/forum/includes/utf/utf_tools.php

   1<?php
   2/**
   3*
   4* @package utf
   5* @version $Id$
   6* @copyright (c) 2006 phpBB Group
   7* @license http://opensource.org/licenses/gpl-license.php GNU Public License
   8*
   9*/
  10
  11/**
  12*/
  13if (!defined('IN_PHPBB'))
  14{
  15	exit;
  16}
  17
  18// Enforce ASCII only string handling
  19setlocale(LC_CTYPE, 'C');
  20
  21/**
  22* UTF-8 tools
  23*
  24* Whenever possible, these functions will try to use PHP's built-in functions or
  25* extensions, otherwise they will default to custom routines.
  26*
  27* @package utf
  28*/
  29
  30if (!extension_loaded('xml'))
  31{
  32	/**
  33	* Implementation of PHP's native utf8_encode for people without XML support
  34	* This function exploits some nice things that ISO-8859-1 and UTF-8 have in common
  35	*
  36	* @param string $str ISO-8859-1 encoded data
  37	* @return string UTF-8 encoded data
  38	*/
  39	function utf8_encode($str)
  40	{
  41		$out = '';
  42		for ($i = 0, $len = strlen($str); $i < $len; $i++)
  43		{
  44			$letter = $str[$i];
  45			$num = ord($letter);
  46			if ($num < 0x80)
  47			{
  48				$out .= $letter;
  49			}
  50			else if ($num < 0xC0)
  51			{
  52				$out .= "\xC2" . $letter;
  53			}
  54			else
  55			{
  56				$out .= "\xC3" . chr($num - 64);
  57			}
  58		}
  59		return $out;
  60	}
  61
  62	/**
  63	* Implementation of PHP's native utf8_decode for people without XML support
  64	*
  65	* @param string $str UTF-8 encoded data
  66	* @return string ISO-8859-1 encoded data
  67	*/
  68	function utf8_decode($str)
  69	{
  70		$pos = 0;
  71		$len = strlen($str);
  72		$ret = '';
  73
  74		while ($pos < $len)
  75		{
  76			$ord = ord($str[$pos]) & 0xF0;
  77			if ($ord === 0xC0 || $ord === 0xD0)
  78			{
  79				$charval = ((ord($str[$pos]) & 0x1F) << 6) | (ord($str[$pos + 1]) & 0x3F);
  80				$pos += 2;
  81				$ret .= (($charval < 256) ? chr($charval) : '?');
  82			}
  83			else if ($ord === 0xE0)
  84			{
  85				$ret .= '?';
  86				$pos += 3;
  87			}
  88			else if ($ord === 0xF0)
  89			{
  90				$ret .= '?';
  91				$pos += 4;
  92			}
  93			else
  94			{
  95				$ret .= $str[$pos];
  96				++$pos;
  97			}
  98		}
  99		return $ret;
 100	}
 101}
 102
 103// mbstring is old and has it's functions around for older versions of PHP.
 104// if mbstring is not loaded, we go into native mode.
 105if (extension_loaded('mbstring'))
 106{
 107	mb_internal_encoding('UTF-8');
 108	// Fix for http://www.phpbb.com/bugs/phpbb3/52315
 109	// ini_set is only used to try to make things better for mods using mbstring directly
 110	// I know they're not supposed to, but you know they still could and the fix is costless
 111	@ini_set("mbstring.internal_encoding", 'UTF-8');
 112
 113	/**
 114	* UTF-8 aware alternative to strrpos
 115	* Find position of last occurrence of a char in a string
 116	*
 117	* Notes:
 118	* - offset for mb_strrpos was added in 5.2.0, we emulate if it is lower
 119	*/
 120	if (version_compare(PHP_VERSION, '5.2.0', '>='))
 121	{
 122		/**
 123		* UTF-8 aware alternative to strrpos
 124		* @ignore
 125		*/
 126		function utf8_strrpos($str,	$needle, $offset = null)
 127		{
 128			// Emulate behaviour of strrpos rather than raising warning
 129			if (empty($str))
 130			{
 131				return false;
 132			}
 133
 134			if (is_null($offset))
 135			{
 136				// Fix for http://www.phpbb.com/bugs/phpbb3/52315
 137				// Explicit encoding
 138				return mb_strrpos($str, $needle, 0, 'UTF-8');
 139			}
 140			else
 141			{
 142				// Fix for http://www.phpbb.com/bugs/phpbb3/52315
 143				// Explicit encoding
 144				return mb_strrpos($str, $needle, $offset, 'UTF-8');
 145			}
 146		}
 147	}
 148	else
 149	{
 150		/**
 151		* UTF-8 aware alternative to strrpos
 152		* @ignore
 153		*/
 154		function utf8_strrpos($str,	$needle, $offset = null)
 155		{
 156			// offset for mb_strrpos was added in 5.2.0
 157			if (is_null($offset))
 158			{
 159				// Emulate behaviour of strrpos rather than raising warning
 160				if (empty($str))
 161				{
 162					return false;
 163				}
 164				// Fix for http://www.phpbb.com/bugs/phpbb3/52315
 165				// Explicit encoding
 166				return mb_strrpos($str, $needle, 'UTF-8');
 167			}
 168			else
 169			{
 170				if (!is_int($offset))
 171				{
 172					trigger_error('utf8_strrpos expects parameter 3 to be long', E_USER_ERROR);
 173					return false;
 174				}
 175				// Fix for http://www.phpbb.com/bugs/phpbb3/52315
 176				// Explicit encoding
 177				$str = mb_substr($str, $offset, mb_strlen($str, 'UTF-8'), 'UTF-8');
 178				// Fix for http://www.phpbb.com/bugs/phpbb3/52315
 179				// Explicit encoding
 180				if (false !== ($pos = mb_strrpos($str, $needle, 'UTF-8')))
 181				{
 182					return $pos + $offset;
 183				}
 184
 185				return false;
 186			}
 187		}
 188	}
 189
 190	/**
 191	* UTF-8 aware alternative to strpos
 192	* @ignore
 193	*/
 194	function utf8_strpos($str, $needle, $offset = null)
 195	{
 196		if (is_null($offset))
 197		{
 198			// Fix for http://www.phpbb.com/bugs/phpbb3/52315
 199			// Explicit encoding
 200			return mb_strpos($str, $needle, 0, 'UTF-8');
 201		}
 202		else
 203		{
 204			// Fix for http://www.phpbb.com/bugs/phpbb3/52315
 205			// Explicit encoding
 206			return mb_strpos($str, $needle, $offset, 'UTF-8');
 207		}
 208	}
 209
 210	/**
 211	* UTF-8 aware alternative to strtolower
 212	* @ignore
 213	*/
 214	function utf8_strtolower($str)
 215	{
 216		// Fix for http://www.phpbb.com/bugs/phpbb3/52315
 217		// Explicit encoding
 218		return mb_strtolower($str, 'UTF-8');
 219	}
 220
 221	/**
 222	* UTF-8 aware alternative to strtoupper
 223	* @ignore
 224	*/
 225	function utf8_strtoupper($str)
 226	{
 227		// Fix for http://www.phpbb.com/bugs/phpbb3/52315
 228		// Explicit encoding
 229		return mb_strtoupper($str, 'UTF-8');
 230	}
 231
 232	/**
 233	* UTF-8 aware alternative to substr
 234	* @ignore
 235	*/
 236	function utf8_substr($str, $offset, $length = null)
 237	{
 238		if (is_null($length))
 239		{
 240			// Fix for http://www.phpbb.com/bugs/phpbb3/52315
 241			// Explicit encoding
 242			return mb_substr($str, $offset, mb_strlen($str, 'UTF-8'), 'UTF-8');
 243		}
 244		else
 245		{
 246			// Fix for http://www.phpbb.com/bugs/phpbb3/52315
 247			// Explicit encoding
 248			return mb_substr($str, $offset, $length, 'UTF-8');
 249		}
 250	}
 251
 252	/**
 253	* Return the length (in characters) of a UTF-8 string
 254	* @ignore
 255	*/
 256	function utf8_strlen($text)
 257	{
 258		return mb_strlen($text, 'utf-8');
 259	}
 260}
 261else
 262{
 263	/**
 264	* UTF-8 aware alternative to strrpos
 265	* Find position of last occurrence of a char in a string
 266	*
 267	* @author Harry Fuecks
 268	* @param string $str haystack
 269	* @param string $needle needle
 270	* @param integer $offset (optional) offset (from left)
 271	* @return mixed integer position or FALSE on failure
 272	*/
 273	function utf8_strrpos($str,	$needle, $offset = null)
 274	{
 275		if (is_null($offset))
 276		{
 277			$ar	= explode($needle, $str);
 278
 279			if (sizeof($ar) > 1)
 280			{
 281				// Pop off the end of the string where the last	match was made
 282				array_pop($ar);
 283				$str = join($needle, $ar);
 284
 285				return utf8_strlen($str);
 286			}
 287			return false;
 288		}
 289		else
 290		{
 291			if (!is_int($offset))
 292			{
 293				trigger_error('utf8_strrpos	expects	parameter 3	to be long', E_USER_ERROR);
 294				return false;
 295			}
 296
 297			$str = utf8_substr($str, $offset);
 298
 299			if (false !== ($pos = utf8_strrpos($str, $needle)))
 300			{
 301				return $pos	+ $offset;
 302			}
 303
 304			return false;
 305		}
 306	}
 307
 308	/**
 309	* UTF-8 aware alternative to strpos
 310	* Find position of first occurrence of a string
 311	*
 312	* @author Harry Fuecks
 313	* @param string $str haystack
 314	* @param string $needle needle
 315	* @param integer $offset offset in characters (from left)
 316	* @return mixed integer position or FALSE on failure
 317	*/
 318	function utf8_strpos($str, $needle, $offset = null)
 319	{
 320		if (is_null($offset))
 321		{
 322			$ar = explode($needle, $str);
 323			if (sizeof($ar) > 1)
 324			{
 325				return utf8_strlen($ar[0]);
 326			}
 327			return false;
 328		}
 329		else
 330		{
 331			if (!is_int($offset))
 332			{
 333				trigger_error('utf8_strpos:  Offset must  be an integer', E_USER_ERROR);
 334				return false;
 335			}
 336
 337			$str = utf8_substr($str, $offset);
 338
 339			if (false !== ($pos = utf8_strpos($str, $needle)))
 340			{
 341				return $pos + $offset;
 342			}
 343
 344			return false;
 345		}
 346	}
 347
 348	/**
 349	* UTF-8 aware alternative to strtolower
 350	* Make a string lowercase
 351	* Note: The concept of a characters "case" only exists is some alphabets
 352	* such as Latin, Greek, Cyrillic, Armenian and archaic Georgian - it does
 353	* not exist in the Chinese alphabet, for example. See Unicode Standard
 354	* Annex #21: Case Mappings
 355	*
 356	* @param string
 357	* @return string string in lowercase
 358	*/
 359	function utf8_strtolower($string)
 360	{
 361		static $utf8_upper_to_lower = array(
 362			"\xC3\x80" => "\xC3\xA0", "\xC3\x81" => "\xC3\xA1",
 363			"\xC3\x82" => "\xC3\xA2", "\xC3\x83" => "\xC3\xA3", "\xC3\x84" => "\xC3\xA4", "\xC3\x85" => "\xC3\xA5",
 364			"\xC3\x86" => "\xC3\xA6", "\xC3\x87" => "\xC3\xA7", "\xC3\x88" => "\xC3\xA8", "\xC3\x89" => "\xC3\xA9",
 365			"\xC3\x8A" => "\xC3\xAA", "\xC3\x8B" => "\xC3\xAB", "\xC3\x8C" => "\xC3\xAC", "\xC3\x8D" => "\xC3\xAD",
 366			"\xC3\x8E" => "\xC3\xAE", "\xC3\x8F" => "\xC3\xAF", "\xC3\x90" => "\xC3\xB0", "\xC3\x91" => "\xC3\xB1",
 367			"\xC3\x92" => "\xC3\xB2", "\xC3\x93" => "\xC3\xB3", "\xC3\x94" => "\xC3\xB4", "\xC3\x95" => "\xC3\xB5",
 368			"\xC3\x96" => "\xC3\xB6", "\xC3\x98" => "\xC3\xB8", "\xC3\x99" => "\xC3\xB9", "\xC3\x9A" => "\xC3\xBA",
 369			"\xC3\x9B" => "\xC3\xBB", "\xC3\x9C" => "\xC3\xBC", "\xC3\x9D" => "\xC3\xBD", "\xC3\x9E" => "\xC3\xBE",
 370			"\xC4\x80" => "\xC4\x81", "\xC4\x82" => "\xC4\x83", "\xC4\x84" => "\xC4\x85", "\xC4\x86" => "\xC4\x87",
 371			"\xC4\x88" => "\xC4\x89", "\xC4\x8A" => "\xC4\x8B", "\xC4\x8C" => "\xC4\x8D", "\xC4\x8E" => "\xC4\x8F",
 372			"\xC4\x90" => "\xC4\x91", "\xC4\x92" => "\xC4\x93", "\xC4\x96" => "\xC4\x97", "\xC4\x98" => "\xC4\x99",
 373			"\xC4\x9A" => "\xC4\x9B", "\xC4\x9C" => "\xC4\x9D", "\xC4\x9E" => "\xC4\x9F", "\xC4\xA0" => "\xC4\xA1",
 374			"\xC4\xA2" => "\xC4\xA3", "\xC4\xA4" => "\xC4\xA5", "\xC4\xA6" => "\xC4\xA7", "\xC4\xA8" => "\xC4\xA9",
 375			"\xC4\xAA" => "\xC4\xAB", "\xC4\xAE" => "\xC4\xAF", "\xC4\xB4" => "\xC4\xB5", "\xC4\xB6" => "\xC4\xB7",
 376			"\xC4\xB9" => "\xC4\xBA", "\xC4\xBB" => "\xC4\xBC", "\xC4\xBD" => "\xC4\xBE", "\xC5\x81" => "\xC5\x82",
 377			"\xC5\x83" => "\xC5\x84", "\xC5\x85" => "\xC5\x86", "\xC5\x87" => "\xC5\x88", "\xC5\x8A" => "\xC5\x8B",
 378			"\xC5\x8C" => "\xC5\x8D", "\xC5\x90" => "\xC5\x91", "\xC5\x94" => "\xC5\x95", "\xC5\x96" => "\xC5\x97",
 379			"\xC5\x98" => "\xC5\x99", "\xC5\x9A" => "\xC5\x9B", "\xC5\x9C" => "\xC5\x9D", "\xC5\x9E" => "\xC5\x9F",
 380			"\xC5\xA0" => "\xC5\xA1", "\xC5\xA2" => "\xC5\xA3", "\xC5\xA4" => "\xC5\xA5", "\xC5\xA6" => "\xC5\xA7",
 381			"\xC5\xA8" => "\xC5\xA9", "\xC5\xAA" => "\xC5\xAB", "\xC5\xAC" => "\xC5\xAD", "\xC5\xAE" => "\xC5\xAF",
 382			"\xC5\xB0" => "\xC5\xB1", "\xC5\xB2" => "\xC5\xB3", "\xC5\xB4" => "\xC5\xB5", "\xC5\xB6" => "\xC5\xB7",
 383			"\xC5\xB8" => "\xC3\xBF", "\xC5\xB9" => "\xC5\xBA", "\xC5\xBB" => "\xC5\xBC", "\xC5\xBD" => "\xC5\xBE",
 384			"\xC6\xA0" => "\xC6\xA1", "\xC6\xAF" => "\xC6\xB0", "\xC8\x98" => "\xC8\x99", "\xC8\x9A" => "\xC8\x9B",
 385			"\xCE\x86" => "\xCE\xAC", "\xCE\x88" => "\xCE\xAD", "\xCE\x89" => "\xCE\xAE", "\xCE\x8A" => "\xCE\xAF",
 386			"\xCE\x8C" => "\xCF\x8C", "\xCE\x8E" => "\xCF\x8D", "\xCE\x8F" => "\xCF\x8E", "\xCE\x91" => "\xCE\xB1",
 387			"\xCE\x92" => "\xCE\xB2", "\xCE\x93" => "\xCE\xB3", "\xCE\x94" => "\xCE\xB4", "\xCE\x95" => "\xCE\xB5",
 388			"\xCE\x96" => "\xCE\xB6", "\xCE\x97" => "\xCE\xB7", "\xCE\x98" => "\xCE\xB8", "\xCE\x99" => "\xCE\xB9",
 389			"\xCE\x9A" => "\xCE\xBA", "\xCE\x9B" => "\xCE\xBB", "\xCE\x9C" => "\xCE\xBC", "\xCE\x9D" => "\xCE\xBD",
 390			"\xCE\x9E" => "\xCE\xBE", "\xCE\x9F" => "\xCE\xBF", "\xCE\xA0" => "\xCF\x80", "\xCE\xA1" => "\xCF\x81",
 391			"\xCE\xA3" => "\xCF\x83", "\xCE\xA4" => "\xCF\x84", "\xCE\xA5" => "\xCF\x85", "\xCE\xA6" => "\xCF\x86",
 392			"\xCE\xA7" => "\xCF\x87", "\xCE\xA8" => "\xCF\x88", "\xCE\xA9" => "\xCF\x89", "\xCE\xAA" => "\xCF\x8A",
 393			"\xCE\xAB" => "\xCF\x8B", "\xD0\x81" => "\xD1\x91", "\xD0\x82" => "\xD1\x92", "\xD0\x83" => "\xD1\x93",
 394			"\xD0\x84" => "\xD1\x94", "\xD0\x85" => "\xD1\x95", "\xD0\x86" => "\xD1\x96", "\xD0\x87" => "\xD1\x97",
 395			"\xD0\x88" => "\xD1\x98", "\xD0\x89" => "\xD1\x99", "\xD0\x8A" => "\xD1\x9A", "\xD0\x8B" => "\xD1\x9B",
 396			"\xD0\x8C" => "\xD1\x9C", "\xD0\x8E" => "\xD1\x9E", "\xD0\x8F" => "\xD1\x9F", "\xD0\x90" => "\xD0\xB0",
 397			"\xD0\x91" => "\xD0\xB1", "\xD0\x92" => "\xD0\xB2", "\xD0\x93" => "\xD0\xB3", "\xD0\x94" => "\xD0\xB4",
 398			"\xD0\x95" => "\xD0\xB5", "\xD0\x96" => "\xD0\xB6", "\xD0\x97" => "\xD0\xB7", "\xD0\x98" => "\xD0\xB8",
 399			"\xD0\x99" => "\xD0\xB9", "\xD0\x9A" => "\xD0\xBA", "\xD0\x9B" => "\xD0\xBB", "\xD0\x9C" => "\xD0\xBC",
 400			"\xD0\x9D" => "\xD0\xBD", "\xD0\x9E" => "\xD0\xBE", "\xD0\x9F" => "\xD0\xBF", "\xD0\xA0" => "\xD1\x80",
 401			"\xD0\xA1" => "\xD1\x81", "\xD0\xA2" => "\xD1\x82", "\xD0\xA3" => "\xD1\x83", "\xD0\xA4" => "\xD1\x84",
 402			"\xD0\xA5" => "\xD1\x85", "\xD0\xA6" => "\xD1\x86", "\xD0\xA7" => "\xD1\x87", "\xD0\xA8" => "\xD1\x88",
 403			"\xD0\xA9" => "\xD1\x89", "\xD0\xAA" => "\xD1\x8A", "\xD0\xAB" => "\xD1\x8B", "\xD0\xAC" => "\xD1\x8C",
 404			"\xD0\xAD" => "\xD1\x8D", "\xD0\xAE" => "\xD1\x8E", "\xD0\xAF" => "\xD1\x8F", "\xD2\x90" => "\xD2\x91",
 405			"\xE1\xB8\x82" => "\xE1\xB8\x83", "\xE1\xB8\x8A" => "\xE1\xB8\x8B", "\xE1\xB8\x9E" => "\xE1\xB8\x9F", "\xE1\xB9\x80" => "\xE1\xB9\x81",
 406			"\xE1\xB9\x96" => "\xE1\xB9\x97", "\xE1\xB9\xA0" => "\xE1\xB9\xA1", "\xE1\xB9\xAA" => "\xE1\xB9\xAB", "\xE1\xBA\x80" => "\xE1\xBA\x81",
 407			"\xE1\xBA\x82" => "\xE1\xBA\x83", "\xE1\xBA\x84" => "\xE1\xBA\x85", "\xE1\xBB\xB2" => "\xE1\xBB\xB3"
 408		);
 409
 410		return strtr(strtolower($string), $utf8_upper_to_lower);
 411	}
 412
 413	/**
 414	* UTF-8 aware alternative to strtoupper
 415	* Make a string uppercase
 416	* Note: The concept of a characters "case" only exists is some alphabets
 417	* such as Latin, Greek, Cyrillic, Armenian and archaic Georgian - it does
 418	* not exist in the Chinese alphabet, for example. See Unicode Standard
 419	* Annex #21: Case Mappings
 420	*
 421	* @param string
 422	* @return string string in uppercase
 423	*/
 424	function utf8_strtoupper($string)
 425	{
 426		static $utf8_lower_to_upper = array(
 427			"\xC3\xA0" => "\xC3\x80", "\xC3\xA1" => "\xC3\x81",
 428			"\xC3\xA2" => "\xC3\x82", "\xC3\xA3" => "\xC3\x83", "\xC3\xA4" => "\xC3\x84", "\xC3\xA5" => "\xC3\x85",
 429			"\xC3\xA6" => "\xC3\x86", "\xC3\xA7" => "\xC3\x87", "\xC3\xA8" => "\xC3\x88", "\xC3\xA9" => "\xC3\x89",
 430			"\xC3\xAA" => "\xC3\x8A", "\xC3\xAB" => "\xC3\x8B", "\xC3\xAC" => "\xC3\x8C", "\xC3\xAD" => "\xC3\x8D",
 431			"\xC3\xAE" => "\xC3\x8E", "\xC3\xAF" => "\xC3\x8F", "\xC3\xB0" => "\xC3\x90", "\xC3\xB1" => "\xC3\x91",
 432			"\xC3\xB2" => "\xC3\x92", "\xC3\xB3" => "\xC3\x93", "\xC3\xB4" => "\xC3\x94", "\xC3\xB5" => "\xC3\x95",
 433			"\xC3\xB6" => "\xC3\x96", "\xC3\xB8" => "\xC3\x98", "\xC3\xB9" => "\xC3\x99", "\xC3\xBA" => "\xC3\x9A",
 434			"\xC3\xBB" => "\xC3\x9B", "\xC3\xBC" => "\xC3\x9C", "\xC3\xBD" => "\xC3\x9D", "\xC3\xBE" => "\xC3\x9E",
 435			"\xC3\xBF" => "\xC5\xB8", "\xC4\x81" => "\xC4\x80", "\xC4\x83" => "\xC4\x82", "\xC4\x85" => "\xC4\x84",
 436			"\xC4\x87" => "\xC4\x86", "\xC4\x89" => "\xC4\x88", "\xC4\x8B" => "\xC4\x8A", "\xC4\x8D" => "\xC4\x8C",
 437			"\xC4\x8F" => "\xC4\x8E", "\xC4\x91" => "\xC4\x90", "\xC4\x93" => "\xC4\x92", "\xC4\x97" => "\xC4\x96",
 438			"\xC4\x99" => "\xC4\x98", "\xC4\x9B" => "\xC4\x9A", "\xC4\x9D" => "\xC4\x9C", "\xC4\x9F" => "\xC4\x9E",
 439			"\xC4\xA1" => "\xC4\xA0", "\xC4\xA3" => "\xC4\xA2", "\xC4\xA5" => "\xC4\xA4", "\xC4\xA7" => "\xC4\xA6",
 440			"\xC4\xA9" => "\xC4\xA8", "\xC4\xAB" => "\xC4\xAA", "\xC4\xAF" => "\xC4\xAE", "\xC4\xB5" => "\xC4\xB4",
 441			"\xC4\xB7" => "\xC4\xB6", "\xC4\xBA" => "\xC4\xB9", "\xC4\xBC" => "\xC4\xBB", "\xC4\xBE" => "\xC4\xBD",
 442			"\xC5\x82" => "\xC5\x81", "\xC5\x84" => "\xC5\x83", "\xC5\x86" => "\xC5\x85", "\xC5\x88" => "\xC5\x87",
 443			"\xC5\x8B" => "\xC5\x8A", "\xC5\x8D" => "\xC5\x8C", "\xC5\x91" => "\xC5\x90", "\xC5\x95" => "\xC5\x94",
 444			"\xC5\x97" => "\xC5\x96", "\xC5\x99" => "\xC5\x98", "\xC5\x9B" => "\xC5\x9A", "\xC5\x9D" => "\xC5\x9C",
 445			"\xC5\x9F" => "\xC5\x9E", "\xC5\xA1" => "\xC5\xA0", "\xC5\xA3" => "\xC5\xA2", "\xC5\xA5" => "\xC5\xA4",
 446			"\xC5\xA7" => "\xC5\xA6", "\xC5\xA9" => "\xC5\xA8", "\xC5\xAB" => "\xC5\xAA", "\xC5\xAD" => "\xC5\xAC",
 447			"\xC5\xAF" => "\xC5\xAE", "\xC5\xB1" => "\xC5\xB0", "\xC5\xB3" => "\xC5\xB2", "\xC5\xB5" => "\xC5\xB4",
 448			"\xC5\xB7" => "\xC5\xB6", "\xC5\xBA" => "\xC5\xB9", "\xC5\xBC" => "\xC5\xBB", "\xC5\xBE" => "\xC5\xBD",
 449			"\xC6\xA1" => "\xC6\xA0", "\xC6\xB0" => "\xC6\xAF", "\xC8\x99" => "\xC8\x98", "\xC8\x9B" => "\xC8\x9A",
 450			"\xCE\xAC" => "\xCE\x86", "\xCE\xAD" => "\xCE\x88", "\xCE\xAE" => "\xCE\x89", "\xCE\xAF" => "\xCE\x8A",
 451			"\xCE\xB1" => "\xCE\x91", "\xCE\xB2" => "\xCE\x92", "\xCE\xB3" => "\xCE\x93", "\xCE\xB4" => "\xCE\x94",
 452			"\xCE\xB5" => "\xCE\x95", "\xCE\xB6" => "\xCE\x96", "\xCE\xB7" => "\xCE\x97", "\xCE\xB8" => "\xCE\x98",
 453			"\xCE\xB9" => "\xCE\x99", "\xCE\xBA" => "\xCE\x9A", "\xCE\xBB" => "\xCE\x9B", "\xCE\xBC" => "\xCE\x9C",
 454			"\xCE\xBD" => "\xCE\x9D", "\xCE\xBE" => "\xCE\x9E", "\xCE\xBF" => "\xCE\x9F", "\xCF\x80" => "\xCE\xA0",
 455			"\xCF\x81" => "\xCE\xA1", "\xCF\x83" => "\xCE\xA3", "\xCF\x84" => "\xCE\xA4", "\xCF\x85" => "\xCE\xA5",
 456			"\xCF\x86" => "\xCE\xA6", "\xCF\x87" => "\xCE\xA7", "\xCF\x88" => "\xCE\xA8", "\xCF\x89" => "\xCE\xA9",
 457			"\xCF\x8A" => "\xCE\xAA", "\xCF\x8B" => "\xCE\xAB", "\xCF\x8C" => "\xCE\x8C", "\xCF\x8D" => "\xCE\x8E",
 458			"\xCF\x8E" => "\xCE\x8F", "\xD0\xB0" => "\xD0\x90", "\xD0\xB1" => "\xD0\x91", "\xD0\xB2" => "\xD0\x92",
 459			"\xD0\xB3" => "\xD0\x93", "\xD0\xB4" => "\xD0\x94", "\xD0\xB5" => "\xD0\x95", "\xD0\xB6" => "\xD0\x96",
 460			"\xD0\xB7" => "\xD0\x97", "\xD0\xB8" => "\xD0\x98", "\xD0\xB9" => "\xD0\x99", "\xD0\xBA" => "\xD0\x9A",
 461			"\xD0\xBB" => "\xD0\x9B", "\xD0\xBC" => "\xD0\x9C", "\xD0\xBD" => "\xD0\x9D", "\xD0\xBE" => "\xD0\x9E",
 462			"\xD0\xBF" => "\xD0\x9F", "\xD1\x80" => "\xD0\xA0", "\xD1\x81" => "\xD0\xA1", "\xD1\x82" => "\xD0\xA2",
 463			"\xD1\x83" => "\xD0\xA3", "\xD1\x84" => "\xD0\xA4", "\xD1\x85" => "\xD0\xA5", "\xD1\x86" => "\xD0\xA6",
 464			"\xD1\x87" => "\xD0\xA7", "\xD1\x88" => "\xD0\xA8", "\xD1\x89" => "\xD0\xA9", "\xD1\x8A" => "\xD0\xAA",
 465			"\xD1\x8B" => "\xD0\xAB", "\xD1\x8C" => "\xD0\xAC", "\xD1\x8D" => "\xD0\xAD", "\xD1\x8E" => "\xD0\xAE",
 466			"\xD1\x8F" => "\xD0\xAF", "\xD1\x91" => "\xD0\x81", "\xD1\x92" => "\xD0\x82", "\xD1\x93" => "\xD0\x83",
 467			"\xD1\x94" => "\xD0\x84", "\xD1\x95" => "\xD0\x85", "\xD1\x96" => "\xD0\x86", "\xD1\x97" => "\xD0\x87",
 468			"\xD1\x98" => "\xD0\x88", "\xD1\x99" => "\xD0\x89", "\xD1\x9A" => "\xD0\x8A", "\xD1\x9B" => "\xD0\x8B",
 469			"\xD1\x9C" => "\xD0\x8C", "\xD1\x9E" => "\xD0\x8E", "\xD1\x9F" => "\xD0\x8F", "\xD2\x91" => "\xD2\x90",
 470			"\xE1\xB8\x83" => "\xE1\xB8\x82", "\xE1\xB8\x8B" => "\xE1\xB8\x8A", "\xE1\xB8\x9F" => "\xE1\xB8\x9E", "\xE1\xB9\x81" => "\xE1\xB9\x80",
 471			"\xE1\xB9\x97" => "\xE1\xB9\x96", "\xE1\xB9\xA1" => "\xE1\xB9\xA0", "\xE1\xB9\xAB" => "\xE1\xB9\xAA", "\xE1\xBA\x81" => "\xE1\xBA\x80",
 472			"\xE1\xBA\x83" => "\xE1\xBA\x82", "\xE1\xBA\x85" => "\xE1\xBA\x84", "\xE1\xBB\xB3" => "\xE1\xBB\xB2"
 473		);
 474
 475		return strtr(strtoupper($string), $utf8_lower_to_upper);
 476	}
 477
 478	/**
 479	* UTF-8 aware alternative to substr
 480	* Return part of a string given character offset (and optionally length)
 481	*
 482	* Note arguments: comparied to substr - if offset or length are
 483	* not integers, this version will not complain but rather massages them
 484	* into an integer.
 485	*
 486	* Note on returned values: substr documentation states false can be
 487	* returned in some cases (e.g. offset > string length)
 488	* mb_substr never returns false, it will return an empty string instead.
 489	* This adopts the mb_substr approach
 490	*
 491	* Note on implementation: PCRE only supports repetitions of less than
 492	* 65536, in order to accept up to MAXINT values for offset and length,
 493	* we'll repeat a group of 65535 characters when needed.
 494	*
 495	* Note on implementation: calculating the number of characters in the
 496	* string is a relatively expensive operation, so we only carry it out when
 497	* necessary. It isn't necessary for +ve offsets and no specified length
 498	*
 499	* @author Chris Smith<chris@jalakai.co.uk>
 500	* @param string $str
 501	* @param integer $offset number of UTF-8 characters offset (from left)
 502	* @param integer $length (optional) length in UTF-8 characters from offset
 503	* @return mixed string or FALSE if failure
 504	*/
 505	function utf8_substr($str, $offset, $length = NULL)
 506	{
 507		// generates E_NOTICE
 508		// for PHP4 objects, but not PHP5 objects
 509		$str = (string) $str;
 510		$offset = (int) $offset;
 511		if (!is_null($length))
 512		{
 513			$length = (int) $length;
 514		}
 515
 516		// handle trivial cases
 517		if ($length === 0 || ($offset < 0 && $length < 0 && $length < $offset))
 518		{
 519			return '';
 520		}
 521
 522		// normalise negative offsets (we could use a tail
 523		// anchored pattern, but they are horribly slow!)
 524		if ($offset < 0)
 525		{
 526			// see notes
 527			$strlen = utf8_strlen($str);
 528			$offset = $strlen + $offset;
 529			if ($offset < 0)
 530			{
 531				$offset = 0;
 532			}
 533		}
 534
 535		$op = '';
 536		$lp = '';
 537
 538		// establish a pattern for offset, a
 539		// non-captured group equal in length to offset
 540		if ($offset > 0)
 541		{
 542			$ox = (int) ($offset / 65535);
 543			$oy = $offset % 65535;
 544
 545			if ($ox)
 546			{
 547				$op = '(?:.{65535}){' . $ox . '}';
 548			}
 549
 550			$op = '^(?:' . $op . '.{' . $oy . '})';
 551		}
 552		else
 553		{
 554			// offset == 0; just anchor the pattern
 555			$op = '^';
 556		}
 557
 558		// establish a pattern for length
 559		if (is_null($length))
 560		{
 561			// the rest of the string
 562			$lp = '(.*)$';
 563		}
 564		else
 565		{
 566			if (!isset($strlen))
 567			{
 568				// see notes
 569				$strlen = utf8_strlen($str);
 570			}
 571
 572			// another trivial case
 573			if ($offset > $strlen)
 574			{
 575				return '';
 576			}
 577
 578			if ($length > 0)
 579			{
 580				// reduce any length that would
 581				// go passed the end of the string
 582				$length = min($strlen - $offset, $length);
 583
 584				$lx = (int) ($length / 65535);
 585				$ly = $length % 65535;
 586
 587				// negative length requires a captured group
 588				// of length characters
 589				if ($lx)
 590				{
 591					$lp = '(?:.{65535}){' . $lx . '}';
 592				}
 593				$lp = '(' . $lp . '.{'. $ly . '})';
 594			}
 595			else if ($length < 0)
 596			{
 597				if ($length < ($offset - $strlen))
 598				{
 599					return '';
 600				}
 601
 602				$lx = (int)((-$length) / 65535);
 603				$ly = (-$length) % 65535;
 604
 605				// negative length requires ... capture everything
 606				// except a group of  -length characters
 607				// anchored at the tail-end of the string
 608				if ($lx)
 609				{
 610					$lp = '(?:.{65535}){' . $lx . '}';
 611				}
 612				$lp = '(.*)(?:' . $lp . '.{' . $ly . '})$';
 613			}
 614		}
 615
 616		if (!preg_match('#' . $op . $lp . '#us', $str, $match))
 617		{
 618			return '';
 619		}
 620
 621		return $match[1];
 622	}
 623
 624	/**
 625	* Return the length (in characters) of a UTF-8 string
 626	*
 627	* @param	string	$text		UTF-8 string
 628	* @return	integer				Length (in chars) of given string
 629	*/
 630	function utf8_strlen($text)
 631	{
 632		// Since utf8_decode is replacing multibyte characters to ? strlen works fine
 633		return strlen(utf8_decode($text));
 634	}
 635}
 636
 637/**
 638* UTF-8 aware alternative to str_split
 639* Convert a string to an array
 640*
 641* @author Harry Fuecks
 642* @param string $str UTF-8 encoded
 643* @param int $split_len number to characters to split string by
 644* @return array characters in string reverses
 645*/
 646function utf8_str_split($str, $split_len = 1)
 647{
 648	if (!is_int($split_len) || $split_len < 1)
 649	{
 650		return false;
 651	}
 652
 653	$len = utf8_strlen($str);
 654	if ($len <= $split_len)
 655	{
 656		return array($str);
 657	}
 658
 659	preg_match_all('/.{' . $split_len . '}|[^\x00]{1,' . $split_len . '}$/us', $str, $ar);
 660	return $ar[0];
 661}
 662
 663/**
 664* UTF-8 aware alternative to strspn
 665* Find length of initial segment matching the mask
 666*
 667* @author Harry Fuecks
 668*/
 669function utf8_strspn($str, $mask, $start = null, $length = null)
 670{
 671	if ($start !== null || $length !== null)
 672	{
 673		$str = utf8_substr($str, $start, $length);
 674	}
 675
 676	preg_match('/^[' . $mask . ']+/u', $str, $matches);
 677
 678	if (isset($matches[0]))
 679	{
 680		return utf8_strlen($matches[0]);
 681	}
 682
 683	return 0;
 684}
 685
 686/**
 687* UTF-8 aware alternative to ucfirst
 688* Make a string's first character uppercase
 689*
 690* @author Harry Fuecks
 691* @param string
 692* @return string with first character as upper case (if applicable)
 693*/
 694function utf8_ucfirst($str)
 695{
 696	switch (utf8_strlen($str))
 697	{
 698		case 0:
 699			return '';
 700		break;
 701
 702		case 1:
 703			return utf8_strtoupper($str);
 704		break;
 705
 706		default:
 707			preg_match('/^(.{1})(.*)$/us', $str, $matches);
 708			return utf8_strtoupper($matches[1]) . $matches[2];
 709		break;
 710	}
 711}
 712
 713/**
 714* Recode a string to UTF-8
 715*
 716* If the encoding is not supported, the string is returned as-is
 717*
 718* @param	string	$string		Original string
 719* @param	string	$encoding	Original encoding (lowered)
 720* @return	string				The string, encoded in UTF-8
 721*/
 722function utf8_recode($string, $encoding)
 723{
 724	$encoding = strtolower($encoding);
 725
 726	if ($encoding == 'utf-8' || !is_string($string) || empty($string))
 727	{
 728		return $string;
 729	}
 730
 731	// we force iso-8859-1 to be cp1252
 732	if ($encoding == 'iso-8859-1')
 733	{
 734		$encoding = 'cp1252';
 735	}
 736	// convert iso-8859-8-i to iso-8859-8
 737	else if ($encoding == 'iso-8859-8-i')
 738	{
 739		$encoding = 'iso-8859-8';
 740		$string = hebrev($string);
 741	}
 742
 743	// First, try iconv()
 744	if (function_exists('iconv'))
 745	{
 746		$ret = @iconv($encoding, 'utf-8', $string);
 747
 748		if (!empty($ret))
 749		{
 750			return $ret;
 751		}
 752	}
 753
 754	// Try the mb_string extension
 755	if (function_exists('mb_convert_encoding'))
 756	{
 757		// mbstring is nasty on PHP4, we must make *sure* that we send a good encoding
 758		switch ($encoding)
 759		{
 760			case 'iso-8859-1':
 761			case 'iso-8859-2':
 762			case 'iso-8859-4':
 763			case 'iso-8859-7':
 764			case 'iso-8859-9':
 765			case 'iso-8859-15':
 766			case 'windows-1251':
 767			case 'windows-1252':
 768			case 'cp1252':
 769			case 'shift_jis':
 770			case 'euc-kr':
 771			case 'big5':
 772			case 'gb2312':
 773				$ret = @mb_convert_encoding($string, 'utf-8', $encoding);
 774
 775				if (!empty($ret))
 776				{
 777					return $ret;
 778				}
 779		}
 780	}
 781
 782	// Try the recode extension
 783	if (function_exists('recode_string'))
 784	{
 785		$ret = @recode_string($encoding . '..utf-8', $string);
 786
 787		if (!empty($ret))
 788		{
 789			return $ret;
 790		}
 791	}
 792
 793	// If nothing works, check if we have a custom transcoder available
 794	if (!preg_match('#^[a-z0-9_ \\-]+$#', $encoding))
 795	{
 796		// Make sure the encoding name is alphanumeric, we don't want it to be abused into loading arbitrary files
 797		trigger_error('Unknown encoding: ' . $encoding, E_USER_ERROR);
 798	}
 799
 800	global $phpbb_root_path, $phpEx;
 801
 802	// iso-8859-* character encoding
 803	if (preg_match('/iso[_ -]?8859[_ -]?(\\d+)/', $encoding, $array))
 804	{
 805		switch ($array[1])
 806		{
 807			case '1':
 808			case '2':
 809			case '4':
 810			case '7':
 811			case '8':
 812			case '9':
 813			case '15':
 814				if (!function_exists('iso_8859_' . $array[1]))
 815				{
 816					if (!file_exists($phpbb_root_path . 'includes/utf/data/recode_basic.' . $phpEx))
 817					{
 818						trigger_error('Basic reencoder file is missing', E_USER_ERROR);
 819					}
 820					include($phpbb_root_path . 'includes/utf/data/recode_basic.' . $phpEx);
 821				}
 822				return call_user_func('iso_8859_' . $array[1], $string);
 823			break;
 824
 825			default:
 826				trigger_error('Unknown encoding: ' . $encoding, E_USER_ERROR);
 827			break;
 828		}
 829	}
 830
 831	// CP/WIN character encoding
 832	if (preg_match('/(?:cp|windows)[_\- ]?(\\d+)/', $encoding, $array))
 833	{
 834		switch ($array[1])
 835		{
 836			case '932':
 837			break;
 838			case '1250':
 839			case '1251':
 840			case '1252':
 841			case '1254':
 842			case '1255':
 843			case '1256':
 844			case '1257':
 845			case '874':
 846				if (!function_exists('cp' . $array[1]))
 847				{
 848					if (!file_exists($phpbb_root_path . 'includes/utf/data/recode_basic.' . $phpEx))
 849					{
 850						trigger_error('Basic reencoder file is missing', E_USER_ERROR);
 851					}
 852					include($phpbb_root_path . 'includes/utf/data/recode_basic.' . $phpEx);
 853				}
 854				return call_user_func('cp' . $array[1], $string);
 855			break;
 856
 857			default:
 858				trigger_error('Unknown encoding: ' . $encoding, E_USER_ERROR);
 859			break;
 860		}
 861	}
 862
 863	// TIS-620
 864	if (preg_match('/tis[_ -]?620/', $encoding))
 865	{
 866		if (!function_exists('tis_620'))
 867		{
 868			if (!file_exists($phpbb_root_path . 'includes/utf/data/recode_basic.' . $phpEx))
 869			{
 870				trigger_error('Basic reencoder file is missing', E_USER_ERROR);
 871			}
 872			include($phpbb_root_path . 'includes/utf/data/recode_basic.' . $phpEx);
 873		}
 874		return tis_620($string);
 875	}
 876
 877	// SJIS
 878	if (preg_match('/sjis(?:[_ -]?win)?|(?:cp|ibm)[_ -]?932|shift[_ -]?jis/', $encoding))
 879	{
 880		if (!function_exists('sjis'))
 881		{
 882			if (!file_exists($phpbb_root_path . 'includes/utf/data/recode_cjk.' . $phpEx))
 883			{
 884				trigger_error('CJK reencoder file is missing', E_USER_ERROR);
 885			}
 886			include($phpbb_root_path . 'includes/utf/data/recode_cjk.' . $phpEx);
 887		}
 888		return sjis($string);
 889	}
 890
 891	// EUC_KR
 892	if (preg_match('/euc[_ -]?kr/', $encoding))
 893	{
 894		if (!function_exists('euc_kr'))
 895		{
 896			if (!file_exists($phpbb_root_path . 'includes/utf/data/recode_cjk.' . $phpEx))
 897			{
 898				trigger_error('CJK reencoder file is missing', E_USER_ERROR);
 899			}
 900			include($phpbb_root_path . 'includes/utf/data/recode_cjk.' . $phpEx);
 901		}
 902		return euc_kr($string);
 903	}
 904
 905	// BIG-5
 906	if (preg_match('/big[_ -]?5/', $encoding))
 907	{
 908		if (!function_exists('big5'))
 909		{
 910			if (!file_exists($phpbb_root_path . 'includes/utf/data/recode_cjk.' . $phpEx))
 911			{
 912				trigger_error('CJK reencoder file is missing', E_USER_ERROR);
 913			}
 914			include($phpbb_root_path . 'includes/utf/data/recode_cjk.' . $phpEx);
 915		}
 916		return big5($string);
 917	}
 918
 919	// GB2312
 920	if (preg_match('/gb[_ -]?2312/', $encoding))
 921	{
 922		if (!function_exists('gb2312'))
 923		{
 924			if (!file_exists($phpbb_root_path . 'includes/utf/data/recode_cjk.' . $phpEx))
 925			{
 926				trigger_error('CJK reencoder file is missing', E_USER_ERROR);
 927			}
 928			include($phpbb_root_path . 'includes/utf/data/recode_cjk.' . $phpEx);
 929		}
 930		return gb2312($string);
 931	}
 932
 933	// Trigger an error?! Fow now just give bad data :-(
 934	trigger_error('Unknown encoding: ' . $encoding, E_USER_ERROR);
 935	//return $string; // use utf_normalizer::cleanup() ?
 936}
 937
 938/**
 939* Replace all UTF-8 chars that are not in ASCII with their NCR
 940*
 941* @param	string	$text		UTF-8 string in NFC
 942* @return	string				ASCII string using NCRs for non-ASCII chars
 943*/
 944function utf8_encode_ncr($text)
 945{
 946	return preg_replace_callback('#[\\xC2-\\xF4][\\x80-\\xBF]{1,3}#', 'utf8_encode_ncr_callback', $text);
 947}
 948
 949/**
 950* Callback used in encode_ncr()
 951*
 952* Takes a UTF-8 char and replaces it with its NCR. Attention, $m is an array
 953*
 954* @param	array	$m			0-based numerically indexed array passed by preg_replace_callback()
 955* @return	string				A HTML NCR if the character is valid, or the original string otherwise
 956*/
 957function utf8_encode_ncr_callback($m)
 958{
 959	return '&#' . utf8_ord($m[0]) . ';';
 960}
 961
 962/**
 963* Converts a UTF-8 char to an NCR
 964*
 965* @param string $chr UTF-8 char
 966* @return integer UNICODE code point
 967*/
 968function utf8_ord($chr)
 969{
 970	switch (strlen($chr))
 971	{
 972		case 1:
 973			return ord($chr);
 974		break;
 975
 976		case 2:
 977			return ((ord($chr[0]) & 0x1F) << 6) | (ord($chr[1]) & 0x3F);
 978		break;
 979
 980		case 3:
 981			return ((ord($chr[0]) & 0x0F) << 12) | ((ord($chr[1]) & 0x3F) << 6) | (ord($chr[2]) & 0x3F);
 982		break;
 983
 984		case 4:
 985			return ((ord($chr[0]) & 0x07) << 18) | ((ord($chr[1]) & 0x3F) << 12) | ((ord($chr[2]) & 0x3F) << 6) | (ord($chr[3]) & 0x3F);
 986		break;
 987
 988		default:
 989			return $chr;
 990	}
 991}
 992
 993/**
 994* Converts an NCR to a UTF-8 char
 995*
 996* @param	int		$cp	UNICODE code point
 997* @return	string		UTF-8 char
 998*/
 999function utf8_chr($cp)
1000{
1001	if ($cp > 0xFFFF)
1002	{
1003		return chr(0xF0 | ($cp >> 18)) . chr(0x80 | (($cp >> 12) & 0x3F)) . chr(0x80 | (($cp >> 6) & 0x3F)) . chr(0x80 | ($cp & 0x3F));
1004	}
1005	else if ($cp > 0x7FF)
1006	{
1007		return chr(0xE0 | ($cp >> 12)) . chr(0x80 | (($cp >> 6) & 0x3F)) . chr(0x80 | ($cp & 0x3F));
1008	}
1009	else if ($cp > 0x7F)
1010	{
1011		return chr(0xC0 | ($cp >> 6)) . chr(0x80 | ($cp & 0x3F));
1012	}
1013	else
1014	{
1015		return chr($cp);
1016	}
1017}
1018
1019/**
1020* Convert Numeric Character References to UTF-8 chars
1021*
1022* Notes:
1023*	- we do not convert NCRs recursively, if you pass &#38;#38; it will return &#38;
1024*	- we DO NOT check for the existence of the Unicode characters, therefore an entity may be converted to an inexistent codepoint
1025*
1026* @param	string	$text		String to convert, encoded in UTF-8 (no normal form required)
1027* @return	string				UTF-8 string where NCRs have been replaced with the actual chars
1028*/
1029function utf8_decode_ncr($text)
1030{
1031	return preg_replace_callback('/&#([0-9]{1,6}|x[0-9A-F]{1,5});/i', 'utf8_decode_ncr_callback', $text);
1032}
1033
1034/**
1035* Callback used in decode_ncr()
1036*
1037* Takes a NCR (in decimal or hexadecimal) and returns a UTF-8 char. Attention, $m is an array.
1038* It will ignore most of invalid NCRs, but not all!
1039*
1040* @param	array	$m			0-based numerically indexed array passed by preg_replace_callback()
1041* @return	string				UTF-8 char
1042*/
1043function utf8_decode_ncr_callback($m)
1044{
1045	$cp = (strncasecmp($m[1], 'x', 1)) ? $m[1] : hexdec(substr($m[1], 1));
1046
1047	return utf8_chr($cp);
1048}
1049
1050/**
1051* Case folds a unicode string as per Unicode 5.0, section 3.13
1052*
1053* @param	string	$text	text to be case folded
1054* @param	string	$option	determines how we will fold the cases
1055* @return	string			case folded text
1056*/
1057function utf8_case_fold($text, $option = 'full')
1058{
1059	static $uniarray = array();
1060	global $phpbb_root_path, $phpEx;
1061
1062	// common is always set
1063	if (!isset($uniarray['c']))
1064	{
1065		$uniarray['c'] = include($phpbb_root_path . 'includes/utf/data/case_fold_c.' . $phpEx);
1066	}
1067
1068	// only set full if we need to
1069	if ($option === 'full' && !isset($uniarray['f']))
1070	{
1071		$uniarray['f'] = include($phpbb_root_path . 'includes/utf/data/case_fold_f.' . $phpEx);
1072	}
1073
1074	// only set simple if we need to
1075	if ($option !== 'full' && !isset($uniarray['s']))
1076	{
1077		$uniarray['s'] = include($phpbb_root_path . 'includes/utf/data/case_fold_s.' . $phpEx);
1078	}
1079
1080	// common is always replaced
1081	$text = strtr($text, $uniarray['c']);
1082
1083	if ($option === 'full')
1084	{
1085		// full replaces a character with multiple characters
1086		$text = strtr($text, $uniarray['f']);
1087	}
1088	else
1089	{
1090		// simple replaces a character with another character
1091		$text = strtr($text, $uniarray['s']);
1092	}
1093
1094	return $text;
1095}
1096
1097/**
1098* Takes the input and does a "special" case fold. It does minor normalization
1099* and returns NFKC compatable text
1100*
1101* @param	string	$text	text to be case folded
1102* @param	string	$option	determines how we will fold the cases
1103* @return	string			case folded text
1104*/
1105function utf8_case_fold_nfkc($text, $option = 'full')
1106{
1107	static $fc_nfkc_closure = array(
1108		"\xCD\xBA"	=> "\x20\xCE\xB9",
1109		"\xCF\x92"	=> "\xCF\x85",
1110		"\xCF\x93"	=> "\xCF\x8D",
1111		"\xCF\x94"	=> "\xCF\x8B",
1112		"\xCF\xB2"	=> "\xCF\x83",
1113		"\xCF\xB9"	=> "\xCF\x83",
1114		"\xE1\xB4\xAC"	=> "\x61",
1115		"\xE1\xB4\xAD"	=> "\xC3\xA6",
1116		"\xE1\xB4\xAE"	=> "\x62",
1117		"\xE1\xB4\xB0"	=> "\x64",
1118		"\xE1\xB4\xB1"	=> "\x65",
1119		"\xE1\xB4\xB2"	=> "\xC7\x9D",
1120		"\xE1\xB4\xB3"	=> "\x67",
1121		"\xE1\xB4\xB4"	=> "\x68",
1122		"\xE1\xB4\xB5"	=> "\x69",
1123		"\xE1\xB4\xB6"	=> "\x6A",
1124		"\xE1\xB4\xB7"	=> "\x6B",
1125		"\xE1\xB4\xB8"	=> "\x6C",
1126		"\xE1\xB4\xB9"	=> "\x6D",
1127		"\xE1\xB4\xBA"	=> "\x6E",
1128		"\xE1\xB4\xBC"	=> "\x6F",
1129		"\xE1\xB4\xBD"	=> "\xC8\xA3",
1130		"\xE1\xB4\xBE"	=> "\x70",
1131		"\xE1\xB4\xBF"	=> "\x72",
1132		"\xE1\xB5\x80"	=> "\x74",
1133		"\xE1\xB5\x81"	=> "\x75",
1134		"\xE1\xB5\x82"	=> "\x77",
1135		"\xE2\x82\xA8"	=> "\x72\x73",
1136		"\xE2\x84\x82"	=> "\x63",
1137		"\xE2\x84\x83"	=> "\xC2\xB0\x63",
1138		"\xE2\x84\x87"	=> "\xC9\x9B",
1139		"\xE2\x84\x89"	=> "\xC2\xB0\x66",
1140		"\xE2\x84\x8B"	=> "\x68",
1141		"\xE2\x84\x8C"	=> "\x68",
1142		"\xE2\x84\x8D"	=> "\x68",
1143		"\xE2\x84\x90"	=> "\x69",
1144		"\xE2\x84\x91"	=> "\x69",
1145		"\xE2\x84\x92"	=> "\x6C",
1146		"\xE2\x84\x95"	=> "\x6E",
1147		"\xE2\x84\x96"	=> "\x6E\x6F",
1148		"\xE2\x84\x99"	=> "\x70",
1149		"\xE2\x84\x9A"	=> "\x71",
1150		"\xE2\x84\x9B"	=> "\x72",
1151		"\xE2\x84\x9C"	=> "\x72",
1152		"\xE2\x84\x9D"	=> "\x72",
1153		"\xE2\x84\xA0"	=> "\x73\x6D",
1154		"\xE2\x84\xA1"	=> "\x74\x65\x6C",
1155		"\xE2\x84\xA2"	=> "\x74\x6D",
1156		"\xE2\x84\xA4"	=> "\x7A",
1157		"\xE2\x84\xA8"	=> "\x7A",
1158		"\xE2\x84\xAC"	=> "\x62",
1159		"\xE2\x84\xAD"	=> "\x63",
1160		"\xE2\x84\xB0"	=> "\x65",
1161		"\xE2\x84\xB1"	=> "\x66",
1162		"\xE2\x84\xB3"	=> "\x6D",
1163		"\xE2\x84\xBB"	=> "\x66\x61\x78",
1164		"\xE2\x84\xBE"	=> "\xCE\xB3",
1165		"\xE2\x84\xBF"	=> "\xCF\x80",
1166		"\xE2\x85\x85"	=> "\x64",
1167		"\xE3\x89\x90"	=> "\x70\x74\x65",
1168		"\xE3\x8B\x8C"	=> "\x68\x67",
1169		"\xE3\x8B\x8E"	=> "\x65\x76",
1170		"\xE3\x8B\x8F"	=> "\x6C\x74\x64",
1171		"\xE3\x8D\xB1"	=> "\x68\x70\x61",
1172		"\xE3\x8D\xB3"	=> "\x61\x75",
1173		"\xE3\x8D\xB5"	=> "\x6F\x76",
1174		"\xE3\x8D\xBA"	=> "\x69\x75",
1175		"\xE3\x8E\x80"	=> "\x70\x61",
1176		"\xE3\x8E\x81"	=> "\x6E\x61",
1177		"\xE3\x8E\x82"	=> "\xCE\xBC\x61",
1178		"\xE3\x8E\x83"	=> "\x6D\x61",
1179		"\xE3\x8E\x84"	=> "\x6B\x61",
1180		"\xE3\x8E\x85"	=> "\x6B\x62",
1181		"\xE3\x8E\x86"	=> "\x6D\x62",
1182		"\xE3\x8E\x87"	=> "\x67\x62",
1183		"\xE3\x8E\x8A"	=> "\x70\x66",
1184		"\xE3\x8E\x8B"	=> "\x6E\x66",
1185		"\xE3\x8E\x8C"	=> "\xCE\xBC\x66",
1186		"\xE3\x8E\x90"	=> "\x68\x7A",
1187		"\xE3\x8E\x91"	=> "\x6B\x68\x7A",
1188		"\xE3\x8E\x92"	=> "\x6D\x68\x7A",
1189		"\xE3\x8E\x93"	=> "\x67\x68\x7A",
1190		"\xE3\x8E\x94"	=> "\x74\x68\x7A",
1191		"\xE3\x8E\xA9"	=> "\x70\x61",
1192		"\xE3\x8E\xAA"	=> "\x6B\x70\x61",
1193		"\xE3\x8E\xAB"	=> "\x6D\x70\x61",
1194		"\xE3\x8E\xAC"	=> "\x67\x70\x61",
1195		"\xE3\x8E\xB4"	=> "\x70\x76",
1196		"\xE3\x8E\xB5"	=> "\x6E\x76",
1197		"\xE3\x8E\xB6"	=> "\xCE\xBC\x76",
1198		"\xE3\x8E\xB7"	=> "\x6D\x76",
1199		"\xE3\x8E\xB8"	=> "\x6B\x76",
1200		"\xE3\x8E\xB9"	=> "\x6D\x76",
1201		"\xE3\x8E\xBA"	=> "\x70\x77",
1202		"\xE3\x8E\xBB"	=> "\x6E\x77",
1203		"\xE3\x8E\xBC"	=> "\xCE\xBC\x77",
1204		"\xE3\x8E\xBD"	=> "\x6D\x77",
1205		"\xE3\x8E\xBE"	=> "\x6B\x77",
1206		"\xE3\x8E\xBF"	=> "\x6D\x77",
1207		"\xE3\x8F\x80"	=> "\x6B\xCF\x89",
1208		"\xE3\x8F\x81"	=> "\x6D\xCF\x89",
1209		"\xE3\x8F\x83"	=> "\x62\x71",
1210		"\xE3\x8F\x86"	=> "\x63\xE2\x88\x95\x6B\x67",
1211		"\xE3\x8F\x87"	=> "\x63\x6F\x2E",
1212		"\xE3\x8F\x88"	=> "\x64\x62",
1213		"\xE3\x8F\x89"	=> "\x67\x79",
1214		"\xE3\x8F\x8B"	=> "\x68\x70",
1215		"\xE3\x8F\x8D"	=> "\x6B\x6B",
1216		"\xE3\x8F\x8E"	=> "\x6B\x6D",
1217		"\xE3\x8F\x97"	=> "\x70\x68",
1218		"\xE3\x8F\x99"	=> "\x70\x70\x6D",
1219		"\xE3\x8F\x9A"	=> "\x70\x72",
1220		"\xE3\x8F\x9C"	=> "\x73\x76",
1221		"\xE3\x8F\x9D"	=> "\x77\x62",
1222		"\xE3\x8F\x9E"	=> "\x76\xE2\x88\x95\x6D",
1223		"\xE3\x8F\x9F"	=> "\x61\xE2\x88\x95\x6D",
1224		"\xF0\x9D\x90\x80"	=> "\x61",
1225		"\xF0\x9D\x90\x81"	=> "\x62",
1226		"\xF0\x9D\x90\x82"	=> "\x63",
1227		"\xF0\x9D\x90\x83"	=> "\x64",
1228		"\xF0\x9D\x90\x84"	=> "\x65",
1229		"\xF0\x9D\x90\x85"	=> "\x66",
1230		"\xF0\x9D\x90\x86"	=> "\x67",
1231		"\xF0\x9D\x90\x87"	=> "\x68",
1232		"\xF0\x9D\x90\x88"	=> "\x69",
1233		"\xF0\x9D\x90\x89"	=> "\x6A",
1234		"\xF0\x9D\x90\x8A"	=> "\x6B",
1235		"\xF0\x9D\x90\x8B"	=> "\x6C",
1236		"\xF0\x9D\x90\x8C"	=> "\x6D",
1237		"\xF0\x9D\x90\x8D"	=> "\x6E",
1238		"\xF0\x9D\x90\x8E"	=> "\x6F",
1239		"\xF0\x9D\x90\x8F"	=> "\x70",
1240		"\xF0\x9D\x90\x90"	=> "\x71",
1241		"\xF0\x9D\x90\x91"	=> "\x72",
1242		"\xF0\x9D\x90\x92"	=> "\x73",
1243		"\xF0\x9D\x90\x93"	=> "\x74",
1244		"\xF0\x9D\x90\x94"	=> "\x75",
1245		"\xF0\x9D\x90\x95"	=> "\x76",
1246		"\xF0\x9D\x90\x96"	=> "\x77",
1247		"\xF0\x9D\x90\x97"	=> "\x78",
1248		"\xF0\x9D\x90\x98"	=> "\x79",
1249		"\xF0\x9D\x90\x99"	=> "\x7A",
1250		"\xF0\x9D\x90\xB4"	=> "\x61",
1251		"\xF0\x9D\x90\xB5"	=> "\x62",
1252		"\xF0\x9D\x90\xB6"	=> "\x63",
1253		"\xF0\x9D\x90\xB7"	=> "\x64",
1254		"\xF0\x9D\x90\xB8"	=> "\x65",
1255		"\xF0\x9D\x90\xB9"	=> "\x66",
1256		"\xF0\x9D\x90\xBA"	=> "\x67",
1257		"\xF0\x9D\x90\xBB"	=> "\x68",
1258		"\xF0\x9D\x90\xBC"	=> "\x69",
1259		"\xF0\x9D\x90\xBD"	=> "\x6A",
1260		"\xF0\x9D\x90\xBE"	=> "\x6B",
1261		"\xF0\x9D\x90\xBF"	=> "\x6C",
1262		"\xF0\x9D\x91\x80"	=> "\x6D",
1263		"\xF0\x9D\x91\x81"	=> "\x6E",
1264		"\xF0\x9D\x91\x82"	=> "\x6F",
1265		"\xF0\x9D\x91\x83"	=> "\x70",
1266		"\xF0\x9D\x91\x84"	=> "\x71",
1267		"\xF0\x9D\x91\x85"	=> "\x72",
1268		"\xF0\x9D\x91\x86"	=> "\x73",
1269		"\xF0\x9D\x91\x87"	=> "\x74",
1270		"\xF0\x9D\x91\x88"	=> "\x75",
1271		"\xF0\x9D\x91\x89"	=> "\x76",
1272		"\xF0\x9D\x91\x8A"	=> "\x77",
1273		"\xF0\x9D\x91\x8B"	=> "\x78",
1274		"\xF0\x9D\x91\x8C"	=> "\x79",
1275		"\xF0\x9D\x91\x8D"	=> "\x7A",
1276		"\xF0\x9D\x91\xA8"	=> "\x61",
1277		"\xF0\x9D\x91\xA9"	=> "\x62",
1278		"\xF0\x9D\x91\xAA"	=> "\x63",
1279		"\xF0\x9D\x91\xAB"	=> "\x64",
1280		"\xF0\x9D\x91\xAC"	=> "\x65",
1281		"\xF0\x9D\x91\xAD"	=> "\x66",
1282		"\xF0\x9D\x91\xAE"	=> "\x67",
1283		"\xF0\x9D\x91\xAF"	=> "\x68",
1284		"\xF0\x9D\x91\xB0"	=> "\x69",
1285		"\xF0\x9D\x91\xB1"	=> "\x6A",
1286		"\xF0\x9D\x91\xB2"	=> "\x6B",
1287		"\xF0\x9D\x91\xB3"	=> "\x6C",
1288		"\xF0\x9D\x91\xB4"	=> "\x6D",
1289		"\xF0\x9D\x91\xB5"	=> "\x6E",
1290		"\xF0\x9D\x91\xB6"	=> "\x6F",
1291		"\xF0\x9D\x91\xB7"	=> "\x70",
1292		"\xF0\x9D\x91\xB8"	=> "\x71",
1293		"\xF0\x9D\x91\xB9"	=> "\x72",
1294		"\xF0\x9D\x91\xBA"	=> "\x73",
1295		"\xF0\x9D\x91\xBB"	=> "\x74",
1296		"\xF0\x9D\x91\xBC"	=> "\x75",
1297		"\xF0\x9D\x91\xBD"	=> "\x76",
1298		"\xF0\x9D\x91\xBE"	=> "\x77",
1299		"\xF0\x9D\x91\xBF"	=> "\x78",
1300		"\xF0\x9D\x92\x80"	=> "\x79",
1301		"\xF0\x9D\x92\x81"	=> "\x7A",
1302		"\xF0\x9D\x92\x9C"	=> "\x61",
1303		"\xF0\x9D\x92\x9E"	=> "\x63",
1304		"\xF0\x9D\x92\x9F"	=> "\x64",
1305		"\xF0\x9D\x92\xA2"	=> "\x67",
1306		"\xF0\x9D\x92\xA5"	=> "\x6A",
1307		"\xF0\x9D\x92\xA6"	=> "\x6B",
1308		"\xF0\x9D\x92\xA9"	=> "\x6E",
1309		"\xF0\x9D\x92\xAA"	=> "\x6F",
1310		"\xF0\x9D\x92\xAB"	=> "\x70",
1311		"\xF0\x9D\x92\xAC"	=> "\x71",
1312		"\xF0\x9D\x92\xAE"	=> "\x73",
1313		"\xF0\x9D\x92\xAF"	=> "\x74",
1314		"\xF0\x9D\x92\xB0"	=> "\x75",
1315		"\xF0\x9D\x92\xB1"	=> "\x76",
1316		"\xF0\x9D\x92\xB2"	=> "\x77",
1317		"\xF0\x9D\x92\xB3"	=> "\x78",
1318		"\xF0\x9D\x92\xB4"	=> "\x79",
1319		"\xF0\x9D\x92\xB5"	=> "\x7A",
1320		"\xF0\x9D\x93\x90"	=> "\x61",
1321		"\xF0\x9D\x93\x91"	=> "\x62",
1322		"\xF0\x9D\x93\x92"	=> "\x63",
1323		"\xF0\x9D\x93\x93"	=> "\x64",
1324		"\xF0\x9D\x93\x94"	=> "\x65",
1325		"\xF0\x9D\x93\x95"	=> "\x66",
1326		"\xF0\x9D\x93\x96"	=> "\x67",
1327		"\xF0\x9D\x93\x97"	=> "\x68",
1328		"\xF0\x9D\x93\x98"	=> "\x69",
1329		"\xF0\x9D\x93\x99"	=> "\x6A",
1330		"\xF0\x9D\x93\x9A"	=> "\x6B",
1331		"\xF0\x9D\x93\x9B"	=> "\x6C",
1332		"\xF0\x9D\x93\x9C"	=> "\x6D",
1333		"\xF0\x9D\x93\x9D"	=> "\x6E",
1334		"\xF0\x9D\x93\x9E"	=> "\x6F",
1335		"\xF0\x9D\x93\x9F"	=> "\x70",
1336		"\xF0\x9D\x93\xA0"	=> "\x71",
1337		"\xF0\x9D\x93\xA1"	=> "\x72",
1338		"\xF0\x9D\x93\xA2"	=> "\x73",
1339		"\xF0\x9D\x93\xA3"	=> "\x74",
1340		"\xF0\x9D\x93\xA4"	=> "\x75",
1341		"\xF0\x9D\x93\xA5"	=> "\x76",
1342		"\xF0\x9D\x93\xA6"	=> "\x77",
1343		"\xF0\x9D\x93\xA7"	=> "\x78",
1344		"\xF0\x9D\x93\xA8"	=> "\x79",
1345		"\xF0\x9D\x93\xA9"	=> "\x7A",
1346		"\xF0\x9D\x94\x84"	=> "\x61",
1347		"\xF0\x9D\x94\x85"	=> "\x62",
1348		"\xF0\x9D\x94\x87"	=> "\x64",
1349		"\xF0\x9D\x94\x88"	=> "\x65",
1350		"\xF0\x9D\x94\x89"	=> "\x66",
1351		"\xF0\x9D\x94\x8A"	=> "\x67",
1352		"\xF0\x9D\x94\x8D"	=> "\x6A",
1353		"\xF0\x9D\x94\x8E"	=> "\x6B",
1354		"\xF0\x9D\x94\x8F"	=> "\x6C",
1355		"\xF0\x9D\x94\x90"	=> "\x6D",
1356		"\xF0\x9D\x94\x91"	=> "\x6E",
1357		"\xF0\x9D\x94\x92"	=> "\x6F",
1358		"\xF0\x9D\x94\x93"	=> "\x70",
1359		"\xF0\x9D\x94\x94"	=> "\x71",
1360		"\xF0\x9D\x94\x96"	=> "\x73",
1361		"\xF0\x9D\x94\x97"	=> "\x74",
1362		"\xF0\x9D\x94\x98"	=> "\x75",
1363		"\xF0\x9D\x94\x99"	=> "\x76",
1364		"\xF0\x9D\x94\x9A"	=> "\x77",
1365		"\xF0\x9D\x94\x9B"	=> "\x78",
1366		"\xF0\x9D\x94\x9C"	=> "\x79",
1367		"\xF0\x9D\x94\xB8"	=> "\x61",
1368		"\xF0\x9D\x94\xB9"	=> "\x62",
1369		"\xF0\x9D\x94\xBB"	=> "\x64",
1370		"\xF0\x9D\x94\xBC"	=> "\x65",
1371		"\xF0\x9D\x94\xBD"	=> "\x66",
1372		"\xF0\x9D\x94\xBE"	=> "\x67",
1373		"\xF0\x9D\x95\x80"	=> "\x69",
1374		"\xF0\x9D\x95\x81"	=> "\x6A",
1375		"\xF0\x9D\x95\x82"	=> "\x6B",
1376		"\xF0\x9D\x95\x83"	=> "\x6C",
1377		"\xF0\x9D\x95\x84"	=> "\x6D",
1378		"\xF0\x9D\x95\x86"	=> "\x6F",
1379		"\xF0\x9D\x95\x8A"	=> "\x73",
1380		"\xF0\x9D\x95\x8B"	=> "\x74",
1381		"\xF0\x9D\x95\x8C"	=> "\x75",
1382		"\xF0\x9D\x95\x8D"	=> "\x76",
1383		"\xF0\x9D\x95\x8E"	=> "\x77",
1384		"\xF0\x9D\x95\x8F"	=> "\x78",
1385		"\xF0\x9D\x95\x90"	=> "\x79",
1386		"\xF0\x9D\x95\xAC"	=> "\x61",
1387		"\xF0\x9D\x95\xAD"	=> "\x62",
1388		"\xF0\x9D\x95\xAE"	=> "\x63",
1389		"\xF0\x9D\x95\xAF"	=> "\x64",
1390		"\xF0\x9D\x95\xB0"	=> "\x65",
1391		"\xF0\x9D\x95\xB1"	=> "\x66",
1392		"\xF0\x9D\x95\xB2"	=> "\x67",
1393		"\xF0\x9D\x95\xB3"	=> "\x68",
1394		"\xF0\x9D\x95\xB4"	=> "\x69",
1395		"\xF0\x9D\x95\xB5"	=> "\x6A",
1396		"\xF0\x9D\x95\xB6"	=> "\x6B",
1397		"\xF0\x9D\x95\xB7"	=> "\x6C",
1398		"\xF0\x9D\x95\xB8"	=> "\x6D",
1399		"\xF0\x9D\x95\xB9"	=> "\x6E",
1400		"\xF0\x9D\x95\xBA"	=> "\x6F",
1401		"\xF0\x9D\x95\xBB"	=> "\x70",
1402		"\xF0\x9D\x95\xBC"	=> "\x71",
1403		"\xF0\x9D\x95\xBD"	=> "\x72",
1404		"\xF0\x9D\x95\xBE"	=> "\x73",
1405		"\xF0\x9D\x95\xBF"	=> "\x74",
1406		"\xF0\x9D\x96\x80"	=> "\x75",
1407		"\xF0\x9D\x96\x81"	=> "\x76",
1408		"\xF0\x9D\x96\x82"	=> "\x77",
1409		"\xF0\x9D\x96\x83"	=> "\x78",
1410		"\xF0\x9D\x96\x84"	=> "\x79",
1411		"\xF0\x9D\x96\x85"	=> "\x7A",
1412		"\xF0\x9D\x96\xA0"	=> "\x61",
1413		"\xF0\x9D\x96\xA1"	=> "\x62",
1414		"\xF0\x9D\x96\xA2"	=> "\x63",
1415		"\xF0\x9D\x96\xA3"	=> "\x64",
1416		"\xF0\x9D\x96\xA4"	=> "\x65",
1417		"\xF0\x9D\x96\xA5"	=> "\x66",
1418		"\xF0\x9D\x96\xA6"	=> "\x67",
1419		"\xF0\x9D\x96\xA7"	=> "\x68",
1420		"\xF0\x9D\x96\xA8"	=> "\x69",
1421		"\xF0\x9D\x96\xA9"	=> "\x6A",
1422		"\xF0\x9D\x96\xAA"	=> "\x6B",
1423		"\xF0\x9D\x96\xAB"	=> "\x6C",
1424		"\xF0\x9D\x96\xAC"	=> "\x6D",
1425		"\xF0\x9D\x96\xAD"	=> "\x6E",
1426		"\xF0\x9D\x96\xAE"	=> "\x6F",
1427		"\xF0\x9D\x96\xAF"	=> "\x70",
1428		"\xF0\x9D\x96\xB0"	=> "\x71",
1429		"\xF0\x9D\x96\xB1"	=> "\x72",
1430		"\xF0\x9D\x96\xB2"	=> "\x73",
1431		"\xF0\x9D\x96\xB3"	=> "\x74",
1432		"\xF0\x9D\x96\xB4"	=> "\x75",
1433		"\xF0\x9D\x96\xB5"	=> "\x76",
1434		"\xF0\x9D\x96\xB6"	=> "\x77",
1435		"\xF0\x9D\x96\xB7"	=> "\x78",
1436		"\xF0\x9D\x96\xB8"	=> "\x79",
1437		"\xF0\x9D\x96\xB9"	=> "\x7A",
1438		"\xF0\x9D\x97\x94"	=> "\x61",
1439		"\xF0\x9D\x97\x95"	=> "\x62",
1440		"\xF0\x9D\x97\x96"	=> "\x63",
1441		"\xF0\x9D\x97\x97"	=> "\x64",
1442		"\xF0\x9D\x97\x98"	=> "\x65",
1443		"\xF0\x9D\x97\x99"	=> "\x66",
1444		"\xF0\x9D\x97\x9A"	=> "\x67",
1445		"\xF0\x9D\x97\x9B"	=> "\x68",
1446		"\xF0\x9D\x97\x9C"	=> "\x69",
1447		"\xF0\x9D\x97\x9D"	=> "\x6A",
1448		"\xF0\x9D\x97\x9E"	=> "\x6B",
1449		"\xF0\x9D\x97\x9F"	=> "\x6C",
1450		"\xF0\x9D\x97\xA0"	=> "\x6D",
1451		"\xF0\x9D\x97\xA1"	=> "\x6E",
1452		"\xF0\x9D\x97\xA2"	=> "\x6F",
1453		"\xF0\x9D\x97\xA3"	=> "\x70",
1454		"\xF0\x9D\x97\xA4"	=> "\x71",
1455		"\xF0\x9D\x97\xA5"	=> "\x72",
1456		"\xF0\x9D\x97\xA6"	=> "\x73",
1457		"\xF0\x9D\x97\xA7"	=> "\x74",
1458		"\xF0\x9D\x97\xA8"	=> "\x75",
1459		"\xF0\x9D\x97\xA9"	=> "\x76",
1460		"\xF0\x9D\x97\xAA"	=> "\x77",
1461		"\xF0\x9D\x97\xAB"	=> "\x78",
1462		"\xF0\x9D\x97\xAC"	=> "\x79",
1463		"\xF0\x9D\x97\xAD"	=> "\x7A",
1464		"\xF0\x9D\x98\x88"	=> "\x61",
1465		"\xF0\x9D\x98\x89"	=> "\x62",
1466		"\xF0\x9D\x98\x8A"	=> "\x63",
1467		"\xF0\x9D\x98\x8B"	=> "\x64",
1468		"\xF0\x9D\x98\x8C"	=> "\x65",
1469		"\xF0\x9D\x98\x8D"	=> "\x66",
1470		"\xF0\x9D\x98\x8E"	=> "\x67",
1471		"\xF0\x9D\x98\x8F"	=> "\x68",
1472		"\xF0\x9D\x98\x90"	=> "\x69",
1473		"\xF0\x9D\x98\x91"	=> "\x6A",
1474		"\xF0\x9D\x98\x92"	=> "\x6B",
1475		"\xF0\x9D\x98\x93"	=> "\x6C",
1476		"\xF0\x9D\x98\x94"	=> "\x6D",
1477		"\xF0\x9D\x98\x95"	=> "\x6E",
1478		"\xF0\x9D\x98\x96"	=> "\x6F",
1479		"\xF0\x9D\x98\x97"	=> "\x70",
1480		"\xF0\x9D\x98\x98"	=> "\x71",
1481		"\xF0\x9D\x98\x99"	=> "\x72",
1482		"\xF0\x9D\x98\x9A"	=> "\x73",
1483		"\xF0\x9D\x98\x9B"	=> "\x74",
1484		"\xF0\x9D\x98\x9C"	=> "\x75",
1485		"\xF0\x9D\x98\x9D"	=> "\x76",
1486		"\xF0\x9D\x98\x9E"	=> "\x77",
1487		"\xF0\x9D\x98\x9F"	=> "\x78",
1488		"\xF0\x9D\x98\xA0"	=> "\x79",
1489		"\xF0\x9D\x98\xA1"	=> "\x7A",
1490		"\xF0\x9D\x98\xBC"	=> "\x61",
1491		"\xF0\x9D\x98\xBD"	=> "\x62",
1492		"\xF0\x9D\x98\xBE"	=> "\x63",
1493		"\xF0\x9D\x98\xBF"	=> "\x64",
1494		"\xF0\x9D\x99\x80"	=> "\x65",
1495		"\xF0\x9D\x99\x81"	=> "\x66",
1496		"\xF0\x9D\x99\x82"	=> "\x67",
1497		"\xF0\x9D\x99\x83"	=> "\x68",
1498		"\xF0\x9D\x99\x84"	=> "\x69",
1499		"\xF0\x9D\x99\x85"	=> "\x6A",
1500		"\xF0\x9D\x99\x86"	=> "\x6B",
1501		"\xF0\x9D\x99\x87"	=> "\x6C",
1502		"\xF0\x9D\x99\x88"	=> "\x6D",
1503		"\xF0\x9D\x99\x89"	=> "\x6E",
1504		"\xF0\x9D\x99\x8A"	=> "\x6F",
1505		"\xF0\x9D\x99\x8B"	=> "\x70",
1506		"\xF0\x9D\x99\x8C"	=> "\x71",
1507		"\xF0\x9D\x99\x8D"	=> "\x72",
1508		"\xF0\x9D\x99\x8E"	=> "\x73",
1509		"\xF0\x9D\x99\x8F"	=> "\x74",
1510		"\xF0\x9D\x99\x90"	=> "\x75",
1511		"\xF0\x9D\x99\x91"	=> "\x76",
1512		"\xF0\x9D\x99\x92"	=> "\x77",
1513		"\xF0\x9D\x99\x93"	=> "\x78",
1514		"\xF0\x9D\x99\x94"	=> "\x79",
1515		"\xF0\x9D\x99\x95"	=> "\x7A",
1516		"\xF0\x9D\x99\xB0"	=> "\x61",
1517		"\xF0\x9D\x99\xB1"	=> "\x62",
1518		"\xF0\x9D\x99\xB2"	=> "\x63",
1519		"\xF0\x9D\x99\xB3"	=> "\x64",
1520		"\xF0\x9D\x99\xB4"	=> "\x65",
1521		"\xF0\x9D\x99\xB5"	=> "\x66",
1522		"\xF0\x9D\x99\xB6"	=> "\x67",
1523		"\xF0\x9D\x99\xB7"	=> "\x68",
1524		"\xF0\x9D\x99\xB8"	=> "\x69",
1525		"\xF0\x9D\x99\xB9"	=> "\x6A",
1526		"\xF0\x9D\x99\xBA"	=> "\x6B",
1527		"\xF0\x9D\x99\xBB"	=> "\x6C",
1528		"\xF0\x9D\x99\xBC"	=> "\x6D",
1529		"\xF0\x9D\x99\xBD"	=> "\x6E",
1530		"\xF0\x9D\x99\xBE"	=> "\x6F",
1531		"\xF0\x9D\x99\xBF"	=> "\x70",
1532		"\xF0\x9D\x9A\x80"	=> "\x71",
1533		"\xF0\x9D\x9A\x81"	=> "\x72",
1534		"\xF0\x9D\x9A\x82"	=> "\x73",
1535		"\xF0\x9D\x9A\x83"	=> "\x74",
1536		"\xF0\x9D\x9A\x84"	=> "\x75",
1537		"\xF0\x9D\x9A\x85"	=> "\x76",
1538		"\xF0\x9D\x9A\x86"	=> "\x77",
1539		"\xF0\x9D\x9A\x87"	=> "\x78",
1540		"\xF0\x9D\x9A\x88"	=> "\x79",
1541		"\xF0\x9D\x9A\x89"	=> "\x7A",
1542		"\xF0\x9D\x9A\xA8"	=> "\xCE\xB1",
1543		"\xF0\x9D\x9A\xA9"	=> "\xCE\xB2",
1544		"\xF0\x9D\x9A\xAA"	=> "\xCE\xB3",
1545		"\xF0\x9D\x9A\xAB"	=> "\xCE\xB4",
1546		"\xF0\x9D\x9A\xAC"	=> "\xCE\xB5",
1547		"\xF0\x9D\x9A\xAD"	=> "\xCE\xB6",
1548		"\xF0\x9D\x9A\xAE"	=> "\xCE\xB7",
1549		"\xF0\x9D\x9A\xAF"	=> "\xCE\xB8",
1550		"\xF0\x9D\x9A\xB0"	=> "\xCE\xB9",
1551		"\xF0\x9D\x9A\xB1"	=> "\xCE\xBA",
1552		"\xF0\x9D\x9A\xB2"	=> "\xCE\xBB",
1553		"\xF0\x9D\x9A\xB3"	=> "\xCE\xBC",
1554		"\xF0\x9D\x9A\xB4"	=> "\xCE\xBD",
1555		"\xF0\x9D\x9A\xB5"	=> "\xCE\xBE",
1556		"\xF0\x9D\x9A\xB6"	=> "\xCE\xBF",
1557		"\xF0\x9D\x9A\xB7"	=> "\xCF\x80",
1558		"\xF0\x9D\x9A\xB8"	=> "\xCF\x81",
1559		"\xF0\x9D\x9A\xB9"	=> "\xCE\xB8",
1560		"\xF0\x9D\x9A\xBA"	=> "\xCF\x83",
1561		"\xF0\x9D\x9A\xBB"	=> "\xCF\x84",
1562		"\xF0\x9D\x9A\xBC"	=> "\xCF\x85",
1563		"\xF0\x9D\x9A\xBD"	=> "\xCF\x86",
1564		"\xF0\x9D\x9A\xBE"	=> "\xCF\x87",
1565		"\xF0\x9D\x9A\xBF"	=> "\xCF\x88",
1566		"\xF0\x9D\x9B\x80"	=> "\xCF\x89",
1567		"\xF0\x9D\x9B\x93"	=> "\xCF\x83",
1568		"\xF0\x9D\x9B\xA2"	=> "\xCE\xB1",
1569		"\xF0\x9D\x9B\xA3"	=> "\xCE\xB2",
1570		"\xF0\x9D\x9B\xA4"	=> "\xCE\xB3",
1571		"\xF0\x9D\x9B\xA5"	=> "\xCE\xB4",
1572		"\xF0\x9D\x9B\xA6"	=> "\xCE\xB5",
1573		"\xF0\x9D\x9B\xA7"	=> "\xCE\xB6",
1574		"\xF0\x9D\x9B\xA8"	=> "\xCE\xB7",
1575		"\xF0\x9D\x9B\xA9"	=> "\xCE\xB8",
1576		"\xF0\x9D\x9B\xAA"	=> "\xCE\xB9",
1577		"\xF0\x9D\x9B\xAB"	=> "\xCE\xBA",
1578		"\xF0\x9D\x9B\xAC"	=> "\xCE\xBB",
1579		"\xF0\x9D\x9B\xAD"	=> "\xCE\xBC",
1580		"\xF0\x9D\x9B\xAE"	=> "\xCE\xBD",
1581		"\xF0\x9D\x9B\xAF"	=> "\xCE\xBE",
1582		"\xF0\x9D\x9B\xB0"	=> "\xCE\xBF",
1583		"\xF0\x9D\x9B\xB1"	=> "\xCF\x80",
1584		"\xF0\x9D\x9B\xB2"	=> "\xCF\x81",
1585		"\xF0\x9D\x9B\xB3"	=> "\xCE\xB8",
1586		"\xF0\x9D\x9B\xB4"	=> "\xCF\x83",
1587		"\xF0\x9D\x9B\xB5"	=> "\xCF\x84",
1588		"\xF0\x9D\x9B\xB6"	=> "\xCF\x85",
1589		"\xF0\x9D\x9B\xB7"	=> "\xCF\x86",
1590		"\xF0\x9D\x9B\xB8"	=> "\xCF\x87",
1591		"\xF0\x9D\x9B\xB9"	=> "\xCF\x88",
1592		"\xF0\x9D\x9B\xBA"	=> "\xCF\x89",
1593		"\xF0\x9D\x9C\x8D"	=> "\xCF\x83",
1594		"\xF0\x9D\x9C\x9C"	=> "\xCE\xB1",
1595		"\xF0\x9D\x9C\x9D"	=> "\xCE\xB2",
1596		"\xF0\x9D\x9C\x9E"	=> "\xCE\xB3",
1597		"\xF0\x9D\x9C\x9F"	=> "\xCE\xB4",
1598		"\xF0\x9D\x9C\xA0"	=> "\xCE\xB5",
1599		"\xF0\x9D\x9C\xA1"	=> "\xCE\xB6",
1600		"\xF0\x9D\x9C\xA2"	=> "\xCE\xB7",
1601		"\xF0\x9D\x9C\xA3"	=> "\xCE\xB8",
1602		"\xF0\x9D\x9C\xA4"	=> "\xCE\xB9",
1603		"\xF0\x9D\x9C\xA5"	=> "\xCE\xBA",
1604		"\xF0\x9D\x9C\xA6"	=> "\xCE\xBB",
1605		"\xF0\x9D\x9C\xA7"	=> "\xCE\xBC",
1606		"\xF0\x9D\x9C\xA8"	=> "\xCE\xBD",
1607		"\xF0\x9D\x9C\xA9"	=> "\xCE\xBE",
1608		"\xF0\x9D\x9C\xAA"	=> "\xCE\xBF",
1609		"\xF0\x9D\x9C\xAB"	=> "\xCF\x80",
1610		"\xF0\x9D\x9C\xAC"	=> "\xCF\x81",
1611		"\xF0\x9D\x9C\xAD"	=> "\xCE\xB8",
1612		"\xF0\x9D\x9C\xAE"	=> "\xCF\x83",
1613		"\xF0\x9D\x9C\xAF"	=> "\xCF\x84",
1614		"\xF0\x9D\x9C\xB0"	=> "\xCF\x85",
1615		"\xF0\x9D\x9C\xB1"	=> "\xCF\x86",
1616		"\xF0\x9D\x9C\xB2"	=> "\xCF\x87",
1617		"\xF0\x9D\x9C\xB3"	=> "\xCF\x88",
1618		"\xF0\x9D\x9C\xB4"	=> "\xCF\x89",
1619		"\xF0\x9D\x9D\x87"	=> "\xCF\x83",
1620		"\xF0\x9D\x9D\x96"	=> "\xCE\xB1",
1621		"\xF0\x9D\x9D\x97"	=> "\xCE\xB2",
1622		"\xF0\x9D\x9D\x98"	=> "\xCE\xB3",
1623		"\xF0\x9D\x9D\x99"	=> "\xCE\xB4",
1624		"\xF0\x9D\x9D\x9A"	=> "\xCE\xB5",
1625		"\xF0\x9D\x9D\x9B"	=> "\xCE\xB6",
1626		"\xF0\x9D\x9D\x9C"	=> "\xCE\xB7",
1627		"\xF0\x9D\x9D\x9D"	=> "\xCE\xB8",
1628		"\xF0\x9D\x9D\x9E"	=> "\xCE\xB9",
1629		"\xF0\x9D\x9D\x9F"	=> "\xCE\xBA",
1630		"\xF0\x9D\x9D\xA0"	=> "\xCE\xBB",
1631		"\xF0\x9D\x9D\xA1"	=> "\xCE\xBC",
1632		"\xF0\x9D\x9D\xA2"	=> "\xCE\xBD",
1633		"\xF0\x9D\x9D\xA3"	=> "\xCE\xBE",
1634		"\xF0\x9D\x9D\xA4"	=> "\xCE\xBF",
1635		"\xF0\x9D\x9D\xA5"	=> "\xCF\x80",
1636		"\xF0\x9D\x9D\xA6"	=> "\xCF\x81",
1637		"\xF0\x9D\x9D\xA7"	=> "\xCE\xB8",
1638		"\xF0\x9D\x9D\xA8"	=> "\xCF\x83",
1639		"\xF0\x9D\x9D\xA9"	=> "\xCF\x84",
1640		"\xF0\x9D\x9D\xAA"	=> "\xCF\x85",
1641		"\xF0\x9D\x9D\xAB"	=> "\xCF\x86",
1642		"\xF0\x9D\x9D\xAC"	=> "\xCF\x87",
1643		"\xF0\x9D\x9D\xAD"	=> "\xCF\x88",
1644		"\xF0\x9D\x9D\xAE"	=> "\xCF\x89",
1645		"\xF0\x9D\x9E\x81"	=> "\xCF\x83",
1646		"\xF0\x9D\x9E\x90"	=> "\xCE\xB1",
1647		"\xF0\x9D\x9E\x91"	=> "\xCE\xB2",
1648		"\xF0\x9D\x9E\x92"	=> "\xCE\xB3",
1649		"\xF0\x9D\x9E\x93"	=> "\xCE\xB4",
1650		"\xF0\x9D\x9E\x94"	=> "\xCE\xB5",
1651		"\xF0\x9D\x9E\x95"	=> "\xCE\xB6",
1652		"\xF0\x9D\x9E\x96"	=> "\xCE\xB7",
1653		"\xF0\x9D\x9E\x97"	=> "\xCE\xB8",
1654		"\xF0\x9D\x9E\x98"	=> "\xCE\xB9",
1655		"\xF0\x9D\x9E\x99"	=> "\xCE\xBA",
1656		"\xF0\x9D\x9E\x9A"	=> "\xCE\xBB",
1657		"\xF0\x9D\x9E\x9B"	=> "\xCE\xBC",
1658		"\xF0\x9D\x9E\x9C"	=> "\xCE\xBD",
1659		"\xF0\x9D\x9E\x9D"	=> "\xCE\xBE",
1660		"\xF0\x9D\x9E\x9E"	=> "\xCE\xBF",
1661		"\xF0\x9D\x9E\x9F"	=> "\xCF\x80",
1662		"\xF0\x9D\x9E\xA0"	=> "\xCF\x81",
1663		"\xF0\x9D\x9E\xA1"	=> "\xCE\xB8",
1664		"\xF0\x9D\x9E\xA2"	=> "\xCF\x83",
1665		"\xF0\x9D\x9E\xA3"	=> "\xCF\x84",
1666		"\xF0\x9D\x9E\xA4"	=> "\xCF\x85",
1667		"\xF0\x9D\x9E\xA5"	=> "\xCF\x86",
1668		"\xF0\x9D\x9E\xA6"	=> "\xCF\x87",
1669		"\xF0\x9D\x9E\xA7"	=> "\xCF\x88",
1670		"\xF0\x9D\x9E\xA8"	=> "\xCF\x89",
1671		"\xF0\x9D\x9E\xBB"	=> "\xCF\x83",
1672		"\xF0\x9D\x9F\x8A"	=> "\xCF\x9D",
1673	);
1674	global $phpbb_root_path, $phpEx;
1675
1676	// do the case fold
1677	$text = utf8_case_fold($text, $option);
1678
1679	if (!class_exists('utf_normalizer'))
1680	{
1681		global $phpbb_root_path, $phpEx;
1682		include($phpbb_root_path . 'includes/utf/utf_normalizer.' . $phpEx);
1683	}
1684
1685	// convert to NFKC
1686	utf_normalizer::nfkc($text);
1687
1688	// FC_NFKC_Closure, http://www.unicode.org/Public/5.0.0/ucd/DerivedNormalizationProps.txt
1689	$text = strtr($text, $fc_nfkc_closure);
1690
1691	return $text;
1692}
1693
1694/**
1695* Assume the input is NFC:
1696* Takes the input and does a "special" case fold. It does minor normalization as well.
1697*
1698* @param	string	$text	text to be case folded
1699* @param	string	$option	determines how we will fold the cases
1700* @return	string			case folded text
1701*/
1702function utf8_case_fold_nfc($text, $option = 'full')
1703{
1704	static $uniarray = array();
1705	static $ypogegrammeni = array(
1706		"\xCD\xBA"		=> "\x20\xCD\x85",
1707		"\xE1\xBE\x80"	=> "\xE1\xBC\x80\xCD\x85",
1708		"\xE1\xBE\x81"	=> "\xE1\xBC\x81\xCD\x85",
1709		"\xE1\xBE\x82"	=> "\xE1\xBC\x82\xCD\x85",
1710		"\xE1\xBE\x83"	=> "\xE1\xBC\x83\xCD\x85",
1711		"\xE1\xBE\x84"	=> "\xE1\xBC\x84\xCD\x85",
1712		"\xE1\xBE\x85"	=> "\xE1\xBC\x85\xCD\x85",
1713		"\xE1\xBE\x86"	=> "\xE1\xBC\x86\xCD\x85",
1714		"\xE1\xBE\x87"	=> "\xE1\xBC\x87\xCD\x85",
1715		"\xE1\xBE\x88"	=> "\xE1\xBC\x88\xCD\x85",
1716		"\xE1\xBE\x89"	=> "\xE1\xBC\x89\xCD\x85",
1717		"\xE1\xBE\x8A"	=> "\xE1\xBC\x8A\xCD\x85",
1718		"\xE1\xBE\x8B"	=> "\xE1\xBC\x8B\xCD\x85",
1719		"\xE1\xBE\x8C"	=> "\xE1\xBC\x8C\xCD\x85",
1720		"\xE1\xBE\x8D"	=> "\xE1\xBC\x8D\xCD\x85",
1721		"\xE1\xBE\x8E"	=> "\xE1\xBC\x8E\xCD\x85",
1722		"\xE1\xBE\x8F"	=> "\xE1\xBC\x8F\xCD\x85",
1723		"\xE1\xBE\x90"	=> "\xE1\xBC\xA0\xCD\x85",
1724		"\xE1\xBE\x91"	=> "\xE1\xBC\xA1\xCD\x85",
1725		"\xE1\xBE\x92"	=> "\xE1\xBC\xA2\xCD\x85",
1726		"\xE1\xBE\x93"	=> "\xE1\xBC\xA3\xCD\x85",
1727		"\xE1\xBE\x94"	=> "\xE1\xBC\xA4\xCD\x85",
1728		"\xE1\xBE\x95"	=> "\xE1\xBC\xA5\xCD\x85",
1729		"\xE1\xBE\x96"	=> "\xE1\xBC\xA6\xCD\x85",
1730		"\xE1\xBE\x97"	=> "\xE1\xBC\xA7\xCD\x85",
1731		"\xE1\xBE\x98"	=> "\xE1\xBC\xA8\xCD\x85",
1732		"\xE1\xBE\x99"	=> "\xE1\xBC\xA9\xCD\x85",
1733		"\xE1\xBE\x9A"	=> "\xE1\xBC\xAA\xCD\x85",
1734		"\xE1\xBE\x9B"	=> "\xE1\xBC\xAB\xCD\x85",
1735		"\xE1\xBE\x9C"	=> "\xE1\xBC\xAC\xCD\x85",
1736		"\xE1\xBE\x9D"	=> "\xE1\xBC\xAD\xCD\x85",
1737		"\xE1\xBE\x9E"	=> "\xE1\xBC\xAE\xCD\x85",
1738		"\xE1\xBE\x9F"	=> "\xE1\xBC\xAF\xCD\x85",
1739		"\xE1\xBE\xA0"	=> "\xE1\xBD\xA0\xCD\x85",
1740		"\xE1\xBE\xA1"	=> "\xE1\xBD\xA1\xCD\x85",
1741		"\xE1\xBE\xA2"	=> "\xE1\xBD\xA2\xCD\x85",
1742		"\xE1\xBE\xA3"	=> "\xE1\xBD\xA3\xCD\x85",
1743		"\xE1\xBE\xA4"	=> "\xE1\xBD\xA4\xCD\x85",
1744		"\xE1\xBE\xA5"	=> "\xE1\xBD\xA5\xCD\x85",
1745		"\xE1\xBE\xA6"	=> "\xE1\xBD\xA6\xCD\x85",
1746		"\xE1\xBE\xA7"	=> "\xE1\xBD\xA7\xCD\x85",
1747		"\xE1\xBE\xA8"	=> "\xE1\xBD\xA8\xCD\x85",
1748		"\xE1\xBE\xA9"	=> "\xE1\xBD\xA9\xCD\x85",
1749		"\xE1\xBE\xAA"	=> "\xE1\xBD\xAA\xCD\x85",
1750		"\xE1\xBE\xAB"	=> "\xE1\xBD\xAB\xCD\x85",
1751		"\xE1\xBE\xAC"	=> "\xE1\xBD\xAC\xCD\x85",
1752		"\xE1\xBE\xAD"	=> "\xE1\xBD\xAD\xCD\x85",
1753		"\xE1\xBE\xAE"	=> "\xE1\xBD\xAE\xCD\x85",
1754		"\xE1\xBE\xAF"	=> "\xE1\xBD\xAF\xCD\x85",
1755		"\xE1\xBE\xB2"	=> "\xE1\xBD\xB0\xCD\x85",
1756		"\xE1\xBE\xB3"	=> "\xCE\xB1\xCD\x85",
1757		"\xE1\xBE\xB4"	=> "\xCE\xAC\xCD\x85",
1758		"\xE1\xBE\xB7"	=> "\xE1\xBE\xB6\xCD\x85",
1759		"\xE1\xBE\xBC"	=> "\xCE\x91\xCD\x85",
1760		"\xE1\xBF\x82"	=> "\xE1\xBD\xB4\xCD\x85",
1761		"\xE1\xBF\x83"	=> "\xCE\xB7\xCD\x85",
1762		"\xE1\xBF\x84"	=> "\xCE\xAE\xCD\x85",
1763		"\xE1\xBF\x87"	=> "\xE1\xBF\x86\xCD\x85",
1764		"\xE1\xBF\x8C"	=> "\xCE\x97\xCD\x85",
1765		"\xE1\xBF\xB2"	=> "\xE1\xBD\xBC\xCD\x85",
1766		"\xE1\xBF\xB3"	=> "\xCF\x89\xCD\x85",
1767		"\xE1\xBF\xB4"	=> "\xCF\x8E\xCD\x85",
1768		"\xE1\xBF\xB7"	=> "\xE1\xBF\xB6\xCD\x85",
1769		"\xE1\xBF\xBC"	=> "\xCE\xA9\xCD\x85",
1770	);
1771	global $phpbb_root_path, $phpEx;
1772
1773	// perform a small trick, avoid further normalization on composed points that contain U+0345 in their decomposition
1774	$text = strtr($text, $ypogegrammeni);
1775
1776	// do the case fold
1777	$text = utf8_case_fold($text, $option);
1778
1779	return $text;
1780}
1781
1782/**
1783* A wrapper function for the normalizer which takes care of including the class if required and modifies the passed strings
1784* to be in NFC (Normalization Form Composition).
1785*
1786* @param	mixed	$strings	a string or an array of strings to normalize
1787* @return	mixed				the normalized content, preserving array keys if array given.
1788*/
1789function utf8_normalize_nfc($strings)
1790{
1791	if (empty($strings))
1792	{
1793		return $strings;
1794	}
1795
1796	if (!class_exists('utf_normalizer'))
1797	{
1798		global $phpbb_root_path, $phpEx;
1799		include($phpbb_root_path . 'includes/utf/utf_normalizer.' . $phpEx);
1800	}
1801
1802	if (!is_array($strings))
1803	{
1804		utf_normalizer::nfc($strings);
1805	}
1806	else if (is_array($strings))
1807	{
1808		foreach ($strings as $key => $string)
1809		{
1810			if (is_array($string))
1811			{
1812				foreach ($string as $_key => $_string)
1813				{
1814					utf_normalizer::nfc($strings[$key][$_key]);
1815				}
1816			}
1817			else
1818			{
1819				utf_normalizer::nfc($strings[$key]);
1820			}
1821		}
1822	}
1823
1824	return $strings;
1825}
1826
1827/**
1828* This function is used to generate a "clean" version of a string.
1829* Clean means that it is a case insensitive form (case folding) and that it is normalized (NFC).
1830* Additionally a homographs of one character are transformed into one specific character (preferably ASCII
1831* if it is an ASCII character).
1832*
1833* Please be aware that if you change something within this function or within
1834* functions used here you need to rebuild/update the username_clean column in the users table. And all other
1835* columns that store a clean string otherwise you will break this functionality.
1836*
1837* @param	string	$text	An unclean string, mabye user input (has to be valid UTF-8!)
1838* @return	string			Cleaned up version of the input string
1839*/
1840function utf8_clean_string($text)
1841{
1842	global $phpbb_root_path, $phpEx;
1843
1844	static $homographs = array();
1845	if (empty($homographs))
1846	{
1847		$homographs = include($phpbb_root_path . 'includes/utf/data/confusables.' . $phpEx);
1848	}
1849
1850	$text = utf8_case_fold_nfkc($text);
1851	$text = strtr($text, $homographs);
1852	// Other control characters
1853	$text = preg_replace('#(?:[\x00-\x1F\x7F]+|(?:\xC2[\x80-\x9F])+)#', '', $text);
1854
1855	// we need to reduce multiple spaces to a single one
1856	$text = preg_replace('# {2,}#', ' ', $text);
1857
1858	// we can use trim here as all the other space characters should have been turned
1859	// into normal ASCII spaces by now
1860	return trim($text);
1861}
1862
1863/**
1864* A wrapper for htmlspecialchars($value, ENT_COMPAT, 'UTF-8')
1865*/
1866function utf8_htmlspecialchars($value)
1867{
1868	return htmlspecialchars($value, ENT_COMPAT, 'UTF-8');
1869}
1870
1871/**
1872* Trying to convert returned system message to utf8
1873*
1874* PHP assumes such messages are ISO-8859-1 so we'll do that too
1875* and if it breaks messages we'll blame it on them ;-)
1876*/
1877function utf8_convert_message($message)
1878{
1879	// First of all check if conversion is neded at all, as there is no point
1880	// in converting ASCII messages from ISO-8859-1 to UTF-8
1881	if (!preg_match('/[\x80-\xFF]/', $message))
1882	{
1883		return utf8_htmlspecialchars($message);
1884	}
1885
1886	// else we need to convert some part of the message
1887	return utf8_htmlspecialchars(utf8_recode($message, 'ISO-8859-1'));
1888}
1889
1890/**
1891* UTF8-compatible wordwrap replacement
1892*
1893* @param	string	$string	The input string
1894* @param	int		$width	The column width. Defaults to 75.
1895* @param	string	$break	The line is broken using the optional break parameter. Defaults to '\n'.
1896* @param	bool	$cut	If the cut is set to TRUE, the string is always wrapped at the specified width. So if you have a word that is larger than the given width, it is broken apart.
1897*
1898* @return	string			the given string wrapped at the specified column.
1899*
1900*/
1901function utf8_wordwrap($string, $width = 75, $break = "\n", $cut = false)
1902{
1903	// We first need to explode on $break, not destroying existing (intended) breaks
1904	$lines = explode($break, $string);
1905	$new_lines = array(0 => '');
1906	$index = 0;
1907
1908	foreach ($lines as $line)
1909	{
1910		$words = explode(' ', $line);
1911
1912		for ($i = 0, $size = sizeof($words); $i < $size; $i++)
1913		{
1914			$word = $words[$i];
1915
1916			// If cut is true we need to cut the word if it is > width chars
1917			if ($cut && utf8_strlen($word) > $width)
1918			{
1919				$words[$i] = utf8_substr($word, $width);
1920				$word = utf8_substr($word, 0, $width);
1921				$i--;
1922			}
1923
1924			if (utf8_strlen($new_lines[$index] . $word) > $width)
1925			{
1926				$new_lines[$index] = substr($new_lines[$index], 0, -1);
1927				$index++;
1928				$new_lines[$index] = '';
1929			}
1930
1931			$new_lines[$index] .= $word . ' ';
1932		}
1933
1934		$new_lines[$index] = substr($new_lines[$index], 0, -1);
1935		$index++;
1936		$new_lines[$index] = '';
1937	}
1938
1939	unset($new_lines[$index]);
1940	return implode($break, $new_lines);
1941}
1942
1943/**
1944* UTF8-safe basename() function
1945*
1946* basename() has some limitations and is dependent on the locale setting
1947* according to the PHP manual. Therefore we provide our own locale independant
1948* basename function.
1949*
1950* @param string $filename The filename basename() should be applied to
1951* @return string The basenamed filename
1952*/
1953function utf8_basename($filename)
1954{
1955	// We always check for forward slash AND backward slash
1956	// because they could be mixed or "sneaked" in. ;)
1957	// You know, never trust user input...
1958	if (strpos($filename, '/') !== false)
1959	{
1960		$filename = utf8_substr($filename, utf8_strrpos($filename, '/') + 1);
1961	}
1962
1963	if (strpos($filename, '\\') !== false)
1964	{
1965		$filename = utf8_substr($filename, utf8_strrpos($filename, '\\') + 1);
1966	}
1967
1968	return $filename;
1969}
1970
1971/**
1972* UTF8-safe str_replace() function
1973*
1974* @param string $search The value to search for
1975* @param string $replace The replacement string
1976* @param string $subject The target string
1977* @return string The resultant string
1978*/
1979function utf8_str_replace($search, $replace, $subject)
1980{
1981	if (!is_array($search))
1982	{
1983		$search = array($search);
1984		if (is_array($replace))
1985		{
1986			$replace = (string) $replace;
1987			trigger_error('Array to string conversion', E_USER_NOTICE);
1988		}
1989	}
1990
1991	$length = sizeof($search);
1992
1993	if (!is_array($replace))
1994	{
1995		$replace = array_fill(0, $length, $replace);
1996	}
1997	else
1998	{
1999		$replace = array_pad($replace, $length, '');
2000	}
2001
2002	for ($i = 0; $i < $length; $i++)
2003	{
2004		$search_length = utf8_strlen($search[$i]);
2005		$replace_length = utf8_strlen($replace[$i]);
2006
2007		$offset = 0;
2008		while (($start = utf8_strpos($subject, $search[$i], $offset)) !== false)
2009		{
2010			$subject = utf8_substr($subject, 0, $start) . $replace[$i] . utf8_substr($subject, $start + $search_length);
2011			$offset = $start + $replace_length;
2012		}
2013	}
2014
2015	return $subject;
2016}
2017
2018?>