<?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_characters, $static_replacements, $dynamic_characters, $dynamic_replacements,

		$default_no_texturize_tags, $default_no_texturize_shortcodes;

	// No need to set up these static variables more than once

	if ( ! isset( $static_characters ) ) {

		/* translators: opening curly double quote */

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

		/* translators: closing curly double quote */

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

		/* translators: apostrophe, for example in 'cause or can't */

		$apos = _x( '’', 'apostrophe' );

		/* translators: prime, for example in 9' (nine feet) */

		$prime = _x( '′', 'prime' );

		/* translators: double prime, for example in 9" (nine inches) */

		$double_prime = _x( '″', 'double prime' );

		/* translators: opening curly single quote */

		$opening_single_quote = _x( '‘', 'opening curly single quote' );

		/* translators: closing curly single quote */

		$closing_single_quote = _x( '’', 'closing curly single quote' );

		/* translators: en dash */

		$en_dash = _x( '–', 'en dash' );

		/* translators: em dash */

		$em_dash = _x( '—', 'em dash' );

		$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);

		} elseif ( "'" != $apos ) { // Only bother if we're doing a replacement.

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

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

		} else {

			$cockney = $cockneyreplace = array();

		}

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

		$static_replacements = array_merge( array( $em_dash, ' ' . $em_dash . ' ', $en_dash, ' ' . $en_dash . ' ', 'xn--', '…', $opening_quote, $closing_quote, ' ™' ), $cockneyreplace );

		$dynamic = array();

		if ( "'" != $apos ) {

			$dynamic[ '/\'(\d\d(?:’|\')?s)/' ] = $apos . '$1'; // '99's

			$dynamic[ '/\'(\d)/'                   ] = $apos . '$1'; // '99

		}

		if ( "'" != $opening_single_quote )

			$dynamic[ '/(\s|\A|[([{<]|")\'/'       ] = '$1' . $opening_single_quote; // opening single quote, even after (, {, <, [

		if ( '"' != $double_prime )

			$dynamic[ '/(\d)"/'                    ] = '$1' . $double_prime; // 9" (double prime)

		if ( "'" != $prime )

			$dynamic[ '/(\d)\'/'                   ] = '$1' . $prime; // 9' (prime)

		if ( "'" != $apos )

			$dynamic[ '/(\S)\'([^\'\s])/'          ] = '$1' . $apos . '$2'; // apostrophe in a word

		if ( '"' != $opening_quote )

			$dynamic[ '/(\s|\A|[([{<])"(?!\s)/'    ] = '$1' . $opening_quote . '$2'; // opening double quote, even after (, {, <, [

		if ( '"' != $closing_quote )

			$dynamic[ '/"(\s|\S|\Z)/'              ] = $closing_quote . '$1'; // closing double quote

		if ( "'" != $closing_single_quote )

			$dynamic[ '/\'([\s.]|\Z)/'             ] = $closing_single_quote . '$1'; // closing single quote

		$dynamic[ '/\b(\d+)x(\d+)\b/'              ] = '$1×$2'; // 9x9 (times)

		$dynamic_characters = array_keys( $dynamic );

		$dynamic_replacements = array_values( $dynamic );

	}

	// Transform into regexp sub-expression used in _wptexturize_pushpop_element

	// Must do this every time 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();

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

	foreach ( $textarr as &$curl ) {

		if ( empty( $curl ) )

			continue;

		// Only call _wptexturize_pushpop_element if first char is correct tag opening

		$first = $curl[0];

		if ( '<' === $first ) {

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

		} elseif ( '[' === $first ) {

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

		} elseif ( 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);

		}

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

	}

	return implode( '', $textarr );

}

/**

 * 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 $closing Tag closing character

 */

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);

		}

	}

}

/**

 * 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 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 = true) {

	$pre_tags = array();

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

		return '';

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

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

		$pee_parts = explode( '</pre>', $pee );

		$last_pee = array_pop($pee_parts);

		$pee = '';

		$i = 0;

		foreach ( $pee_parts as $pee_part ) {

			$start = strpos($pee_part, '<pre');

			// Malformed html?

			if ( $start === false ) {

				$pee .= $pee_part;

				continue;

			}

			$name = "<pre wp-pre-tag-$i></pre>";

			$pre_tags[$name] = substr( $pee_part, $start ) . '</pre>';

			$pee .= substr( $pee_part, 0, $start ) . $name;

			$i++;

		}

		$pee .= $last_pee;

	}

	$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|option|form|map|area|blockquote|address|math|style|p|h[1-6]|hr|fieldset|noscript|samp|legend|section|article|aside|hgroup|header|footer|nav|figure|figcaption|details|menu|summary)';

	$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', '_autop_newline_preservation_helper', $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);

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

	if ( !empty($pre_tags) )

		$pee = str_replace(array_keys($pre_tags), array_values($pre_tags), $pee);

	return $pee;

}

/**

 * Newline preservation help function for wpautop

 *

 * @since 3.1.0

 * @access private

 * @param array $matches preg_replace_callback matches array

 * @return string

 */

function _autop_newline_preservation_helper( $matches ) {

	return str_replace("\n", "<WPPreserveNewline />", $matches[0]);

}

/**

 * 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 ) ) {

		return $pee;

	}

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

	$pattern =

		  '/'

		. '<p>'                              // Opening paragraph

		. '\\s*+'                            // Optional leading whitespace

		. '('                                // 1: The shortcode

		.     '\\['                          // Opening bracket

		.     "($tagregexp)"                 // 2: Shortcode name

		.     '(?![\\w-])'                   // Not followed by word character or hyphen

		                                     // Unroll the loop: Inside the opening shortcode tag

		.     '[^\\]\\/]*'                   // Not a closing bracket or forward slash

		.     '(?:'

		.         '\\/(?!\\])'               // A forward slash not followed by a closing bracket

		.         '[^\\]\\/]*'               // Not a closing bracket or forward slash

		.     ')*?'

		.     '(?:'

		.         '\\/\\]'                   // Self closing tag and closing bracket

		.     '|'

		.         '\\]'                      // Closing bracket

		.         '(?:'                      // Unroll the loop: Optionally, anything between the opening and closing shortcode tags

		.             '[^\\[]*+'             // Not an opening bracket

		.             '(?:'

		.                 '\\[(?!\\/\\2\\])' // An opening bracket not followed by the closing shortcode tag

		.                 '[^\\[]*+'         // Not an opening bracket

		.             ')*+'

		.             '\\[\\/\\2\\]'         // Closing shortcode tag

		.         ')?'

		.     ')'

		. ')'

		. '\\s*+'                            // optional trailing whitespace

		. '<\\/p>'                           // closing paragraph

		. '/s';

	return preg_replace( $pattern, '$1', $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 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 = @htmlspecialchars( $string, $quote_style, $charset );

	} else {

		// Decode & into &

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

		// Guarantee every &entity; is valid or re-encode the &

		$string = wp_kses_normalize_entities( $string );

		// Now re-encode everything except &entity;

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

		for ( $i = 0; $i < count( $string ); $i += 2 )

			$string[$i] = @htmlspecialchars( $string[$i], $quote_style, $charset );

		$string = implode( '', $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 );

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

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

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

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

	} elseif ( $quote_style === ENT_NOQUOTES ) {

		$translation = $others;

		$translation_preg = $others_preg;

	}

	// Remove zero padding on numeric entities

	$string = preg_replace( array_keys( $translation_preg ), array_values( $translation_preg ), $string );

	// Replace characters according to translation table

	return strtr( $string, $translation );

}

/**

 * Checks for invalid UTF8 in a string.

 *

 * @since 2.8

 *

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

 * @param boolean $strip Optional. Whether to attempt to strip out invalid UTF8. Default is false.

 * @return string The checked text.

 */

function wp_check_invalid_utf8( $string, $strip = false ) {

	$string = (string) $string;

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

		return '';