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

    26  *

    27  * @global array $wp_cockneyreplace Array of formatted entities for certain common phrases

    28  * @global array $shortcode_tags

    29  * @staticvar array  $static_characters

    30  * @staticvar array  $static_replacements

    31  * @staticvar array  $dynamic_characters

    32  * @staticvar array  $dynamic_replacements

    33  * @staticvar array  $default_no_texturize_tags

    34  * @staticvar array  $default_no_texturize_shortcodes

    35  * @staticvar bool   $run_texturize

    36  * @staticvar string $apos

    37  * @staticvar string $prime

    38  * @staticvar string $double_prime

    39  * @staticvar string $opening_quote

    40  * @staticvar string $closing_quote

    41  * @staticvar string $opening_single_quote

    42  * @staticvar string $closing_single_quote

    43  * @staticvar string $open_q_flag

    44  * @staticvar string $open_sq_flag

    45  * @staticvar string $apos_flag

    27  * @param bool $reset Set to true for unit testing. Translated patterns will reset.

    48  * @param bool   $reset Set to true for unit testing. Translated patterns will reset.

    30 function wptexturize($text, $reset = false) {

    51 function wptexturize( $text, $reset = false ) {

    32 	static $static_characters, $static_replacements, $dynamic_characters, $dynamic_replacements,

    53 	static $static_characters = null,

    33 		$default_no_texturize_tags, $default_no_texturize_shortcodes, $run_texturize = true;

    54 		$static_replacements = null,

    55 		$dynamic_characters = null,

    56 		$dynamic_replacements = null,

    57 		$default_no_texturize_tags = null,

    58 		$default_no_texturize_shortcodes = null,

    59 		$run_texturize = true,

    60 		$apos = null,

    61 		$prime = null,

    62 		$double_prime = null,

    63 		$opening_quote = null,

    64 		$closing_quote = null,

    65 		$opening_single_quote = null,

    66 		$closing_single_quote = null,

    67 		$open_q_flag = '<!--oq-->',

    68 		$open_sq_flag = '<!--osq-->',

    69 		$apos_flag = '<!--apos-->';

    43 		 * Filter whether to skip running wptexturize().

    79 		 * Filters whether to skip running wptexturize().

    95 			$cockney = $cockneyreplace = array();

   128 			/* translators: This is a comma-separated list of words that defy the syntax of quotations in normal use,

   129 			 * for example...  'We do not have enough words yet' ... is a typical quoted phrase.  But when we write

   130 			 * lines of code 'til we have enough of 'em, then we need to insert apostrophes instead of quotes.

   131 			 */

   132 			$cockney = explode( ',', _x( "'tain't,'twere,'twas,'tis,'twill,'til,'bout,'nuff,'round,'cause,'em",

   133 				'Comma-separated list of words to texturize in your language' ) );

   134 

   135 			$cockneyreplace = explode( ',', _x( '’tain’t,’twere,’twas,’tis,’twill,’til,’bout,’nuff,’round,’cause,’em',

   136 				'Comma-separated list of replacement words in your language' ) );

   111 			$dynamic[ '/\'(\d\d)\'(?=\Z|[.,)}\-\]]|>|' . $spaces . ')/' ] = $apos . '$1' . $closing_single_quote;

   152 			$dynamic[ '/\'(\d\d)\'(?=\Z|[.,:;!?)}\-\]]|>|' . $spaces . ')/' ] = $apos_flag . '$1' . $closing_single_quote;

   114 			$dynamic[ '/\'(\d\d)"(?=\Z|[.,)}\-\]]|>|' . $spaces . ')/' ] = $apos . '$1' . $closing_quote;

   155 			$dynamic[ '/\'(\d\d)"(?=\Z|[.,:;!?)}\-\]]|>|' . $spaces . ')/' ] = $apos_flag . '$1' . $closing_quote;

   119 			$dynamic[ '/\'(?=\d\d(?:\Z|(?![%\d]|[.,]\d)))/' ] = $apos;

   160 			$dynamic[ '/\'(?=\d\d(?:\Z|(?![%\d]|[.,]\d)))/' ] = $apos_flag;

   124 			$dynamic[ '/(?<=\A|' . $spaces . ')\'(\d[.,\d]*)\'/' ] = $opening_single_quote . '$1' . $closing_single_quote;

   165 			$dynamic[ '/(?<=\A|' . $spaces . ')\'(\d[.,\d]*)\'/' ] = $open_sq_flag . '$1' . $closing_single_quote;

   129 			$dynamic[ '/(?<=\A|[([{"\-]|&lt;|' . $spaces . ')\'/' ] = $opening_single_quote;

   170 			$dynamic[ '/(?<=\A|[([{"\-]|&lt;|' . $spaces . ')\'/' ] = $open_sq_flag;

   134 			$dynamic[ '/(?<!' . $spaces . ')\'(?!\Z|[.,:;"\'(){}[\]\-]|&[lg]t;|' . $spaces . ')/' ] = $apos;

   175 			$dynamic[ '/(?<!' . $spaces . ')\'(?!\Z|[.,:;!?"\'(){}[\]\-]|&[lg]t;|' . $spaces . ')/' ] = $apos_flag;

   135 		}

   136 

   137 		// 9' (prime)

   138 		if ( "'" !== $prime ) {

   139 			$dynamic[ '/(?<=\d)\'/' ] = $prime;

   140 		}

   141 

   142 		// Single quotes followed by spaces or ending punctuation.

   143 		if ( "'" !== $closing_single_quote ) {

   144 			$dynamic[ '/\'(?=\Z|[.,)}\-\]]|>|' . $spaces . ')/' ] = $closing_single_quote;

   153 			$dynamic[ '/(?<=\A|' . $spaces . ')"(\d[.,\d]*)"/' ] = $opening_quote . '$1' . $closing_quote;

   184 			$dynamic[ '/(?<=\A|' . $spaces . ')"(\d[.,\d]*)"/' ] = $open_q_flag . '$1' . $closing_quote;

   154 		}

   155 

   156 		// 9" (double prime)

   157 		if ( '"' !== $double_prime ) {

   158 			$dynamic[ '/(?<=\d)"/' ] = $double_prime;

   163 			$dynamic[ '/(?<=\A|[([{\-]|&lt;|' . $spaces . ')"(?!' . $spaces . ')/' ] = $opening_quote;

   189 			$dynamic[ '/(?<=\A|[([{\-]|&lt;|' . $spaces . ')"(?!' . $spaces . ')/' ] = $open_q_flag;

   164 		}

   165 

   166 		// Any remaining double quotes.

   167 		if ( '"' !== $closing_quote ) {

   168 			$dynamic[ '/"/' ] = $closing_quote;

   187 	 * Filter the list of HTML elements not to texturize.

   208 	 * Filters the list of HTML elements not to texturize.

   195 	 * Filter the list of shortcodes not to texturize.

   216 	 * Filters the list of shortcodes not to texturize.

   208 	$tagnames = array_keys( $shortcode_tags );

   229 	preg_match_all( '@\[/?([^<>&/\[\]\x00-\x20=]++)@', $text, $matches );

   230 	$tagnames = array_intersect( array_keys( $shortcode_tags ), $matches[1] );

   231 	$found_shortcodes = ! empty( $tagnames );

   232 	$shortcode_regex = $found_shortcodes ? _get_wptexturize_shortcode_regex( $tagnames ) : '';

   233 	$regex = _get_wptexturize_split_regex( $shortcode_regex );

   234 

   235 	$textarr = preg_split( $regex, $text, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY );

   236 

   237 	foreach ( $textarr as &$curl ) {

   238 		// Only call _wptexturize_pushpop_element if $curl is a delimiter.

   239 		$first = $curl[0];

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

   241 			if ( '<!--' === substr( $curl, 0, 4 ) ) {

   242 				// This is an HTML comment delimiter.

   243 				continue;

   244 			} else {

   245 				// This is an HTML element delimiter.

   246 

   247 				// Replace each & with & unless it already looks like an entity.

   248 				$curl = preg_replace( '/&(?!#(?:\d+|x[a-f0-9]+);|[a-z1-4]{1,8};)/i', '&', $curl );

   249 

   250 				_wptexturize_pushpop_element( $curl, $no_texturize_tags_stack, $no_texturize_tags );

   251 			}

   252 

   253 		} elseif ( '' === trim( $curl ) ) {

   254 			// This is a newline between delimiters.  Performance improves when we check this.

   255 			continue;

   256 

   257 		} elseif ( '[' === $first && $found_shortcodes && 1 === preg_match( '/^' . $shortcode_regex . '$/', $curl ) ) {

   258 			// This is a shortcode delimiter.

   259 

   260 			if ( '[[' !== substr( $curl, 0, 2 ) && ']]' !== substr( $curl, -2 ) ) {

   261 				// Looks like a normal shortcode.

   262 				_wptexturize_pushpop_element( $curl, $no_texturize_shortcodes_stack, $no_texturize_shortcodes );

   263 			} else {

   264 				// Looks like an escaped shortcode.

   265 				continue;

   266 			}

   267 

   268 		} elseif ( empty( $no_texturize_shortcodes_stack ) && empty( $no_texturize_tags_stack ) ) {

   269 			// This is neither a delimiter, nor is this content inside of no_texturize pairs.  Do texturize.

   270 

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

   272 

   273 			if ( false !== strpos( $curl, "'" ) ) {

   274 				$curl = preg_replace( $dynamic_characters['apos'], $dynamic_replacements['apos'], $curl );

   275 				$curl = wptexturize_primes( $curl, "'", $prime, $open_sq_flag, $closing_single_quote );

   276 				$curl = str_replace( $apos_flag, $apos, $curl );

   277 				$curl = str_replace( $open_sq_flag, $opening_single_quote, $curl );

   278 			}

   279 			if ( false !== strpos( $curl, '"' ) ) {

   280 				$curl = preg_replace( $dynamic_characters['quote'], $dynamic_replacements['quote'], $curl );

   281 				$curl = wptexturize_primes( $curl, '"', $double_prime, $open_q_flag, $closing_quote );

   282 				$curl = str_replace( $open_q_flag, $opening_quote, $curl );

   283 			}

   284 			if ( false !== strpos( $curl, '-' ) ) {

   285 				$curl = preg_replace( $dynamic_characters['dash'], $dynamic_replacements['dash'], $curl );

   286 			}

   287 

   288 			// 9x9 (times), but never 0x9999

   289 			if ( 1 === preg_match( '/(?<=\d)x\d/', $curl ) ) {

   290 				// Searching for a digit is 10 times more expensive than for the x, so we avoid doing this one!

   291 				$curl = preg_replace( '/\b(\d(?(?<=0)[\d\.,]+|[\d\.,]*))x(\d[\d\.,]*)\b/', '$1&#215;$2', $curl );

   292 			}

   293 

   294 			// Replace each & with & unless it already looks like an entity.

   295 			$curl = preg_replace( '/&(?!#(?:\d+|x[a-f0-9]+);|[a-z1-4]{1,8};)/i', '&', $curl );

   296 		}

   297 	}

   298 

   299 	return implode( '', $textarr );

   300 }

   301 

   302 /**

   303  * Implements a logic tree to determine whether or not "7'." represents seven feet,

   304  * then converts the special char into either a prime char or a closing quote char.

   305  *

   306  * @since 4.3.0

   307  *

   308  * @param string $haystack    The plain text to be searched.

   309  * @param string $needle      The character to search for such as ' or ".

   310  * @param string $prime       The prime char to use for replacement.

   311  * @param string $open_quote  The opening quote char. Opening quote replacement must be

   312  *                            accomplished already.

   313  * @param string $close_quote The closing quote char to use for replacement.

   314  * @return string The $haystack value after primes and quotes replacements.

   315  */

   316 function wptexturize_primes( $haystack, $needle, $prime, $open_quote, $close_quote ) {

   317 	$spaces = wp_spaces_regexp();

   318 	$flag = '<!--wp-prime-or-quote-->';

   319 	$quote_pattern = "/$needle(?=\\Z|[.,:;!?)}\\-\\]]|>|" . $spaces . ")/";

   320 	$prime_pattern    = "/(?<=\\d)$needle/";

   321 	$flag_after_digit = "/(?<=\\d)$flag/";

   322 	$flag_no_digit    = "/(?<!\\d)$flag/";

   323 

   324 	$sentences = explode( $open_quote, $haystack );

   325 

   326 	foreach ( $sentences as $key => &$sentence ) {

   327 		if ( false === strpos( $sentence, $needle ) ) {

   328 			continue;

   329 		} elseif ( 0 !== $key && 0 === substr_count( $sentence, $close_quote ) ) {

   330 			$sentence = preg_replace( $quote_pattern, $flag, $sentence, -1, $count );

   331 			if ( $count > 1 ) {

   332 				// This sentence appears to have multiple closing quotes.  Attempt Vulcan logic.

   333 				$sentence = preg_replace( $flag_no_digit, $close_quote, $sentence, -1, $count2 );

   334 				if ( 0 === $count2 ) {

   335 					// Try looking for a quote followed by a period.

   336 					$count2 = substr_count( $sentence, "$flag." );

   337 					if ( $count2 > 0 ) {

   338 						// Assume the rightmost quote-period match is the end of quotation.

   339 						$pos = strrpos( $sentence, "$flag." );

   340 					} else {

   341 						// When all else fails, make the rightmost candidate a closing quote.

   342 						// This is most likely to be problematic in the context of bug #18549.

   343 						$pos = strrpos( $sentence, $flag );

   344 					}

   345 					$sentence = substr_replace( $sentence, $close_quote, $pos, strlen( $flag ) );

   346 				}

   347 				// Use conventional replacement on any remaining primes and quotes.

   348 				$sentence = preg_replace( $prime_pattern, $prime, $sentence );

   349 				$sentence = preg_replace( $flag_after_digit, $prime, $sentence );

   350 				$sentence = str_replace( $flag, $close_quote, $sentence );

   351 			} elseif ( 1 == $count ) {

   352 				// Found only one closing quote candidate, so give it priority over primes.

   353 				$sentence = str_replace( $flag, $close_quote, $sentence );

   354 				$sentence = preg_replace( $prime_pattern, $prime, $sentence );

   355 			} else {

   356 				// No closing quotes found.  Just run primes pattern.

   357 				$sentence = preg_replace( $prime_pattern, $prime, $sentence );

   358 			}

   359 		} else {

   360 			$sentence = preg_replace( $prime_pattern, $prime, $sentence );

   361 			$sentence = preg_replace( $quote_pattern, $close_quote, $sentence );

   362 		}

   363 		if ( '"' == $needle && false !== strpos( $sentence, '"' ) ) {

   364 			$sentence = str_replace( '"', $close_quote, $sentence );

   365 		}

   366 	}

   367 

   368 	return implode( $open_quote, $sentences );

   369 }

   370 

   371 /**

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

   373  * on tag close.

   374  *

   375  * Assumes first char of $text is tag opening and last char is tag closing.

   376  * Assumes second char of $text is optionally '/' to indicate closing as in </html>.

   377  *

   378  * @since 2.9.0

   379  * @access private

   380  *

   381  * @param string $text Text to check. Must be a tag like `<html>` or `[shortcode]`.

   382  * @param array  $stack List of open tag elements.

   383  * @param array  $disabled_elements The tag names to match against. Spaces are not allowed in tag names.

   384  */

   385 function _wptexturize_pushpop_element( $text, &$stack, $disabled_elements ) {

   386 	// Is it an opening tag or closing tag?

   387 	if ( isset( $text[1] ) && '/' !== $text[1] ) {

   388 		$opening_tag = true;

   389 		$name_offset = 1;

   390 	} elseif ( 0 == count( $stack ) ) {

   391 		// Stack is empty. Just stop.

   392 		return;

   393 	} else {

   394 		$opening_tag = false;

   395 		$name_offset = 2;

   396 	}

   397 

   398 	// Parse out the tag name.

   399 	$space = strpos( $text, ' ' );

   400 	if ( false === $space ) {

   401 		$space = -1;

   402 	} else {

   403 		$space -= $name_offset;

   404 	}

   405 	$tag = substr( $text, $name_offset, $space );

   406 

   407 	// Handle disabled tags.

   408 	if ( in_array( $tag, $disabled_elements ) ) {

   409 		if ( $opening_tag ) {

   410 			/*

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

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

   413 			 *

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

   415 			 *          "baba" won't be texturize

   416 			 */

   417 

   418 			array_push( $stack, $tag );

   419 		} elseif ( end( $stack ) == $tag ) {

   420 			array_pop( $stack );

   421 		}

   422 	}

   423 }

   424 

   425 /**

   426  * Replaces double line-breaks with paragraph elements.

   427  *

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

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

   430  * after conversion become <<br />> tags, unless $br is set to '0' or 'false'.

   431  *

   432  * @since 0.71

   433  *

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

   435  * @param bool   $br  Optional. If set, this will convert all remaining line-breaks

   436  *                    after paragraphing. Default true.

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

   438  */

   439 function wpautop( $pee, $br = true ) {

   440 	$pre_tags = array();

   441 

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

   443 		return '';

   444 

   445 	// Just to make things a little easier, pad the end.

   446 	$pee = $pee . "\n";

   447 

   448 	/*

   449 	 * Pre tags shouldn't be touched by autop.

   450 	 * Replace pre tags with placeholders and bring them back after autop.

   451 	 */

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

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

   454 		$last_pee = array_pop($pee_parts);

   455 		$pee = '';

   456 		$i = 0;

   457 

   458 		foreach ( $pee_parts as $pee_part ) {

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

   460 

   461 			// Malformed html?

   462 			if ( $start === false ) {

   463 				$pee .= $pee_part;

   464 				continue;

   465 			}

   466 

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

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

   469 

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

   471 			$i++;

   472 		}

   473 

   474 		$pee .= $last_pee;

   475 	}

   476 	// Change multiple <br>s into two line breaks, which will turn into paragraphs.

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

   478 

   479 	$allblocks = '(?:table|thead|tfoot|caption|col|colgroup|tbody|tr|td|th|div|dl|dd|dt|ul|ol|li|pre|form|map|area|blockquote|address|math|style|p|h[1-6]|hr|fieldset|legend|section|article|aside|hgroup|header|footer|nav|figure|figcaption|details|menu|summary)';

   480 

   481 	// Add a double line break above block-level opening tags.

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

   483 

   484 	// Add a double line break below block-level closing tags.

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

   486 

   487 	// Standardize newline characters to "\n".

   488 	$pee = str_replace(array("\r\n", "\r"), "\n", $pee);

   489 

   490 	// Find newlines in all elements and add placeholders.

   491 	$pee = wp_replace_in_html_tags( $pee, array( "\n" => " <!-- wpnl --> " ) );

   492 

   493 	// Collapse line breaks before and after <option> elements so they don't get autop'd.

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

   495 		$pee = preg_replace( '|\s*<option|', '<option', $pee );

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

   497 	}

   498 

   499 	/*

   500 	 * Collapse line breaks inside <object> elements, before <param> and <embed> elements

   501 	 * so they don't get autop'd.

   502 	 */

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

   504 		$pee = preg_replace( '|(<object[^>]*>)\s*|', '$1', $pee );

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

   506 		$pee = preg_replace( '%\s*(</?(?:param|embed)[^>]*>)\s*%', '$1', $pee );

   507 	}

   508 

   509 	/*

   510 	 * Collapse line breaks inside <audio> and <video> elements,

   511 	 * before and after <source> and <track> elements.

   512 	 */

   513 	if ( strpos( $pee, '<source' ) !== false || strpos( $pee, '<track' ) !== false ) {

   514 		$pee = preg_replace( '%([<\[](?:audio|video)[^>\]]*[>\]])\s*%', '$1', $pee );

   515 		$pee = preg_replace( '%\s*([<\[]/(?:audio|video)[>\]])%', '$1', $pee );

   516 		$pee = preg_replace( '%\s*(<(?:source|track)[^>]*>)\s*%', '$1', $pee );

   517 	}

   518 

   519 	// Collapse line breaks before and after <figcaption> elements.

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

   521 		$pee = preg_replace( '|\s*(<figcaption[^>]*>)|', '$1', $pee );

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

   523 	}

   524 

   525 	// Remove more than two contiguous line breaks.

   526 	$pee = preg_replace("/\n\n+/", "\n\n", $pee);

   527 

   528 	// Split up the contents into an array of strings, separated by double line breaks.

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

   530 

   531 	// Reset $pee prior to rebuilding.

   532 	$pee = '';

   533 

   534 	// Rebuild the content as a string, wrapping every bit with a <p>.

   535 	foreach ( $pees as $tinkle ) {

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

   537 	}

   538 

   539 	// Under certain strange conditions it could create a P of entirely whitespace.

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

   541 

   542 	// Add a closing <p> inside <div>, <address>, or <form> tag if missing.

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

   544 

   545 	// If an opening or closing block element tag is wrapped in a <p>, unwrap it.

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

   547 

   548 	// In some cases <li> may get wrapped in <p>, fix them.

   549 	$pee = preg_replace("|<p>(<li.+?)</p>|", "$1", $pee);

   550 

   551 	// If a <blockquote> is wrapped with a <p>, move it inside the <blockquote>.

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

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

   554 

   555 	// If an opening or closing block element tag is preceded by an opening <p> tag, remove it.

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

   557 

   558 	// If an opening or closing block element tag is followed by a closing <p> tag, remove it.

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

   560 

   561 	// Optionally insert line breaks.

   562 	if ( $br ) {

   563 		// Replace newlines that shouldn't be touched with a placeholder.

   564 		$pee = preg_replace_callback('/<(script|style).*?<\/\\1>/s', '_autop_newline_preservation_helper', $pee);

   565 

   566 		// Normalize <br>

   567 		$pee = str_replace( array( '<br>', '<br/>' ), '<br />', $pee );

   568 

   569 		// Replace any new line characters that aren't preceded by a <br /> with a <br />.

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

   571 

   572 		// Replace newline placeholders with newlines.

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

   574 	}

   575 

   576 	// If a <br /> tag is after an opening or closing block tag, remove it.

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

   578 

   579 	// If a <br /> tag is before a subset of opening or closing block tags, remove it.

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

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

   582 

   583 	// Replace placeholder <pre> tags with their original content.

   584 	if ( !empty($pre_tags) )

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

   586 

   587 	// Restore newlines in all elements.

   588 	if ( false !== strpos( $pee, '<!-- wpnl -->' ) ) {

   589 		$pee = str_replace( array( ' <!-- wpnl --> ', '<!-- wpnl -->' ), "\n", $pee );

   590 	}

   591 

   592 	return $pee;

   593 }

   594 

   595 /**

   596  * Separate HTML elements and comments from the text.

   597  *

   598  * @since 4.2.4

   599  *

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

   601  * @return array The formatted text.

   602  */

   603 function wp_html_split( $input ) {

   604 	return preg_split( get_html_split_regex(), $input, -1, PREG_SPLIT_DELIM_CAPTURE );

   605 }

   606 

   607 /**

   608  * Retrieve the regular expression for an HTML element.

   609  *

   610  * @since 4.4.0

   611  *

   612  * @staticvar string $regex

   613  *

   614  * @return string The regular expression

   615  */

   616 function get_html_split_regex() {

   617 	static $regex;

   618 

   619 	if ( ! isset( $regex ) ) {

   620 		$comments =

   621 			  '!'           // Start of comment, after the <.

   622 			. '(?:'         // Unroll the loop: Consume everything until --> is found.

   623 			.     '-(?!->)' // Dash not followed by end of comment.

   624 			.     '[^\-]*+' // Consume non-dashes.

   625 			. ')*+'         // Loop possessively.

   626 			. '(?:-->)?';   // End of comment. If not found, match all input.

   627 

   628 		$cdata =

   629 			  '!\[CDATA\['  // Start of comment, after the <.

   630 			. '[^\]]*+'     // Consume non-].

   631 			. '(?:'         // Unroll the loop: Consume everything until ]]> is found.

   632 			.     '](?!]>)' // One ] not followed by end of comment.

   633 			.     '[^\]]*+' // Consume non-].

   634 			. ')*+'         // Loop possessively.

   635 			. '(?:]]>)?';   // End of comment. If not found, match all input.

   636 

   637 		$escaped =

   638 			  '(?='           // Is the element escaped?

   639 			.    '!--'

   640 			. '|'

   641 			.    '!\[CDATA\['

   642 			. ')'

   643 			. '(?(?=!-)'      // If yes, which type?

   644 			.     $comments

   645 			. '|'

   646 			.     $cdata

   647 			. ')';

   648 

   649 		$regex =

   650 			  '/('              // Capture the entire match.

   651 			.     '<'           // Find start of element.

   652 			.     '(?'          // Conditional expression follows.

   653 			.         $escaped  // Find end of escaped element.

   654 			.     '|'           // ... else ...

   655 			.         '[^>]*>?' // Find end of normal element.

   656 			.     ')'

   657 			. ')/';

   658 	}

   659 

   660 	return $regex;

   661 }

   662 

   663 /**

   664  * Retrieve the combined regular expression for HTML and shortcodes.

   665  *

   666  * @access private

   667  * @ignore

   668  * @internal This function will be removed in 4.5.0 per Shortcode API Roadmap.

   669  * @since 4.4.0

   670  *

   671  * @staticvar string $html_regex

   672  *

   673  * @param string $shortcode_regex The result from _get_wptexturize_shortcode_regex().  Optional.

   674  * @return string The regular expression

   675  */

   676 function _get_wptexturize_split_regex( $shortcode_regex = '' ) {

   677 	static $html_regex;

   678 

   679 	if ( ! isset( $html_regex ) ) {

   680 		$comment_regex =

   681 			  '!'           // Start of comment, after the <.

   682 			. '(?:'         // Unroll the loop: Consume everything until --> is found.

   683 			.     '-(?!->)' // Dash not followed by end of comment.

   684 			.     '[^\-]*+' // Consume non-dashes.

   685 			. ')*+'         // Loop possessively.

   686 			. '(?:-->)?';   // End of comment. If not found, match all input.

   687 

   688 		$html_regex =			 // Needs replaced with wp_html_split() per Shortcode API Roadmap.

   689 			  '<'                // Find start of element.

   690 			. '(?(?=!--)'        // Is this a comment?

   691 			.     $comment_regex // Find end of comment.

   692 			. '|'

   693 			.     '[^>]*>?'      // Find end of element. If not found, match all input.

   694 			. ')';

   695 	}

   696 

   697 	if ( empty( $shortcode_regex ) ) {

   698 		$regex = '/(' . $html_regex . ')/';

   699 	} else {

   700 		$regex = '/(' . $html_regex . '|' . $shortcode_regex . ')/';

   701 	}

   702 

   703 	return $regex;

   704 }

   705 

   706 /**

   707  * Retrieve the regular expression for shortcodes.

   708  *

   709  * @access private

   710  * @ignore

   711  * @internal This function will be removed in 4.5.0 per Shortcode API Roadmap.

   712  * @since 4.4.0

   713  *

   714  * @param array $tagnames List of shortcodes to find.

   715  * @return string The regular expression

   716  */

   717 function _get_wptexturize_shortcode_regex( $tagnames ) {

   210 	$tagregexp = "(?:$tagregexp)(?![\\w-])"; // Excerpt of get_shortcode_regex().

   719 	$tagregexp = "(?:$tagregexp)(?=[\\s\\]\\/])"; // Excerpt of get_shortcode_regex().

   211 

   720 	$regex =

   212 	$comment_regex =

   213 		  '!'           // Start of comment, after the <.

   214 		. '(?:'         // Unroll the loop: Consume everything until --> is found.

   215 		.     '-(?!->)' // Dash not followed by end of comment.

   216 		.     '[^\-]*+' // Consume non-dashes.

   217 		. ')*+'         // Loop possessively.

   218 		. '(?:-->)?';   // End of comment. If not found, match all input.

   219 

   220 	$shortcode_regex =

   232 	$regex =

   732 	return $regex;

   233 		  '/('                   // Capture the entire match.

   733 }

   234 		.     '<'                // Find start of element.

   734 

   235 		.     '(?(?=!--)'        // Is this a comment?

   735 /**

   236 		.         $comment_regex // Find end of comment.

   736  * Replace characters or phrases within HTML elements only.

   237 		.     '|'

   737  *

   238 		.         '[^>]*>'       // Find end of element.

   738  * @since 4.2.3

   239 		.     ')'

   739  *

   240 		. '|'

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

   241 		.     $shortcode_regex   // Find shortcodes.

   741  * @param array $replace_pairs In the form array('from' => 'to', ...).

   242 		. ')/s';

   742  * @return string The formatted text.

   243 

   743  */

   244 	$textarr = preg_split( $regex, $text, -1, PREG_SPLIT_DELIM_CAPTURE | PREG_SPLIT_NO_EMPTY );

   744 function wp_replace_in_html_tags( $haystack, $replace_pairs ) {

   245 

   745 	// Find all elements.

   246 	foreach ( $textarr as &$curl ) {

   746 	$textarr = wp_html_split( $haystack );

   247 		// Only call _wptexturize_pushpop_element if $curl is a delimiter.

   747 	$changed = false;

   248 		$first = $curl[0];

   748 

   249 		if ( '<' === $first && '<!--' === substr( $curl, 0, 4 ) ) {

   749 	// Optimize when searching for one item.

   250 			// This is an HTML comment delimeter.

   750 	if ( 1 === count( $replace_pairs ) ) {

   251 

   751 		// Extract $needle and $replace.

   252 			continue;

   752 		foreach ( $replace_pairs as $needle => $replace );

   253 

   753 

   254 		} elseif ( '<' === $first && '>' === substr( $curl, -1 ) ) {

   754 		// Loop through delimiters (elements) only.

   255 			// This is an HTML element delimiter.

   755 		for ( $i = 1, $c = count( $textarr ); $i < $c; $i += 2 ) {

   256 

   756 			if ( false !== strpos( $textarr[$i], $needle ) ) {

   257 			_wptexturize_pushpop_element( $curl, $no_texturize_tags_stack, $no_texturize_tags );

   757 				$textarr[$i] = str_replace( $needle, $replace, $textarr[$i] );

   258 

   758 				$changed = true;

   259 		} elseif ( '' === trim( $curl ) ) {

   260 			// This is a newline between delimiters.  Performance improves when we check this.

   261 

   262 			continue;

   263 

   264 		} elseif ( '[' === $first && 1 === preg_match( '/^' . $shortcode_regex . '$/', $curl ) ) {

   265 			// This is a shortcode delimiter.

   266 

   267 			if ( '[[' !== substr( $curl, 0, 2 ) && ']]' !== substr( $curl, -2 ) ) {

   268 				// Looks like a normal shortcode.

   269 				_wptexturize_pushpop_element( $curl, $no_texturize_shortcodes_stack, $no_texturize_shortcodes );

   270 			} else {

   271 				// Looks like an escaped shortcode.

   272 				continue;

   274 

   760 		}

   275 		} elseif ( empty( $no_texturize_shortcodes_stack ) && empty( $no_texturize_tags_stack ) ) {

   761 	} else {

   276 			// This is neither a delimiter, nor is this content inside of no_texturize pairs.  Do texturize.

   762 		// Extract all $needles.

   277 

   763 		$needles = array_keys( $replace_pairs );

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

   764 

   279 

   765 		// Loop through delimiters (elements) only.

   280 			if ( false !== strpos( $curl, "'" ) ) {

   766 		for ( $i = 1, $c = count( $textarr ); $i < $c; $i += 2 ) {

   281 				$curl = preg_replace( $dynamic_characters['apos'], $dynamic_replacements['apos'], $curl );

   767 			foreach ( $needles as $needle ) {

   768 				if ( false !== strpos( $textarr[$i], $needle ) ) {

   769 					$textarr[$i] = strtr( $textarr[$i], $replace_pairs );

   770 					$changed = true;

   771 					// After one strtr() break out of the foreach loop and look at next element.

   772 					break;

   773 				}

   283 			if ( false !== strpos( $curl, '"' ) ) {

   775 		}

   284 				$curl = preg_replace( $dynamic_characters['quote'], $dynamic_replacements['quote'], $curl );

   776 	}

   285 			}

   777 

   286 			if ( false !== strpos( $curl, '-' ) ) {

   778 	if ( $changed ) {

   287 				$curl = preg_replace( $dynamic_characters['dash'], $dynamic_replacements['dash'], $curl );

   779 		$haystack = implode( $textarr );

   288 			}

   780 	}

   289 

   781 

   290 			// 9x9 (times), but never 0x9999

   782 	return $haystack;

   291 			if ( 1 === preg_match( '/(?<=\d)x\d/', $curl ) ) {

   292 				// Searching for a digit is 10 times more expensive than for the x, so we avoid doing this one!

   293 				$curl = preg_replace( '/\b(\d(?(?<=0)[\d\.,]+|[\d\.,]*))x(\d[\d\.,]*)\b/', '$1&#215;$2', $curl );

   294 			}

   295 		}

   296 	}

   297 	$text = implode( '', $textarr );

   298 

   299 	// Replace each & with & unless it already looks like an entity.

   300 	$text = preg_replace('/&(?!#(?:\d+|x[a-f0-9]+);|[a-z1-4]{1,8};)/i', '&', $text);

   301 

   302 	return $text;

   303 }

   304 

   305 /**

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

   307  * on tag close.

   308  *

   309  * Assumes first char of $text is tag opening and last char is tag closing.

   310  * Assumes second char of $text is optionally '/' to indicate closing as in </html>.

   311  *

   312  * @since 2.9.0

   313  * @access private

   314  *

   315  * @param string $text Text to check. Must be a tag like `<html>` or `[shortcode]`.

   316  * @param array $stack List of open tag elements.

   317  * @param array $disabled_elements The tag names to match against. Spaces are not allowed in tag names.

   318  */

   319 function _wptexturize_pushpop_element($text, &$stack, $disabled_elements) {

   320 	// Is it an opening tag or closing tag?

   321 	if ( '/' !== $text[1] ) {

   322 		$opening_tag = true;

   323 		$name_offset = 1;

   324 	} elseif ( 0 == count( $stack ) ) {

   325 		// Stack is empty. Just stop.

   326 		return;

   327 	} else {

   328 		$opening_tag = false;

   329 		$name_offset = 2;

   330 	}

   331 

   332 	// Parse out the tag name.

   333 	$space = strpos( $text, ' ' );

   334 	if ( false === $space ) {

   335 		$space = -1;

   336 	} else {

   337 		$space -= $name_offset;

   338 	}

   339 	$tag = substr( $text, $name_offset, $space );

   340 

   341 	// Handle disabled tags.

   342 	if ( in_array( $tag, $disabled_elements ) ) {

   343 		if ( $opening_tag ) {

   344 			/*

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

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

   347 			 *

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

   349 			 *          "baba" won't be texturize

   350 			 */

   351 

   352 			array_push( $stack, $tag );

   353 		} elseif ( end( $stack ) == $tag ) {

   354 			array_pop( $stack );

   355 		}

   356 	}

   357 }

   358 

   359 /**

   360  * Replaces double line-breaks with paragraph elements.

   361  *

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

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

   364  * after conversion become <<br />> tags, unless $br is set to '0' or 'false'.

   365  *

   366  * @since 0.71

   367  *

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

   369  * @param bool   $br  Optional. If set, this will convert all remaining line-breaks

   370  *                    after paragraphing. Default true.

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

   372  */

   373 function wpautop($pee, $br = true) {

   374 	$pre_tags = array();

   375 

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

   377 		return '';

   378 

   379 	// Just to make things a little easier, pad the end.

   380 	$pee = $pee . "\n";

   381 

   382 	/*

   383 	 * Pre tags shouldn't be touched by autop.

   384 	 * Replace pre tags with placeholders and bring them back after autop.

   385 	 */

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

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

   388 		$last_pee = array_pop($pee_parts);

   389 		$pee = '';

   390 		$i = 0;

   391 

   392 		foreach ( $pee_parts as $pee_part ) {

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

   394 

   395 			// Malformed html?

   396 			if ( $start === false ) {

   397 				$pee .= $pee_part;

   398 				continue;

   399 			}

   400 

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

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

   403 

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

   405 			$i++;

   406 		}

   407 

   408 		$pee .= $last_pee;

   409 	}

   410 	// Change multiple <br>s into two line breaks, which will turn into paragraphs.

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

   412 

   413 	$allblocks = '(?:table|thead|tfoot|caption|col|colgroup|tbody|tr|td|th|div|dl|dd|dt|ul|ol|li|pre|form|map|area|blockquote|address|math|style|p|h[1-6]|hr|fieldset|legend|section|article|aside|hgroup|header|footer|nav|figure|figcaption|details|menu|summary)';

   414 

   415 	// Add a single line break above block-level opening tags.

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

   417 

   418 	// Add a double line break below block-level closing tags.

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

   420 

   421 	// Standardize newline characters to "\n".

   422 	$pee = str_replace(array("\r\n", "\r"), "\n", $pee); 

   423 

   424 	// Collapse line breaks before and after <option> elements so they don't get autop'd.

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

   426 		$pee = preg_replace( '|\s*<option|', '<option', $pee );

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

   428 	}

   429 

   430 	/*

   431 	 * Collapse line breaks inside <object> elements, before <param> and <embed> elements

   432 	 * so they don't get autop'd.

   433 	 */

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

   435 		$pee = preg_replace( '|(<object[^>]*>)\s*|', '$1', $pee );

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

   437 		$pee = preg_replace( '%\s*(</?(?:param|embed)[^>]*>)\s*%', '$1', $pee );

   438 	}

   439 

   440 	/*

   441 	 * Collapse line breaks inside <audio> and <video> elements,

   442 	 * before and after <source> and <track> elements.

   443 	 */

   444 	if ( strpos( $pee, '<source' ) !== false || strpos( $pee, '<track' ) !== false ) {

   445 		$pee = preg_replace( '%([<\[](?:audio|video)[^>\]]*[>\]])\s*%', '$1', $pee );

   446 		$pee = preg_replace( '%\s*([<\[]/(?:audio|video)[>\]])%', '$1', $pee );

   447 		$pee = preg_replace( '%\s*(<(?:source|track)[^>]*>)\s*%', '$1', $pee );

   448 	}

   449 

   450 	// Remove more than two contiguous line breaks.

   451 	$pee = preg_replace("/\n\n+/", "\n\n", $pee);

   452 

   453 	// Split up the contents into an array of strings, separated by double line breaks.

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

   455 

   456 	// Reset $pee prior to rebuilding.

   457 	$pee = '';

   458 

   459 	// Rebuild the content as a string, wrapping every bit with a <p>.

   460 	foreach ( $pees as $tinkle ) {

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

   462 	}

   463 

   464 	// Under certain strange conditions it could create a P of entirely whitespace.

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

   466 

   467 	// Add a closing <p> inside <div>, <address>, or <form> tag if missing.

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

   469 	

   470 	// If an opening or closing block element tag is wrapped in a <p>, unwrap it.

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

   472 	

   473 	// In some cases <li> may get wrapped in <p>, fix them.

   474 	$pee = preg_replace("|<p>(<li.+?)</p>|", "$1", $pee); 

   475 	

   476 	// If a <blockquote> is wrapped with a <p>, move it inside the <blockquote>.

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

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

   479 	

   480 	// If an opening or closing block element tag is preceded by an opening <p> tag, remove it.

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

   482 	

   483 	// If an opening or closing block element tag is followed by a closing <p> tag, remove it.

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

   485 

   486 	// Optionally insert line breaks.

   487 	if ( $br ) {

   488 		// Replace newlines that shouldn't be touched with a placeholder.

   489 		$pee = preg_replace_callback('/<(script|style).*?<\/\\1>/s', '_autop_newline_preservation_helper', $pee);

   490 

   491 		// Replace any new line characters that aren't preceded by a <br /> with a <br />.

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

   493 

   494 		// Replace newline placeholders with newlines.

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

   496 	}

   497 

   498 	// If a <br /> tag is after an opening or closing block tag, remove it.

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

   500 	

   501 	// If a <br /> tag is before a subset of opening or closing block tags, remove it.

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

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

   504 

   505 	// Replace placeholder <pre> tags with their original content.

   506 	if ( !empty($pre_tags) )

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

   508 

   509 	return $pee;

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

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

   575 		. '/s';

   850 		. '/';

   592 function seems_utf8($str) {

   867 function seems_utf8( $str ) {

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

   899  * @staticvar string $_charset

   625  * @param int $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.

   900  *

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

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

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

   902  * @param int|string $quote_style    Optional. Converts double quotes if set to ENT_COMPAT,

   903  *                                   both single and double if set to ENT_QUOTES or none if set to ENT_NOQUOTES.

   904  *                                   Also compatible with old values; converting single quotes if set to 'single',

   905  *                                   double if set to 'double' or both if otherwise set.

   906  *                                   Default is ENT_NOQUOTES.

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

   908  * @param bool       $double_encode  Optional. Whether to encode existing html entities. Default is false.

   648 		static $_charset;

   929 		static $_charset = null;

   668 	// Handle double encoding ourselves

   949 	if ( ! $double_encode ) {

   669 	if ( $double_encode ) {

   950 		// Guarantee every &entity; is valid, convert &garbage; into &garbage;

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

   951 		// This is required for PHP < 5.4.0 because ENT_HTML401 flag is unavailable.

   671 	} else {

   672 		// Decode & into &

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

   674 

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

   677 

   953 	}

   678 		// Now re-encode everything except &entity;

   954 

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

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

   680 

   956 

   681 		for ( $i = 0, $c = count( $string ); $i < $c; $i += 2 ) {

   957 	// Back-compat.

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

   683 		}

   684 		$string = implode( '', $string );

   685 	}

   686 

   687 	// Backwards compatibility

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

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

   705  * @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.

   975  * @param string|int $quote_style Optional. Converts double quotes if set to ENT_COMPAT,

   976  *                                both single and double if set to ENT_QUOTES or

   977  *                                none if set to ENT_NOQUOTES.

   978  *                                Also compatible with old _wp_specialchars() values;

   979  *                                converting single quotes if set to 'single',

   980  *                                double if set to 'double' or both if otherwise set.

   981  *                                Default is ENT_NOQUOTES.

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

  1037  * @staticvar bool $is_utf8

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

  1038  * @staticvar bool $utf8_pcre

  1039  *

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

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

   773 	static $is_utf8;

  1052 	static $is_utf8 = null;

   774 	if ( !isset( $is_utf8 ) ) {

  1053 	if ( ! isset( $is_utf8 ) ) {

   777 	if ( !$is_utf8 ) {

  1056 	if ( ! $is_utf8 ) {