<?php

/**

 * Main WordPress Formatting API.

 *

 * Handles many functions for formatting output.

 *

 * @package WordPress

 **/

/**

 * Replaces common plain text characters into formatted entities

 *

 * As an example,

 * <code>

 * 'cause today's effort makes it worth tomorrow's "holiday"...

 * </code>

 * Becomes:

 * <code>

 * ’cause today’s effort makes it worth tomorrow’s “holiday”…

 * </code>

 * Code within certain html blocks are skipped.

 *

 * @since 0.71

 * @uses $wp_cockneyreplace Array of formatted entities for certain common phrases

 *

 * @param string $text The text to be formatted

 * @return string The string replaced with html entities

 */

function wptexturize($text) {

	global $wp_cockneyreplace;

	static $static_setup = false, $opening_quote, $closing_quote, $default_no_texturize_tags, $default_no_texturize_shortcodes, $static_characters, $static_replacements, $dynamic_characters, $dynamic_replacements;

	$output = '';

	$curl = '';

	$textarr = preg_split('/(<.*>|\[.*\])/Us', $text, -1, PREG_SPLIT_DELIM_CAPTURE);

	$stop = count($textarr);

	// No need to setup these variables more than once

	if (!$static_setup) {

		/* translators: opening curly quote */

		$opening_quote = _x('“', 'opening curly quote');

		/* translators: closing curly quote */

		$closing_quote = _x('”', 'closing curly quote');

		$default_no_texturize_tags = array('pre', 'code', 'kbd', 'style', 'script', 'tt');

		$default_no_texturize_shortcodes = array('code');

		// if a plugin has provided an autocorrect array, use it

		if ( isset($wp_cockneyreplace) ) {

			$cockney = array_keys($wp_cockneyreplace);

			$cockneyreplace = array_values($wp_cockneyreplace);

		} else {

			$cockney = array("'tain't","'twere","'twas","'tis","'twill","'til","'bout","'nuff","'round","'cause");

			$cockneyreplace = array("’tain’t","’twere","’twas","’tis","’twill","’til","’bout","’nuff","’round","’cause");

		}

		$static_characters = array_merge(array('---', ' -- ', '--', ' - ', 'xn–', '...', '``', '\'s', '\'\'', ' (tm)'), $cockney);

		$static_replacements = array_merge(array('—', ' — ', '–', ' – ', 'xn--', '…', $opening_quote, '’s', $closing_quote, ' ™'), $cockneyreplace);

		$dynamic_characters = array('/\'(\d\d(?:&#8217;|\')?s)/', '/(\s|\A|[([{<]|")\'/', '/(\d+)"/', '/(\d+)\'/', '/(\S)\'([^\'\s])/', '/(\s|\A|[([{<])"(?!\s)/', '/"(\s|\S|\Z)/', '/\'([\s.]|\Z)/', '/(\d+)x(\d+)/');

		$dynamic_replacements = array('’$1','$1‘', '$1″', '$1′', '$1’$2', '$1' . $opening_quote . '$2', $closing_quote . '$1', '’$1', '$1×$2');

		$static_setup = true;

	}

	// Transform into regexp sub-expression used in _wptexturize_pushpop_element

	// Must do this everytime in case plugins use these filters in a context sensitive manner

	$no_texturize_tags = '(' . implode('|', apply_filters('no_texturize_tags', $default_no_texturize_tags) ) . ')';

	$no_texturize_shortcodes = '(' . implode('|', apply_filters('no_texturize_shortcodes', $default_no_texturize_shortcodes) ) . ')';

	$no_texturize_tags_stack = array();

	$no_texturize_shortcodes_stack = array();

	for ( $i = 0; $i < $stop; $i++ ) {

		$curl = $textarr[$i];

		if ( !empty($curl) && '<' != $curl{0} && '[' != $curl{0}

				&& empty($no_texturize_shortcodes_stack) && empty($no_texturize_tags_stack)) { 

			// This is not a tag, nor is the texturization disabled

			// static strings

			$curl = str_replace($static_characters, $static_replacements, $curl);

			// regular expressions

			$curl = preg_replace($dynamic_characters, $dynamic_replacements, $curl);

		} elseif (!empty($curl)) {

			/*

			 * Only call _wptexturize_pushpop_element if first char is correct

			 * tag opening

			 */

			if ('<' == $curl{0})

				_wptexturize_pushpop_element($curl, $no_texturize_tags_stack, $no_texturize_tags, '<', '>');

			elseif ('[' == $curl{0})

				_wptexturize_pushpop_element($curl, $no_texturize_shortcodes_stack, $no_texturize_shortcodes, '[', ']');

		}

		$curl = preg_replace('/&([^#])(?![a-zA-Z1-4]{1,8};)/', '&$1', $curl);

		$output .= $curl;

	}

	return $output;

}

/**

 * Search for disabled element tags. Push element to stack on tag open and pop

 * on tag close. Assumes first character of $text is tag opening.

 *

 * @access private

 * @since 2.9.0

 *

 * @param string $text Text to check. First character is assumed to be $opening

 * @param array $stack Array used as stack of opened tag elements

 * @param string $disabled_elements Tags to match against formatted as regexp sub-expression

 * @param string $opening Tag opening character, assumed to be 1 character long

 * @param string $opening Tag closing  character

 * @return object

 */

function _wptexturize_pushpop_element($text, &$stack, $disabled_elements, $opening = '<', $closing = '>') {

	// Check if it is a closing tag -- otherwise assume opening tag

	if (strncmp($opening . '/', $text, 2)) {

		// Opening? Check $text+1 against disabled elements

		if (preg_match('/^' . $disabled_elements . '\b/', substr($text, 1), $matches)) {

			/*

			 * This disables texturize until we find a closing tag of our type

			 * (e.g. <pre>) even if there was invalid nesting before that

			 * 

			 * Example: in the case <pre>sadsadasd</code>"baba"</pre>

			 *          "baba" won't be texturize

			 */

			array_push($stack, $matches[1]);

		}

	} else {

		// Closing? Check $text+2 against disabled elements

		$c = preg_quote($closing, '/');

		if (preg_match('/^' . $disabled_elements . $c . '/', substr($text, 2), $matches)) {

			$last = array_pop($stack);

			// Make sure it matches the opening tag

			if ($last != $matches[1])

				array_push($stack, $last);

		}

	}

}

/**

 * Accepts matches array from preg_replace_callback in wpautop() or a string.

 *

 * Ensures that the contents of a <<pre>>...<</pre>> HTML block are not

 * converted into paragraphs or line-breaks.

 *

 * @since 1.2.0

 *

 * @param array|string $matches The array or string

 * @return string The pre block without paragraph/line-break conversion.

 */

function clean_pre($matches) {

	if ( is_array($matches) )

		$text = $matches[1] . $matches[2] . "</pre>";

	else

		$text = $matches;

	$text = str_replace('<br />', '', $text);

	$text = str_replace('<p>', "\n", $text);

	$text = str_replace('</p>', '', $text);

	return $text;

}

/**

 * Replaces double line-breaks with paragraph elements.

 *

 * A group of regex replaces used to identify text formatted with newlines and

 * replace double line-breaks with HTML paragraph tags. The remaining

 * line-breaks after conversion become <<br />> tags, unless $br is set to '0'

 * or 'false'.

 *

 * @since 0.71

 *

 * @param string $pee The text which has to be formatted.

 * @param int|bool $br Optional. If set, this will convert all remaining line-breaks after paragraphing. Default true.

 * @return string Text which has been converted into correct paragraph tags.

 */

function wpautop($pee, $br = 1) {

	if ( trim($pee) === '' )

		return '';

	$pee = $pee . "\n"; // just to make things a little easier, pad the end

	$pee = preg_replace('|<br />\s*<br />|', "\n\n", $pee);

	// Space things out a little

	$allblocks = '(?:table|thead|tfoot|caption|col|colgroup|tbody|tr|td|th|div|dl|dd|dt|ul|ol|li|pre|select|form|map|area|blockquote|address|math|style|input|p|h[1-6]|hr|fieldset|legend)';

	$pee = preg_replace('!(<' . $allblocks . '[^>]*>)!', "\n$1", $pee);

	$pee = preg_replace('!(</' . $allblocks . '>)!', "$1\n\n", $pee);

	$pee = str_replace(array("\r\n", "\r"), "\n", $pee); // cross-platform newlines

	if ( strpos($pee, '<object') !== false ) {

		$pee = preg_replace('|\s*<param([^>]*)>\s*|', "<param$1>", $pee); // no pee inside object/embed

		$pee = preg_replace('|\s*</embed>\s*|', '</embed>', $pee);

	}

	$pee = preg_replace("/\n\n+/", "\n\n", $pee); // take care of duplicates

	// make paragraphs, including one at the end

	$pees = preg_split('/\n\s*\n/', $pee, -1, PREG_SPLIT_NO_EMPTY);

	$pee = '';

	foreach ( $pees as $tinkle )

		$pee .= '<p>' . trim($tinkle, "\n") . "</p>\n";

	$pee = preg_replace('|<p>\s*</p>|', '', $pee); // under certain strange conditions it could create a P of entirely whitespace

	$pee = preg_replace('!<p>([^<]+)</(div|address|form)>!', "<p>$1</p></$2>", $pee);

	$pee = preg_replace('!<p>\s*(</?' . $allblocks . '[^>]*>)\s*</p>!', "$1", $pee); // don't pee all over a tag

	$pee = preg_replace("|<p>(<li.+?)</p>|", "$1", $pee); // problem with nested lists

	$pee = preg_replace('|<p><blockquote([^>]*)>|i', "<blockquote$1><p>", $pee);

	$pee = str_replace('</blockquote></p>', '</p></blockquote>', $pee);

	$pee = preg_replace('!<p>\s*(</?' . $allblocks . '[^>]*>)!', "$1", $pee);

	$pee = preg_replace('!(</?' . $allblocks . '[^>]*>)\s*</p>!', "$1", $pee);

	if ($br) {

		$pee = preg_replace_callback('/<(script|style).*?<\/\\1>/s', create_function('$matches', 'return str_replace("\n", "<WPPreserveNewline />", $matches[0]);'), $pee);

		$pee = preg_replace('|(?<!<br />)\s*\n|', "<br />\n", $pee); // optionally make line breaks

		$pee = str_replace('<WPPreserveNewline />', "\n", $pee);

	}

	$pee = preg_replace('!(</?' . $allblocks . '[^>]*>)\s*<br />!', "$1", $pee);

	$pee = preg_replace('!<br />(\s*</?(?:p|li|div|dl|dd|dt|th|pre|td|ul|ol)[^>]*>)!', '$1', $pee);

	if (strpos($pee, '<pre') !== false)

		$pee = preg_replace_callback('!(<pre[^>]*>)(.*?)</pre>!is', 'clean_pre', $pee );

	$pee = preg_replace( "|\n</p>$|", '</p>', $pee );

	return $pee;

}

/**

 * Don't auto-p wrap shortcodes that stand alone

 *

 * Ensures that shortcodes are not wrapped in <<p>>...<</p>>.

 *

 * @since 2.9.0

 *

 * @param string $pee The content.

 * @return string The filtered content.

 */

function shortcode_unautop($pee) {

	global $shortcode_tags;

	if ( !empty($shortcode_tags) && is_array($shortcode_tags) ) {

		$tagnames = array_keys($shortcode_tags);

		$tagregexp = join( '|', array_map('preg_quote', $tagnames) );

		$pee = preg_replace('/<p>\\s*?(\\[(' . $tagregexp . ')\\b.*?\\/?\\](?:.+?\\[\\/\\2\\])?)\\s*<\\/p>/s', '$1', $pee);

	}

	return $pee;

}

/**

 * Checks to see if a string is utf8 encoded.

 *

 * NOTE: This function checks for 5-Byte sequences, UTF8

 *       has Bytes Sequences with a maximum length of 4.

 *

 * @author bmorel at ssi dot fr (modified)

 * @since 1.2.1

 *

 * @param string $str The string to be checked

 * @return bool True if $str fits a UTF-8 model, false otherwise.

 */

function seems_utf8($str) {

	$length = strlen($str);

	for ($i=0; $i < $length; $i++) {

		$c = ord($str[$i]);

		if ($c < 0x80) $n = 0; # 0bbbbbbb

		elseif (($c & 0xE0) == 0xC0) $n=1; # 110bbbbb

		elseif (($c & 0xF0) == 0xE0) $n=2; # 1110bbbb

		elseif (($c & 0xF8) == 0xF0) $n=3; # 11110bbb

		elseif (($c & 0xFC) == 0xF8) $n=4; # 111110bb

		elseif (($c & 0xFE) == 0xFC) $n=5; # 1111110b

		else return false; # Does not match any model

		for ($j=0; $j<$n; $j++) { # n bytes matching 10bbbbbb follow ?

			if ((++$i == $length) || ((ord($str[$i]) & 0xC0) != 0x80))

				return false;

		}

	}

	return true;

}

/**

 * Converts a number of special characters into their HTML entities.

 *

 * Specifically deals with: &, <, >, ", and '.

 *

 * $quote_style can be set to ENT_COMPAT to encode " to

 * ", or ENT_QUOTES to do both. Default is ENT_NOQUOTES where no quotes are encoded.

 *

 * @since 1.2.2

 *

 * @param string $string The text which is to be encoded.

 * @param mixed $quote_style Optional. Converts double quotes if set to ENT_COMPAT, both single and double if set to ENT_QUOTES or none if set to ENT_NOQUOTES. Also compatible with old values; converting single quotes if set to 'single', double if set to 'double' or both if otherwise set. Default is ENT_NOQUOTES.

 * @param string $charset Optional. The character encoding of the string. Default is false.

 * @param boolean $double_encode Optional. Whether or not to encode existing html entities. Default is false.

 * @return string The encoded text with HTML entities.

 */

function _wp_specialchars( $string, $quote_style = ENT_NOQUOTES, $charset = false, $double_encode = false ) {

	$string = (string) $string;

	if ( 0 === strlen( $string ) ) {

		return '';

	}

	// Don't bother if there are no specialchars - saves some processing

	if ( !preg_match( '/[&<>"\']/', $string ) ) {

		return $string;

	}

	// Account for the previous behaviour of the function when the $quote_style is not an accepted value

	if ( empty( $quote_style ) ) {

		$quote_style = ENT_NOQUOTES;

	} elseif ( !in_array( $quote_style, array( 0, 2, 3, 'single', 'double' ), true ) ) {

		$quote_style = ENT_QUOTES;

	}

	// Store the site charset as a static to avoid multiple calls to wp_load_alloptions()

	if ( !$charset ) {

		static $_charset;

		if ( !isset( $_charset ) ) {

			$alloptions = wp_load_alloptions();

			$_charset = isset( $alloptions['blog_charset'] ) ? $alloptions['blog_charset'] : '';

		}

		$charset = $_charset;

	}

	if ( in_array( $charset, array( 'utf8', 'utf-8', 'UTF8' ) ) ) {

		$charset = 'UTF-8';

	}

	$_quote_style = $quote_style;

	if ( $quote_style === 'double' ) {

		$quote_style = ENT_COMPAT;

		$_quote_style = ENT_COMPAT;

	} elseif ( $quote_style === 'single' ) {

		$quote_style = ENT_NOQUOTES;

	}

	// Handle double encoding ourselves

	if ( !$double_encode ) {

		$string = wp_specialchars_decode( $string, $_quote_style );

		$string = preg_replace( '/&(#?x?[0-9a-z]+);/i', '|wp_entity|$1|/wp_entity|', $string );

	}

	$string = @htmlspecialchars( $string, $quote_style, $charset );

	// Handle double encoding ourselves

	if ( !$double_encode ) {

		$string = str_replace( array( '|wp_entity|', '|/wp_entity|' ), array( '&', ';' ), $string );

	}

	// Backwards compatibility

	if ( 'single' === $_quote_style ) {

		$string = str_replace( "'", ''', $string );

	}

	return $string;

}

/**

 * Converts a number of HTML entities into their special characters.

 *

 * Specifically deals with: &, <, >, ", and '.

 *

 * $quote_style can be set to ENT_COMPAT to decode " entities,

 * or ENT_QUOTES to do both " and '. Default is ENT_NOQUOTES where no quotes are decoded.

 *

 * @since 2.8

 *

 * @param string $string The text which is to be decoded.

 * @param mixed $quote_style Optional. Converts double quotes if set to ENT_COMPAT, both single and double if set to ENT_QUOTES or none if set to ENT_NOQUOTES. Also compatible with old _wp_specialchars() values; converting single quotes if set to 'single', double if set to 'double' or both if otherwise set. Default is ENT_NOQUOTES.

 * @return string The decoded text without HTML entities.

 */

function wp_specialchars_decode( $string, $quote_style = ENT_NOQUOTES ) {

	$string = (string) $string;

	if ( 0 === strlen( $string ) ) {

		return '';

	}

	// Don't bother if there are no entities - saves a lot of processing

	if ( strpos( $string, '&' ) === false ) {

		return $string;

	}

	// Match the previous behaviour of _wp_specialchars() when the $quote_style is not an accepted value

	if ( empty( $quote_style ) ) {

		$quote_style = ENT_NOQUOTES;

	} elseif ( !in_array( $quote_style, array( 0, 2, 3, 'single', 'double' ), true ) ) {

		$quote_style = ENT_QUOTES;

	}

	// More complete than get_html_translation_table( HTML_SPECIALCHARS )

	$single = array( '''  => '\'', ''' => '\'' );

	$single_preg = array( '/&#0*39;/'  => ''', '/&#x0*27;/i' => ''' );

	$double = array( '"' => '"', '"'  => '"', '"' => '"' );

	$double_preg = array( '/&#0*34;/'  => '"', '/&#x0*22;/i' => '"' );

	$others = array( '&lt;'   => '<', '&#060;'  => '<', '&gt;'   => '>', '&#062;'  => '>', '&amp;'  => '&', '&#038;'  => '&', '&#x26;' => '&' );

	$others_preg = array( '/&#0*60;/'  => '<', '/&#0*62;/'  => '>', '/&#0*38;/'  => '&', '/&#x0*26;/i' => '&' );

	if ( $quote_style === ENT_QUOTES ) {

		$translation = array_merge( $single, $double, $others );

		$translation_preg = array_merge( $single_preg, $double_preg, $others_preg );

	} elseif ( $quote_style === ENT_COMPAT || $quote_style === 'double' ) {

		$translation = array_merge( $double, $others );