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

	$output = '';

	$curl = '';

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

	$stop = count($textarr);

	/* translators: opening curly quote */

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

	/* translators: closing curly quote */

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

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

	$no_texturize_shortcodes = apply_filters('no_texturize_shortcodes', array('code'));

	$no_texturize_tags_stack = array();

	$no_texturize_shortcodes_stack = array();

	// 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(?:’|\')?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');

	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)) { // If it's not a tag

			// static strings

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

			// regular expressions

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

		} else {

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

			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;

}

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

	$o = preg_quote($opening, '/');

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

	foreach($disabled_elements as $element) {

		if (preg_match('/^'.$o.$element.'\b/', $text)) array_push($stack, $element);

		if (preg_match('/^'.$o.'\/'.$element.$c.'/', $text)) {

			$last = array_pop($stack);

			// disable 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 texturized

			if ($last != $element) 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)';

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

	$pee = preg_replace('/<p>\s*?(' . get_shortcode_regex() . ')\s*<\/p>/s', '$1', $pee); // don't auto-p wrap shortcodes that stand alone

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

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

	}

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

	static $is_utf8;

	if ( !isset( $is_utf8 ) ) {

		$is_utf8 = in_array( get_option( 'blog_charset' ), array( 'utf8', 'utf-8', 'UTF8', 'UTF-8' ) );

	}

	if ( !$is_utf8 ) {

		return $string;

	}

	// Check for support for utf8 in the installed PCRE library once and store the result in a static

	static $utf8_pcre;

	if ( !isset( $utf8_pcre ) ) {

		$utf8_pcre = @preg_match( '/^./u', 'a' );

	}

	// We can't demand utf8 in the PCRE installation, so just return the string in those cases

	if ( !$utf8_pcre ) {

		return $string;

	}

	// preg_match fails when it encounters invalid UTF8 in $string

	if ( 1 === @preg_match( '/^./us', $string ) ) {

		return $string;

	}

	// Attempt to strip the bad chars if requested (not recommended)

	if ( $strip && function_exists( 'iconv' ) ) {

		return iconv( 'utf-8', 'utf-8', $string );

	}

	return '';

}