[ Index ]

PHP Cross Reference of phpBB-3.1.12-deutsch

title

Body

[close]

/vendor/symfony/polyfill-mbstring/ -> Mbstring.php (source)

   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  }


Generated: Thu Jan 11 00:25:41 2018 Cross-referenced by PHPXref 0.7.1