[ Index ]

PHP Cross Reference of WordPress Trunk (Updated Daily)

title

Body

[close]

/wp-includes/random_compat/ -> byte_safe_strings.php (source)

   1  <?php
   2  /**
   3   * Random_* Compatibility Library
   4   * for using the new PHP 7 random_* API in PHP 5 projects
   5   *
   6   * The MIT License (MIT)
   7   *
   8   * Copyright (c) 2015 - 2017 Paragon Initiative Enterprises
   9   *
  10   * Permission is hereby granted, free of charge, to any person obtaining a copy
  11   * of this software and associated documentation files (the "Software"), to deal
  12   * in the Software without restriction, including without limitation the rights
  13   * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  14   * copies of the Software, and to permit persons to whom the Software is
  15   * furnished to do so, subject to the following conditions:
  16   *
  17   * The above copyright notice and this permission notice shall be included in
  18   * all copies or substantial portions of the Software.
  19   *
  20   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  21   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  22   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  23   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  24   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  25   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  26   * SOFTWARE.
  27   */
  28  
  29  if (!is_callable('RandomCompat_strlen')) {
  30      if (
  31          defined('MB_OVERLOAD_STRING') &&
  32          ini_get('mbstring.func_overload') & MB_OVERLOAD_STRING
  33      ) {
  34          /**
  35           * strlen() implementation that isn't brittle to mbstring.func_overload
  36           *
  37           * This version uses mb_strlen() in '8bit' mode to treat strings as raw
  38           * binary rather than UTF-8, ISO-8859-1, etc
  39           *
  40           * @param string $binary_string
  41           *
  42           * @throws TypeError
  43           *
  44           * @return int
  45           */
  46          function RandomCompat_strlen($binary_string)
  47          {
  48              if (!is_string($binary_string)) {
  49                  throw new TypeError(
  50                      'RandomCompat_strlen() expects a string'
  51                  );
  52              }
  53  
  54              return (int) mb_strlen($binary_string, '8bit');
  55          }
  56  
  57      } else {
  58          /**
  59           * strlen() implementation that isn't brittle to mbstring.func_overload
  60           *
  61           * This version just used the default strlen()
  62           *
  63           * @param string $binary_string
  64           *
  65           * @throws TypeError
  66           *
  67           * @return int
  68           */
  69          function RandomCompat_strlen($binary_string)
  70          {
  71              if (!is_string($binary_string)) {
  72                  throw new TypeError(
  73                      'RandomCompat_strlen() expects a string'
  74                  );
  75              }
  76              return (int) strlen($binary_string);
  77          }
  78      }
  79  }
  80  
  81  if (!is_callable('RandomCompat_substr')) {
  82  
  83      if (
  84          defined('MB_OVERLOAD_STRING')
  85          &&
  86          ini_get('mbstring.func_overload') & MB_OVERLOAD_STRING
  87      ) {
  88          /**
  89           * substr() implementation that isn't brittle to mbstring.func_overload
  90           *
  91           * This version uses mb_substr() in '8bit' mode to treat strings as raw
  92           * binary rather than UTF-8, ISO-8859-1, etc
  93           *
  94           * @param string $binary_string
  95           * @param int $start
  96           * @param int $length (optional)
  97           *
  98           * @throws TypeError
  99           *
 100           * @return string
 101           */
 102          function RandomCompat_substr($binary_string, $start, $length = null)
 103          {
 104              if (!is_string($binary_string)) {
 105                  throw new TypeError(
 106                      'RandomCompat_substr(): First argument should be a string'
 107                  );
 108              }
 109  
 110              if (!is_int($start)) {
 111                  throw new TypeError(
 112                      'RandomCompat_substr(): Second argument should be an integer'
 113                  );
 114              }
 115  
 116              if ($length === null) {
 117                  /**
 118                   * mb_substr($str, 0, NULL, '8bit') returns an empty string on
 119                   * PHP 5.3, so we have to find the length ourselves.
 120                   */
 121                  $length = RandomCompat_strlen($binary_string) - $start;
 122              } elseif (!is_int($length)) {
 123                  throw new TypeError(
 124                      'RandomCompat_substr(): Third argument should be an integer, or omitted'
 125                  );
 126              }
 127  
 128              // Consistency with PHP's behavior
 129              if ($start === RandomCompat_strlen($binary_string) && $length === 0) {
 130                  return '';
 131              }
 132              if ($start > RandomCompat_strlen($binary_string)) {
 133                  return '';
 134              }
 135  
 136              return (string) mb_substr($binary_string, $start, $length, '8bit');
 137          }
 138  
 139      } else {
 140  
 141          /**
 142           * substr() implementation that isn't brittle to mbstring.func_overload
 143           *
 144           * This version just uses the default substr()
 145           *
 146           * @param string $binary_string
 147           * @param int $start
 148           * @param int $length (optional)
 149           *
 150           * @throws TypeError
 151           *
 152           * @return string
 153           */
 154          function RandomCompat_substr($binary_string, $start, $length = null)
 155          {
 156              if (!is_string($binary_string)) {
 157                  throw new TypeError(
 158                      'RandomCompat_substr(): First argument should be a string'
 159                  );
 160              }
 161  
 162              if (!is_int($start)) {
 163                  throw new TypeError(
 164                      'RandomCompat_substr(): Second argument should be an integer'
 165                  );
 166              }
 167  
 168              if ($length !== null) {
 169                  if (!is_int($length)) {
 170                      throw new TypeError(
 171                          'RandomCompat_substr(): Third argument should be an integer, or omitted'
 172                      );
 173                  }
 174  
 175                  return (string) substr($binary_string, $start, $length);
 176              }
 177  
 178              return (string) substr($binary_string, $start);
 179          }
 180      }
 181  }


Generated: Sat Nov 23 20:47:33 2019 Cross-referenced by PHPXref 0.7