www.aleph1.co.uk Git - yaffs-website/blob - vendor/symfony/polyfill-mbstring/Mbstring.php

   1 <?php
   2
   3 /*
   4  * This file is part of the Symfony package.
   5  *
   6  * (c) Fabien Potencier <fabien@symfony.com>
   7  *
   8  * For the full copyright and license information, please view the LICENSE
   9  * file that was distributed with this source code.
  10  */
  11
  12 namespace Symfony\Polyfill\Mbstring;
  13
  14 /**
  15  * Partial mbstring implementation in PHP, iconv based, UTF-8 centric.
  16  *
  17  * Implemented:
  18  * - mb_chr                  - Returns a specific character from its Unicode code point
  19  * - mb_convert_encoding     - Convert character encoding
  20  * - mb_convert_variables    - Convert character code in variable(s)
  21  * - mb_decode_mimeheader    - Decode string in MIME header field
  22  * - mb_encode_mimeheader    - Encode string for MIME header XXX NATIVE IMPLEMENTATION IS REALLY BUGGED
  23  * - mb_convert_case         - Perform case folding on a string
  24  * - mb_get_info             - Get internal settings of mbstring
  25  * - mb_http_input           - Detect HTTP input character encoding
  26  * - mb_http_output          - Set/Get HTTP output character encoding
  27  * - mb_internal_encoding    - Set/Get internal character encoding
  28  * - mb_list_encodings       - Returns an array of all supported encodings
  29  * - mb_ord                  - Returns the Unicode code point of a character
  30  * - mb_output_handler       - Callback function converts character encoding in output buffer
  31  * - mb_scrub                - Replaces ill-formed byte sequences with substitute characters
  32  * - mb_strlen               - Get string length
  33  * - mb_strpos               - Find position of first occurrence of string in a string
  34  * - mb_strrpos              - Find position of last occurrence of a string in a string
  35  * - mb_strtolower           - Make a string lowercase
  36  * - mb_strtoupper           - Make a string uppercase
  37  * - mb_substitute_character - Set/Get substitution character
  38  * - mb_substr               - Get part of string
  39  * - mb_stripos              - Finds position of first occurrence of a string within another, case insensitive
  40  * - mb_stristr              - Finds first occurrence of a string within another, case insensitive
  41  * - mb_strrchr              - Finds the last occurrence of a character in a string within another
  42  * - mb_strrichr             - Finds the last occurrence of a character in a string within another, case insensitive
  43  * - mb_strripos             - Finds position of last occurrence of a string within another, case insensitive
  44  * - mb_strstr               - Finds first occurrence of a string within anothers
  45  * - mb_strwidth             - Return width of string
  46  * - mb_substr_count         - Count the number of substring occurrences
  47  *
  48  * Not implemented:
  49  * - mb_convert_kana         - Convert "kana" one from another ("zen-kaku", "han-kaku" and more)
  50  * - mb_decode_numericentity - Decode HTML numeric string reference to character
  51  * - mb_encode_numericentity - Encode character to HTML numeric string reference
  52  * - mb_ereg_*               - Regular expression with multibyte support
  53  * - mb_parse_str            - Parse GET/POST/COOKIE data and set global variable
  54  * - mb_preferred_mime_name  - Get MIME charset string
  55  * - mb_regex_encoding       - Returns current encoding for multibyte regex as string
  56  * - mb_regex_set_options    - Set/Get the default options for mbregex functions
  57  * - mb_send_mail            - Send encoded mail
  58  * - mb_split                - Split multibyte string using regular expression
  59  * - mb_strcut               - Get part of string
  60  * - mb_strimwidth           - Get truncated string with specified width
  61  *
  62  * @author Nicolas Grekas <p@tchwork.com>
  63  *
  64  * @internal
  65  */
  66 final class Mbstring
  67 {
  68     const MB_CASE_FOLD = PHP_INT_MAX;
  69
  70     private static $encodingList = array('ASCII', 'UTF-8');
  71     private static $language = 'neutral';
  72     private static $internalEncoding = 'UTF-8';
  73     private static $caseFold = array(
  74         array('µ','ſ',"\xCD\x85",'ς',"\xCF\x90","\xCF\x91","\xCF\x95","\xCF\x96","\xCF\xB0","\xCF\xB1","\xCF\xB5","\xE1\xBA\x9B","\xE1\xBE\xBE"),
  75         array('μ','s','ι',       'σ','β',       'θ',       'φ',       'π',       'κ',       'ρ',       'ε',       "\xE1\xB9\xA1",'ι'),
  76     );
  77
  78     public static function mb_convert_encoding($s, $toEncoding, $fromEncoding = null)
  79     {
  80         if (is_array($fromEncoding) || false !== strpos($fromEncoding, ',')) {
  81             $fromEncoding = self::mb_detect_encoding($s, $fromEncoding);
  82         } else {
  83             $fromEncoding = self::getEncoding($fromEncoding);
  84         }
  85
  86         $toEncoding = self::getEncoding($toEncoding);
  87
  88         if ('BASE64' === $fromEncoding) {
  89             $s = base64_decode($s);
  90             $fromEncoding = $toEncoding;
  91         }
  92
  93         if ('BASE64' === $toEncoding) {
  94             return base64_encode($s);
  95         }
  96
  97         if ('HTML-ENTITIES' === $toEncoding || 'HTML' === $toEncoding) {
  98             if ('HTML-ENTITIES' === $fromEncoding || 'HTML' === $fromEncoding) {
  99                 $fromEncoding = 'Windows-1252';
 100             }
 101             if ('UTF-8' !== $fromEncoding) {
 102                 $s = iconv($fromEncoding, 'UTF-8//IGNORE', $s);
 103             }
 104
 105             return preg_replace_callback('/[\x80-\xFF]+/', array(__CLASS__, 'html_encoding_callback'), $s);
 106         }
 107
 108         if ('HTML-ENTITIES' === $fromEncoding) {
 109             $s = html_entity_decode($s, ENT_COMPAT, 'UTF-8');
 110             $fromEncoding = 'UTF-8';
 111         }
 112
 113         return iconv($fromEncoding, $toEncoding.'//IGNORE', $s);
 114     }
 115
 116     public static function mb_convert_variables($toEncoding, $fromEncoding, &$a = null, &$b = null, &$c = null, &$d = null, &$e = null, &$f = null)
 117     {
 118         $vars = array(&$a, &$b, &$c, &$d, &$e, &$f);
 119
 120         $ok = true;
 121         array_walk_recursive($vars, function (&$v) use (&$ok, $toEncoding, $fromEncoding) {
 122             if (false === $v = Mbstring::mb_convert_encoding($v, $toEncoding, $fromEncoding)) {
 123                 $ok = false;
 124             }
 125         });
 126
 127         return $ok ? $fromEncoding : false;
 128     }
 129
 130     public static function mb_decode_mimeheader($s)
 131     {
 132         return iconv_mime_decode($s, 2, self::$internalEncoding);
 133     }
 134
 135     public static function mb_encode_mimeheader($s, $charset = null, $transferEncoding = null, $linefeed = null, $indent = null)
 136     {
 137         trigger_error('mb_encode_mimeheader() is bugged. Please use iconv_mime_encode() instead', E_USER_WARNING);
 138     }
 139
 140     public static function mb_convert_case($s, $mode, $encoding = null)
 141     {
 142         if ('' === $s .= '') {
 143             return '';
 144         }
 145
 146         $encoding = self::getEncoding($encoding);
 147
 148         if ('UTF-8' === $encoding) {
 149             $encoding = null;
 150         } else {
 151             $s = iconv($encoding, 'UTF-8//IGNORE', $s);
 152         }
 153
 154         if (MB_CASE_TITLE == $mode) {
 155             $s = preg_replace_callback('/\b\p{Ll}/u', array(__CLASS__, 'title_case_upper'), $s);
 156             $s = preg_replace_callback('/\B[\p{Lu}\p{Lt}]+/u', array(__CLASS__, 'title_case_lower'), $s);
 157         } else {
 158             if (MB_CASE_UPPER == $mode) {
 159                 static $upper = null;
 160                 if (null === $upper) {
 161                     $upper = self::getData('upperCase');
 162                 }
 163                 $map = $upper;
 164             } else {
 165                 if (self::MB_CASE_FOLD === $mode) {
 166                     $s = str_replace(self::$caseFold[0], self::$caseFold[1], $s);
 167                 }
 168
 169                 static $lower = null;
 170                 if (null === $lower) {
 171                     $lower = self::getData('lowerCase');
 172                 }
 173                 $map = $lower;
 174             }
 175
 176             static $ulenMask = array("\xC0" => 2, "\xD0" => 2, "\xE0" => 3, "\xF0" => 4);
 177
 178             $i = 0;
 179             $len = strlen($s);
 180
 181             while ($i < $len) {
 182                 $ulen = $s[$i] < "\x80" ? 1 : $ulenMask[$s[$i] & "\xF0"];
 183                 $uchr = substr($s, $i, $ulen);
 184                 $i += $ulen;
 185
 186                 if (isset($map[$uchr])) {
 187                     $uchr = $map[$uchr];
 188                     $nlen = strlen($uchr);
 189
 190                     if ($nlen == $ulen) {
 191                         $nlen = $i;
 192                         do {
 193                             $s[--$nlen] = $uchr[--$ulen];
 194                         } while ($ulen);
 195                     } else {
 196                         $s = substr_replace($s, $uchr, $i - $ulen, $ulen);
 197                         $len += $nlen - $ulen;
 198                         $i   += $nlen - $ulen;
 199                     }
 200                 }
 201             }
 202         }
 203
 204         if (null === $encoding) {
 205             return $s;
 206         }
 207
 208         return iconv('UTF-8', $encoding.'//IGNORE', $s);
 209     }
 210
 211     public static function mb_internal_encoding($encoding = null)
 212     {
 213         if (null === $encoding) {
 214             return self::$internalEncoding;
 215         }
 216
 217         $encoding = self::getEncoding($encoding);
 218
 219         if ('UTF-8' === $encoding || false !== @iconv($encoding, $encoding, ' ')) {
 220             self::$internalEncoding = $encoding;
 221
 222             return true;
 223         }
 224
 225         return false;
 226     }
 227
 228     public static function mb_language($lang = null)
 229     {
 230         if (null === $lang) {
 231             return self::$language;
 232         }
 233
 234         switch ($lang = strtolower($lang)) {
 235             case 'uni':
 236             case 'neutral':
 237                 self::$language = $lang;
 238
 239                 return true;
 240         }
 241
 242         return false;
 243     }
 244
 245     public static function mb_list_encodings()
 246     {
 247         return array('UTF-8');
 248     }
 249
 250     public static function mb_encoding_aliases($encoding)
 251     {
 252         switch (strtoupper($encoding)) {
 253             case 'UTF8':
 254             case 'UTF-8':
 255                 return array('utf8');
 256         }
 257
 258         return false;
 259     }
 260
 261     public static function mb_check_encoding($var = null, $encoding = null)
 262     {
 263         if (null === $encoding) {
 264             if (null === $var) {
 265                 return false;
 266             }
 267             $encoding = self::$internalEncoding;
 268         }
 269
 270         return self::mb_detect_encoding($var, array($encoding)) || false !== @iconv($encoding, $encoding, $var);
 271     }
 272
 273     public static function mb_detect_encoding($str, $encodingList = null, $strict = false)
 274     {
 275         if (null === $encodingList) {
 276             $encodingList = self::$encodingList;
 277         } else {
 278             if (!is_array($encodingList)) {
 279                 $encodingList = array_map('trim', explode(',', $encodingList));
 280             }
 281             $encodingList = array_map('strtoupper', $encodingList);
 282         }
 283
 284         foreach ($encodingList as $enc) {
 285             switch ($enc) {
 286                 case 'ASCII':
 287                     if (!preg_match('/[\x80-\xFF]/', $str)) {
 288                         return $enc;
 289                     }
 290                     break;
 291
 292                 case 'UTF8':
 293                 case 'UTF-8':
 294                     if (preg_match('//u', $str)) {
 295                         return 'UTF-8';
 296                     }
 297                     break;
 298
 299                 default:
 300                     if (0 === strncmp($enc, 'ISO-8859-', 9)) {
 301                         return $enc;
 302                     }
 303             }
 304         }
 305
 306         return false;
 307     }
 308
 309     public static function mb_detect_order($encodingList = null)
 310     {
 311         if (null === $encodingList) {
 312             return self::$encodingList;
 313         }
 314
 315         if (!is_array($encodingList)) {
 316             $encodingList = array_map('trim', explode(',', $encodingList));
 317         }
 318         $encodingList = array_map('strtoupper', $encodingList);
 319
 320         foreach ($encodingList as $enc) {
 321             switch ($enc) {
 322                 default:
 323                     if (strncmp($enc, 'ISO-8859-', 9)) {
 324                         return false;
 325                     }
 326                 case 'ASCII':
 327                 case 'UTF8':
 328                 case 'UTF-8':
 329             }
 330         }
 331
 332         self::$encodingList = $encodingList;
 333
 334         return true;
 335     }
 336
 337     public static function mb_strlen($s, $encoding = null)
 338     {
 339         switch ($encoding = self::getEncoding($encoding)) {
 340             case 'ASCII':
 341             case 'CP850':
 342                 return strlen($s);
 343         }
 344
 345         return @iconv_strlen($s, $encoding);
 346     }
 347
 348     public static function mb_strpos($haystack, $needle, $offset = 0, $encoding = null)
 349     {
 350         $encoding = self::getEncoding($encoding);
 351
 352         if ('' === $needle .= '') {
 353             trigger_error(__METHOD__.': Empty delimiter', E_USER_WARNING);
 354
 355             return false;
 356         }
 357
 358         return iconv_strpos($haystack, $needle, $offset, $encoding);
 359     }
 360
 361     public static function mb_strrpos($haystack, $needle, $offset = 0, $encoding = null)
 362     {
 363         $encoding = self::getEncoding($encoding);
 364
 365         if ($offset != (int) $offset) {
 366             $offset = 0;
 367         } elseif ($offset = (int) $offset) {
 368             if ($offset < 0) {
 369                 $haystack = self::mb_substr($haystack, 0, $offset, $encoding);
 370                 $offset = 0;
 371             } else {
 372                 $haystack = self::mb_substr($haystack, $offset, 2147483647, $encoding);
 373             }
 374         }
 375
 376         $pos = iconv_strrpos($haystack, $needle, $encoding);
 377
 378         return false !== $pos ? $offset + $pos : false;
 379     }
 380
 381     public static function mb_strtolower($s, $encoding = null)
 382     {
 383         return self::mb_convert_case($s, MB_CASE_LOWER, $encoding);
 384     }
 385
 386     public static function mb_strtoupper($s, $encoding = null)
 387     {
 388         return self::mb_convert_case($s, MB_CASE_UPPER, $encoding);
 389     }
 390
 391     public static function mb_substitute_character($c = null)
 392     {
 393         if (0 === strcasecmp($c, 'none')) {
 394             return true;
 395         }
 396
 397         return null !== $c ? false : 'none';
 398     }
 399
 400     public static function mb_substr($s, $start, $length = null, $encoding = null)
 401     {
 402         $encoding = self::getEncoding($encoding);
 403
 404         if ($start < 0) {
 405             $start = iconv_strlen($s, $encoding) + $start;
 406             if ($start < 0) {
 407                 $start = 0;
 408             }
 409         }
 410
 411         if (null === $length) {
 412             $length = 2147483647;
 413         } elseif ($length < 0) {
 414             $length = iconv_strlen($s, $encoding) + $length - $start;
 415             if ($length < 0) {
 416                 return '';
 417             }
 418         }
 419
 420         return iconv_substr($s, $start, $length, $encoding).'';
 421     }
 422
 423     public static function mb_stripos($haystack, $needle, $offset = 0, $encoding = null)
 424     {
 425         $haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
 426         $needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
 427
 428         return self::mb_strpos($haystack, $needle, $offset, $encoding);
 429     }
 430
 431     public static function mb_stristr($haystack, $needle, $part = false, $encoding = null)
 432     {
 433         $pos = self::mb_stripos($haystack, $needle, 0, $encoding);
 434
 435         return self::getSubpart($pos, $part, $haystack, $encoding);
 436     }
 437
 438     public static function mb_strrchr($haystack, $needle, $part = false, $encoding = null)
 439     {
 440         $encoding = self::getEncoding($encoding);
 441         $needle = self::mb_substr($needle, 0, 1, $encoding);
 442         $pos = iconv_strrpos($haystack, $needle, $encoding);
 443
 444         return self::getSubpart($pos, $part, $haystack, $encoding);
 445     }
 446
 447     public static function mb_strrichr($haystack, $needle, $part = false, $encoding = null)
 448     {
 449         $needle = self::mb_substr($needle, 0, 1, $encoding);
 450         $pos = self::mb_strripos($haystack, $needle, $encoding);
 451
 452         return self::getSubpart($pos, $part, $haystack, $encoding);
 453     }
 454
 455     public static function mb_strripos($haystack, $needle, $offset = 0, $encoding = null)
 456     {
 457         $haystack = self::mb_convert_case($haystack, self::MB_CASE_FOLD, $encoding);
 458         $needle = self::mb_convert_case($needle, self::MB_CASE_FOLD, $encoding);
 459
 460         return self::mb_strrpos($haystack, $needle, $offset, $encoding);
 461     }
 462
 463     public static function mb_strstr($haystack, $needle, $part = false, $encoding = null)
 464     {
 465         $pos = strpos($haystack, $needle);
 466         if (false === $pos) {
 467             return false;
 468         }
 469         if ($part) {
 470             return substr($haystack, 0, $pos);
 471         }
 472
 473         return substr($haystack, $pos);
 474     }
 475
 476     public static function mb_get_info($type = 'all')
 477     {
 478         $info = array(
 479             'internal_encoding' => self::$internalEncoding,
 480             'http_output' => 'pass',
 481             'http_output_conv_mimetypes' => '^(text/|application/xhtml\+xml)',
 482             'func_overload' => 0,
 483             'func_overload_list' => 'no overload',
 484             'mail_charset' => 'UTF-8',
 485             'mail_header_encoding' => 'BASE64',
 486             'mail_body_encoding' => 'BASE64',
 487             'illegal_chars' => 0,
 488             'encoding_translation' => 'Off',
 489             'language' => self::$language,
 490             'detect_order' => self::$encodingList,
 491             'substitute_character' => 'none',
 492             'strict_detection' => 'Off',
 493         );
 494
 495         if ('all' === $type) {
 496             return $info;
 497         }
 498         if (isset($info[$type])) {
 499             return $info[$type];
 500         }
 501
 502         return false;
 503     }
 504
 505     public static function mb_http_input($type = '')
 506     {
 507         return false;
 508     }
 509
 510     public static function mb_http_output($encoding = null)
 511     {
 512         return null !== $encoding ? 'pass' === $encoding : 'pass';
 513     }
 514
 515     public static function mb_strwidth($s, $encoding = null)
 516     {
 517         $encoding = self::getEncoding($encoding);
 518
 519         if ('UTF-8' !== $encoding) {
 520             $s = iconv($encoding, 'UTF-8//IGNORE', $s);
 521         }
 522
 523         $s = preg_replace('/[\x{1100}-\x{115F}\x{2329}\x{232A}\x{2E80}-\x{303E}\x{3040}-\x{A4CF}\x{AC00}-\x{D7A3}\x{F900}-\x{FAFF}\x{FE10}-\x{FE19}\x{FE30}-\x{FE6F}\x{FF00}-\x{FF60}\x{FFE0}-\x{FFE6}\x{20000}-\x{2FFFD}\x{30000}-\x{3FFFD}]/u', '', $s, -1, $wide);
 524
 525         return ($wide << 1) + iconv_strlen($s, 'UTF-8');
 526     }
 527
 528     public static function mb_substr_count($haystack, $needle, $encoding = null)
 529     {
 530         return substr_count($haystack, $needle);
 531     }
 532
 533     public static function mb_output_handler($contents, $status)
 534     {
 535         return $contents;
 536     }
 537
 538     public static function mb_chr($code, $encoding = null)
 539     {
 540         if (0x80 > $code %= 0x200000) {
 541             $s = chr($code);
 542         } elseif (0x800 > $code) {
 543             $s = chr(0xC0 | $code >> 6).chr(0x80 | $code & 0x3F);
 544         } elseif (0x10000 > $code) {
 545             $s = chr(0xE0 | $code >> 12).chr(0x80 | $code >> 6 & 0x3F).chr(0x80 | $code & 0x3F);
 546         } else {
 547             $s = chr(0xF0 | $code >> 18).chr(0x80 | $code >> 12 & 0x3F).chr(0x80 | $code >> 6 & 0x3F).chr(0x80 | $code & 0x3F);
 548         }
 549
 550         if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
 551             $s = mb_convert_encoding($s, $encoding, 'UTF-8');
 552         }
 553
 554         return $s;
 555     }
 556
 557     public static function mb_ord($s, $encoding = null)
 558     {
 559         if ('UTF-8' !== $encoding = self::getEncoding($encoding)) {
 560             $s = mb_convert_encoding($s, 'UTF-8', $encoding);
 561         }
 562
 563         $code = ($s = unpack('C*', substr($s, 0, 4))) ? $s[1] : 0;
 564         if (0xF0 <= $code) {
 565             return (($code - 0xF0) << 18) + (($s[2] - 0x80) << 12) + (($s[3] - 0x80) << 6) + $s[4] - 0x80;
 566         }
 567         if (0xE0 <= $code) {
 568             return (($code - 0xE0) << 12) + (($s[2] - 0x80) << 6) + $s[3] - 0x80;
 569         }
 570         if (0xC0 <= $code) {
 571             return (($code - 0xC0) << 6) + $s[2] - 0x80;
 572         }
 573
 574         return $code;
 575     }
 576
 577     private static function getSubpart($pos, $part, $haystack, $encoding)
 578     {
 579         if (false === $pos) {
 580             return false;
 581         }
 582         if ($part) {
 583             return self::mb_substr($haystack, 0, $pos, $encoding);
 584         }
 585
 586         return self::mb_substr($haystack, $pos, null, $encoding);
 587     }
 588
 589     private static function html_encoding_callback($m)
 590     {
 591         $i = 1;
 592         $entities = '';
 593         $m = unpack('C*', htmlentities($m[0], ENT_COMPAT, 'UTF-8'));
 594
 595         while (isset($m[$i])) {
 596             if (0x80 > $m[$i]) {
 597                 $entities .= chr($m[$i++]);
 598                 continue;
 599             }
 600             if (0xF0 <= $m[$i]) {
 601                 $c = (($m[$i++] - 0xF0) << 18) + (($m[$i++] - 0x80) << 12) + (($m[$i++] - 0x80) << 6) + $m[$i++] - 0x80;
 602             } elseif (0xE0 <= $m[$i]) {
 603                 $c = (($m[$i++] - 0xE0) << 12) + (($m[$i++] - 0x80) << 6) + $m[$i++] - 0x80;
 604             } else {
 605                 $c = (($m[$i++] - 0xC0) << 6) + $m[$i++] - 0x80;
 606             }
 607
 608             $entities .= '&#'.$c.';';
 609         }
 610
 611         return $entities;
 612     }
 613
 614     private static function title_case_lower($s)
 615     {
 616         return self::mb_convert_case($s[0], MB_CASE_LOWER, 'UTF-8');
 617     }
 618
 619     private static function title_case_upper($s)
 620     {
 621         return self::mb_convert_case($s[0], MB_CASE_UPPER, 'UTF-8');
 622     }
 623
 624     private static function getData($file)
 625     {
 626         if (file_exists($file = __DIR__.'/Resources/unidata/'.$file.'.php')) {
 627             return require $file;
 628         }
 629
 630         return false;
 631     }
 632
 633     private static function getEncoding($encoding)
 634     {
 635         if (null === $encoding) {
 636             return self::$internalEncoding;
 637         }
 638
 639         $encoding = strtoupper($encoding);
 640
 641         if ('8BIT' === $encoding || 'BINARY' === $encoding) {
 642             return 'CP850';
 643         }
 644         if ('UTF8' === $encoding) {
 645             return 'UTF-8';
 646         }
 647
 648         return $encoding;
 649     }
 650 }