WordPress.org

Make WordPress Core

Ticket #21568: 21568.patch

File 21568.patch, 59.7 KB (added by bpetty, 6 years ago)
  • wp-includes/class-json.php

    diff --git wp-includes/class-json.php wp-includes/class-json.php
    index 58f6f7d..1e8588d 100644
     
    11<?php
    2 if ( !class_exists( 'Services_JSON' ) ) :
     2if ( ! class_exists( 'Services_JSON' ) ) :
    33/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
    44/**
    55 * Converts to and from JSON format.
    if ( !class_exists( 'Services_JSON' ) ) : 
    4646 * DAMAGE.
    4747 *
    4848 * @category
    49  * @package             Services_JSON
    50  * @author              Michal Migurski <mike-json@teczno.com>
    51  * @author              Matt Knapp <mdknapp[at]gmail[dot]com>
    52  * @author              Brett Stimmerman <brettstimmerman[at]gmail[dot]com>
    53  * @copyright   2005 Michal Migurski
    54  * @version     CVS: $Id: JSON.php 288200 2009-09-09 15:41:29Z alan_k $
    55  * @license             http://www.opensource.org/licenses/bsd-license.php
    56  * @link                http://pear.php.net/pepr/pepr-proposal-show.php?id=198
     49 * @package     Services_JSON
     50 * @author      Michal Migurski <mike-json@teczno.com>
     51 * @author      Matt Knapp <mdknapp[at]gmail[dot]com>
     52 * @author      Brett Stimmerman <brettstimmerman[at]gmail[dot]com>
     53 * @copyright   2005 Michal Migurski
     54 * @version     CVS: $Id: JSON.php 305040 2010-11-02 23:19:03Z alan_k $
     55 * @license     http://www.opensource.org/licenses/bsd-license.php
     56 * @link        http://pear.php.net/pepr/pepr-proposal-show.php?id=198
    5757 */
    5858
    5959/**
    6060 * Marker constant for Services_JSON::decode(), used to flag stack state
    6161 */
    62 define('SERVICES_JSON_SLICE', 1);
     62define('SERVICES_JSON_SLICE',   1);
    6363
    6464/**
    6565 * Marker constant for Services_JSON::decode(), used to flag stack state
    define('SERVICES_JSON_LOOSE_TYPE', 16); 
    9292define('SERVICES_JSON_SUPPRESS_ERRORS', 32);
    9393
    9494/**
     95 * Behavior switch for Services_JSON::decode()
     96 */
     97define('SERVICES_JSON_USE_TO_JSON', 64);
     98
     99/**
    95100 * Converts to and from JSON format.
    96101 *
    97102 * Brief example of use:
    define('SERVICES_JSON_SUPPRESS_ERRORS', 32); 
    114119 */
    115120class Services_JSON
    116121{
    117  /**
    118         * constructs a new JSON instance
    119         *
    120         * @param int $use object behavior flags; combine with boolean-OR
    121         *
    122         *                                               possible values:
    123         *                                               - SERVICES_JSON_LOOSE_TYPE:  loose typing.
    124         *                                                               "{...}" syntax creates associative arrays
    125         *                                                               instead of objects in decode().
    126         *                                               - SERVICES_JSON_SUPPRESS_ERRORS:  error suppression.
    127         *                                                               Values which can't be encoded (e.g. resources)
    128         *                                                               appear as NULL instead of throwing errors.
    129         *                                                               By default, a deeply-nested resource will
    130         *                                                               bubble up with an error, so all return values
    131         *                                                               from encode() should be checked with isError()
    132         */
    133         function Services_JSON($use = 0)
    134         {
    135                 $this->use = $use;
    136         }
    137 
    138  /**
    139         * convert a string from one UTF-16 char to one UTF-8 char
    140         *
    141         * Normally should be handled by mb_convert_encoding, but
    142         * provides a slower PHP-only method for installations
    143         * that lack the multibye string extension.
    144         *
    145         * @param        string  $utf16  UTF-16 character
    146         * @return string  UTF-8 character
    147         * @access private
    148         */
    149         function utf162utf8($utf16)
    150         {
    151                 // oh please oh please oh please oh please oh please
    152                 if(function_exists('mb_convert_encoding')) {
    153                         return mb_convert_encoding($utf16, 'UTF-8', 'UTF-16');
    154                 }
    155 
    156                 $bytes = (ord($utf16[0]) << 8) | ord($utf16[1]);
    157 
    158                 switch(true) {
    159                         case ((0x7F & $bytes) == $bytes):
    160                                 // this case should never be reached, because we are in ASCII range
    161                                 // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    162                                 return chr(0x7F & $bytes);
    163 
    164                         case (0x07FF & $bytes) == $bytes:
    165                                 // return a 2-byte UTF-8 character
    166                                 // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    167                                 return chr(0xC0 | (($bytes >> 6) & 0x1F))
    168                                         . chr(0x80 | ($bytes & 0x3F));
    169 
    170                         case (0xFFFF & $bytes) == $bytes:
    171                                 // return a 3-byte UTF-8 character
    172                                 // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    173                                 return chr(0xE0 | (($bytes >> 12) & 0x0F))
    174                                         . chr(0x80 | (($bytes >> 6) & 0x3F))
    175                                         . chr(0x80 | ($bytes & 0x3F));
    176                 }
    177 
    178                 // ignoring UTF-32 for now, sorry
    179                 return '';
    180         }
    181 
    182  /**
    183         * convert a string from one UTF-8 char to one UTF-16 char
    184         *
    185         * Normally should be handled by mb_convert_encoding, but
    186         * provides a slower PHP-only method for installations
    187         * that lack the multibye string extension.
    188         *
    189         * @param        string  $utf8 UTF-8 character
    190         * @return string  UTF-16 character
    191         * @access private
    192         */
    193         function utf82utf16($utf8)
    194         {
    195                 // oh please oh please oh please oh please oh please
    196                 if(function_exists('mb_convert_encoding')) {
    197                         return mb_convert_encoding($utf8, 'UTF-16', 'UTF-8');
    198                 }
    199 
    200                 switch(strlen($utf8)) {
    201                         case 1:
    202                                 // this case should never be reached, because we are in ASCII range
    203                                 // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    204                                 return $utf8;
    205 
    206                         case 2:
    207                                 // return a UTF-16 character from a 2-byte UTF-8 char
    208                                 // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    209                                 return chr(0x07 & (ord($utf8[0]) >> 2))
    210                                         . chr((0xC0 & (ord($utf8[0]) << 6))
    211                                                 | (0x3F & ord($utf8[1])));
    212 
    213                         case 3:
    214                                 // return a UTF-16 character from a 3-byte UTF-8 char
    215                                 // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    216                                 return chr((0xF0 & (ord($utf8[0]) << 4))
    217                                                 | (0x0F & (ord($utf8[1]) >> 2)))
    218                                         . chr((0xC0 & (ord($utf8[1]) << 6))
    219                                                 | (0x7F & ord($utf8[2])));
    220                 }
    221 
    222                 // ignoring UTF-32 for now, sorry
    223                 return '';
    224         }
    225 
    226  /**
    227         * encodes an arbitrary variable into JSON format (and sends JSON Header)
    228         *
    229         * @param        mixed $var      any number, boolean, string, array, or object to be encoded.
    230         *                                               see argument 1 to Services_JSON() above for array-parsing behavior.
    231         *                                               if var is a strng, note that encode() always expects it
    232         *                                               to be in ASCII or UTF-8 format!
    233         *
    234         * @return mixed JSON string representation of input var or an error if a problem occurs
    235         * @access public
    236         */
    237         function encode($var)
    238         {
    239                 header('Content-type: application/json');
    240                 return $this->_encode($var);
    241         }
    242         /**
    243         * encodes an arbitrary variable into JSON format without JSON Header - warning - may allow CSS!!!!)
    244         *
    245         * @param        mixed $var      any number, boolean, string, array, or object to be encoded.
    246         *                                               see argument 1 to Services_JSON() above for array-parsing behavior.
    247         *                                               if var is a strng, note that encode() always expects it
    248         *                                               to be in ASCII or UTF-8 format!
    249         *
    250         * @return mixed JSON string representation of input var or an error if a problem occurs
    251         * @access public
    252         */
    253         function encodeUnsafe($var)
    254         {
    255                 return $this->_encode($var);
    256         }
    257         /**
    258         * PRIVATE CODE that does the work of encodes an arbitrary variable into JSON format
    259         *
    260         * @param        mixed $var      any number, boolean, string, array, or object to be encoded.
    261         *                                               see argument 1 to Services_JSON() above for array-parsing behavior.
    262         *                                               if var is a strng, note that encode() always expects it
    263         *                                               to be in ASCII or UTF-8 format!
    264         *
    265         * @return mixed JSON string representation of input var or an error if a problem occurs
    266         * @access public
    267         */
    268         function _encode($var)
    269         {
    270 
    271                 switch (gettype($var)) {
    272                         case 'boolean':
    273                                 return $var ? 'true' : 'false';
    274 
    275                         case 'NULL':
    276                                 return 'null';
    277 
    278                         case 'integer':
    279                                 return (int) $var;
    280 
    281                         case 'double':
    282                         case 'float':
    283                                 return (float) $var;
    284 
    285                         case 'string':
    286                                 // STRINGS ARE EXPECTED TO BE IN ASCII OR UTF-8 FORMAT
    287                                 $ascii = '';
    288                                 $strlen_var = strlen($var);
    289 
    290                         /*
    291                                 * Iterate over every character in the string,
    292                                 * escaping with a slash or encoding to UTF-8 where necessary
    293                                 */
    294                                 for ($c = 0; $c < $strlen_var; ++$c) {
    295 
    296                                         $ord_var_c = ord($var[$c]);
    297 
    298                                         switch (true) {
    299                                                 case $ord_var_c == 0x08:
    300                                                         $ascii .= '\b';
    301                                                         break;
    302                                                 case $ord_var_c == 0x09:
    303                                                         $ascii .= '\t';
    304                                                         break;
    305                                                 case $ord_var_c == 0x0A:
    306                                                         $ascii .= '\n';
    307                                                         break;
    308                                                 case $ord_var_c == 0x0C:
    309                                                         $ascii .= '\f';
    310                                                         break;
    311                                                 case $ord_var_c == 0x0D:
    312                                                         $ascii .= '\r';
    313                                                         break;
    314 
    315                                                 case $ord_var_c == 0x22:
    316                                                 case $ord_var_c == 0x2F:
    317                                                 case $ord_var_c == 0x5C:
    318                                                         // double quote, slash, slosh
    319                                                         $ascii .= '\\'.$var[$c];
    320                                                         break;
    321 
    322                                                 case (($ord_var_c >= 0x20) && ($ord_var_c <= 0x7F)):
    323                                                         // characters U-00000000 - U-0000007F (same as ASCII)
    324                                                         $ascii .= $var[$c];
    325                                                         break;
    326 
    327                                                 case (($ord_var_c & 0xE0) == 0xC0):
    328                                                         // characters U-00000080 - U-000007FF, mask 110XXXXX
    329                                                         // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    330                                                         if ($c+1 >= $strlen_var) {
    331                                                                 $c += 1;
    332                                                                 $ascii .= '?';
    333                                                                 break;
    334                                                         }
    335 
    336                                                         $char = pack('C*', $ord_var_c, ord($var[$c + 1]));
    337                                                         $c += 1;
    338                                                         $utf16 = $this->utf82utf16($char);
    339                                                         $ascii .= sprintf('\u%04s', bin2hex($utf16));
    340                                                         break;
    341 
    342                                                 case (($ord_var_c & 0xF0) == 0xE0):
    343                                                         if ($c+2 >= $strlen_var) {
    344                                                                 $c += 2;
    345                                                                 $ascii .= '?';
    346                                                                 break;
    347                                                         }
    348                                                         // characters U-00000800 - U-0000FFFF, mask 1110XXXX
    349                                                         // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    350                                                         $char = pack('C*', $ord_var_c,
    351                                                                                 @ord($var[$c + 1]),
    352                                                                                 @ord($var[$c + 2]));
    353                                                         $c += 2;
    354                                                         $utf16 = $this->utf82utf16($char);
    355                                                         $ascii .= sprintf('\u%04s', bin2hex($utf16));
    356                                                         break;
    357 
    358                                                 case (($ord_var_c & 0xF8) == 0xF0):
    359                                                         if ($c+3 >= $strlen_var) {
    360                                                                 $c += 3;
    361                                                                 $ascii .= '?';
    362                                                                 break;
    363                                                         }
    364                                                         // characters U-00010000 - U-001FFFFF, mask 11110XXX
    365                                                         // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    366                                                         $char = pack('C*', $ord_var_c,
    367                                                                                 ord($var[$c + 1]),
    368                                                                                 ord($var[$c + 2]),
    369                                                                                 ord($var[$c + 3]));
    370                                                         $c += 3;
    371                                                         $utf16 = $this->utf82utf16($char);
    372                                                         $ascii .= sprintf('\u%04s', bin2hex($utf16));
    373                                                         break;
    374 
    375                                                 case (($ord_var_c & 0xFC) == 0xF8):
    376                                                         // characters U-00200000 - U-03FFFFFF, mask 111110XX
    377                                                         // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    378                                                         if ($c+4 >= $strlen_var) {
    379                                                                 $c += 4;
    380                                                                 $ascii .= '?';
    381                                                                 break;
    382                                                         }
    383                                                         $char = pack('C*', $ord_var_c,
    384                                                                                 ord($var[$c + 1]),
    385                                                                                 ord($var[$c + 2]),
    386                                                                                 ord($var[$c + 3]),
    387                                                                                 ord($var[$c + 4]));
    388                                                         $c += 4;
    389                                                         $utf16 = $this->utf82utf16($char);
    390                                                         $ascii .= sprintf('\u%04s', bin2hex($utf16));
    391                                                         break;
    392 
    393                                                 case (($ord_var_c & 0xFE) == 0xFC):
    394                                                 if ($c+5 >= $strlen_var) {
    395                                                                 $c += 5;
    396                                                                 $ascii .= '?';
    397                                                                 break;
    398                                                         }
    399                                                         // characters U-04000000 - U-7FFFFFFF, mask 1111110X
    400                                                         // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    401                                                         $char = pack('C*', $ord_var_c,
    402                                                                                 ord($var[$c + 1]),
    403                                                                                 ord($var[$c + 2]),
    404                                                                                 ord($var[$c + 3]),
    405                                                                                 ord($var[$c + 4]),
    406                                                                                 ord($var[$c + 5]));
    407                                                         $c += 5;
    408                                                         $utf16 = $this->utf82utf16($char);
    409                                                         $ascii .= sprintf('\u%04s', bin2hex($utf16));
    410                                                         break;
    411                                         }
    412                                 }
    413                                 return  '"'.$ascii.'"';
    414 
    415                         case 'array':
    416                         /*
    417                                 * As per JSON spec if any array key is not an integer
    418                                 * we must treat the the whole array as an object. We
    419                                 * also try to catch a sparsely populated associative
    420                                 * array with numeric keys here because some JS engines
    421                                 * will create an array with empty indexes up to
    422                                 * max_index which can cause memory issues and because
    423                                 * the keys, which may be relevant, will be remapped
    424                                 * otherwise.
    425                                 *
    426                                 * As per the ECMA and JSON specification an object may
    427                                 * have any string as a property. Unfortunately due to
    428                                 * a hole in the ECMA specification if the key is a
    429                                 * ECMA reserved word or starts with a digit the
    430                                 * parameter is only accessible using ECMAScript's
    431                                 * bracket notation.
    432                                 */
    433 
    434                                 // treat as a JSON object
    435                                 if (is_array($var) && count($var) && (array_keys($var) !== range(0, sizeof($var) - 1))) {
    436                                         $properties = array_map(array($this, 'name_value'),
    437                                                                                         array_keys($var),
    438                                                                                         array_values($var));
    439 
    440                                         foreach($properties as $property) {
    441                                                 if(Services_JSON::isError($property)) {
    442                                                         return $property;
    443                                                 }
    444                                         }
    445 
    446                                         return '{' . join(',', $properties) . '}';
    447                                 }
    448 
    449                                 // treat it like a regular array
    450                                 $elements = array_map(array($this, '_encode'), $var);
    451 
    452                                 foreach($elements as $element) {
    453                                         if(Services_JSON::isError($element)) {
    454                                                 return $element;
    455                                         }
    456                                 }
    457 
    458                                 return '[' . join(',', $elements) . ']';
    459 
    460                         case 'object':
    461                                 $vars = get_object_vars($var);
    462 
    463                                 $properties = array_map(array($this, 'name_value'),
    464                                                                                 array_keys($vars),
    465                                                                                 array_values($vars));
    466 
    467                                 foreach($properties as $property) {
    468                                         if(Services_JSON::isError($property)) {
    469                                                 return $property;
    470                                         }
    471                                 }
    472 
    473                                 return '{' . join(',', $properties) . '}';
    474 
    475                         default:
    476                                 return ($this->use & SERVICES_JSON_SUPPRESS_ERRORS)
    477                                         ? 'null'
    478                                         : new Services_JSON_Error(gettype($var)." can not be encoded as JSON string");
    479                 }
    480         }
    481 
    482  /**
    483         * array-walking function for use in generating JSON-formatted name-value pairs
    484         *
    485         * @param        string  $name name of key to use
    486         * @param        mixed $value  reference to an array element to be encoded
    487         *
    488         * @return string  JSON-formatted name-value pair, like '"name":value'
    489         * @access private
    490         */
    491         function name_value($name, $value)
    492         {
    493                 $encoded_value = $this->_encode($value);
    494 
    495                 if(Services_JSON::isError($encoded_value)) {
    496                         return $encoded_value;
    497                 }
    498 
    499                 return $this->_encode(strval($name)) . ':' . $encoded_value;
    500         }
    501 
    502  /**
    503         * reduce a string by removing leading and trailing comments and whitespace
    504         *
    505         * @param        $str    string  string value to strip of comments and whitespace
    506         *
    507         * @return string  string value stripped of comments and whitespace
    508         * @access private
    509         */
    510         function reduce_string($str)
    511         {
    512                 $str = preg_replace(array(
    513 
    514                                 // eliminate single line comments in '// ...' form
    515                                 '#^\s*//(.+)$#m',
    516 
    517                                 // eliminate multi-line comments in '/* ... */' form, at start of string
    518                                 '#^\s*/\*(.+)\*/#Us',
    519 
    520                                 // eliminate multi-line comments in '/* ... */' form, at end of string
    521                                 '#/\*(.+)\*/\s*$#Us'
    522 
    523                         ), '', $str);
    524 
    525                 // eliminate extraneous space
    526                 return trim($str);
    527         }
    528 
    529  /**
    530         * decodes a JSON string into appropriate variable
    531         *
    532         * @param        string  $str    JSON-formatted string
    533         *
    534         * @return mixed number, boolean, string, array, or object
    535         *                               corresponding to given JSON input string.
    536         *                               See argument 1 to Services_JSON() above for object-output behavior.
    537         *                               Note that decode() always returns strings
    538         *                               in ASCII or UTF-8 format!
    539         * @access public
    540         */
    541         function decode($str)
    542         {
    543                 $str = $this->reduce_string($str);
    544 
    545                 switch (strtolower($str)) {
    546                         case 'true':
    547                                 return true;
    548 
    549                         case 'false':
    550                                 return false;
    551 
    552                         case 'null':
    553                                 return null;
    554 
    555                         default:
    556                                 $m = array();
    557 
    558                                 if (is_numeric($str)) {
    559                                         // Lookie-loo, it's a number
    560 
    561                                         // This would work on its own, but I'm trying to be
    562                                         // good about returning integers where appropriate:
    563                                         // return (float)$str;
    564 
    565                                         // Return float or int, as appropriate
    566                                         return ((float)$str == (integer)$str)
    567                                                 ? (integer)$str
    568                                                 : (float)$str;
    569 
    570                                 } elseif (preg_match('/^("|\').*(\1)$/s', $str, $m) && $m[1] == $m[2]) {
    571                                         // STRINGS RETURNED IN UTF-8 FORMAT
    572                                         $delim = substr($str, 0, 1);
    573                                         $chrs = substr($str, 1, -1);
    574                                         $utf8 = '';
    575                                         $strlen_chrs = strlen($chrs);
    576 
    577                                         for ($c = 0; $c < $strlen_chrs; ++$c) {
    578 
    579                                                 $substr_chrs_c_2 = substr($chrs, $c, 2);
    580                                                 $ord_chrs_c = ord($chrs[$c]);
    581 
    582                                                 switch (true) {
    583                                                         case $substr_chrs_c_2 == '\b':
    584                                                                 $utf8 .= chr(0x08);
    585                                                                 ++$c;
    586                                                                 break;
    587                                                         case $substr_chrs_c_2 == '\t':
    588                                                                 $utf8 .= chr(0x09);
    589                                                                 ++$c;
    590                                                                 break;
    591                                                         case $substr_chrs_c_2 == '\n':
    592                                                                 $utf8 .= chr(0x0A);
    593                                                                 ++$c;
    594                                                                 break;
    595                                                         case $substr_chrs_c_2 == '\f':
    596                                                                 $utf8 .= chr(0x0C);
    597                                                                 ++$c;
    598                                                                 break;
    599                                                         case $substr_chrs_c_2 == '\r':
    600                                                                 $utf8 .= chr(0x0D);
    601                                                                 ++$c;
    602                                                                 break;
    603 
    604                                                         case $substr_chrs_c_2 == '\\"':
    605                                                         case $substr_chrs_c_2 == '\\\'':
    606                                                         case $substr_chrs_c_2 == '\\\\':
    607                                                         case $substr_chrs_c_2 == '\\/':
    608                                                                 if (($delim == '"' && $substr_chrs_c_2 != '\\\'') ||
    609                                                                 ($delim == "'" && $substr_chrs_c_2 != '\\"')) {
    610                                                                         $utf8 .= $chrs[++$c];
    611                                                                 }
    612                                                                 break;
    613 
    614                                                         case preg_match('/\\\u[0-9A-F]{4}/i', substr($chrs, $c, 6)):
    615                                                                 // single, escaped unicode character
    616                                                                 $utf16 = chr(hexdec(substr($chrs, ($c + 2), 2)))
    617                                                                         . chr(hexdec(substr($chrs, ($c + 4), 2)));
    618                                                                 $utf8 .= $this->utf162utf8($utf16);
    619                                                                 $c += 5;
    620                                                                 break;
    621 
    622                                                         case ($ord_chrs_c >= 0x20) && ($ord_chrs_c <= 0x7F):
    623                                                                 $utf8 .= $chrs[$c];
    624                                                                 break;
    625 
    626                                                         case ($ord_chrs_c & 0xE0) == 0xC0:
    627                                                                 // characters U-00000080 - U-000007FF, mask 110XXXXX
    628                                                                 //see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    629                                                                 $utf8 .= substr($chrs, $c, 2);
    630                                                                 ++$c;
    631                                                                 break;
    632 
    633                                                         case ($ord_chrs_c & 0xF0) == 0xE0:
    634                                                                 // characters U-00000800 - U-0000FFFF, mask 1110XXXX
    635                                                                 // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    636                                                                 $utf8 .= substr($chrs, $c, 3);
    637                                                                 $c += 2;
    638                                                                 break;
    639 
    640                                                         case ($ord_chrs_c & 0xF8) == 0xF0:
    641                                                                 // characters U-00010000 - U-001FFFFF, mask 11110XXX
    642                                                                 // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    643                                                                 $utf8 .= substr($chrs, $c, 4);
    644                                                                 $c += 3;
    645                                                                 break;
    646 
    647                                                         case ($ord_chrs_c & 0xFC) == 0xF8:
    648                                                                 // characters U-00200000 - U-03FFFFFF, mask 111110XX
    649                                                                 // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    650                                                                 $utf8 .= substr($chrs, $c, 5);
    651                                                                 $c += 4;
    652                                                                 break;
    653 
    654                                                         case ($ord_chrs_c & 0xFE) == 0xFC:
    655                                                                 // characters U-04000000 - U-7FFFFFFF, mask 1111110X
    656                                                                 // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
    657                                                                 $utf8 .= substr($chrs, $c, 6);
    658                                                                 $c += 5;
    659                                                                 break;
    660 
    661                                                 }
    662 
    663                                         }
    664 
    665                                         return $utf8;
    666 
    667                                 } elseif (preg_match('/^\[.*\]$/s', $str) || preg_match('/^\{.*\}$/s', $str)) {
    668                                         // array, or object notation
    669 
    670                                         if ($str[0] == '[') {
    671                                                 $stk = array(SERVICES_JSON_IN_ARR);
    672                                                 $arr = array();
    673                                         } else {
    674                                                 if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
    675                                                         $stk = array(SERVICES_JSON_IN_OBJ);
    676                                                         $obj = array();
    677                                                 } else {
    678                                                         $stk = array(SERVICES_JSON_IN_OBJ);
    679                                                         $obj = new stdClass();
    680                                                 }
    681                                         }
    682 
    683                                         array_push($stk, array('what'  => SERVICES_JSON_SLICE,
    684                                                                                 'where' => 0,
    685                                                                                 'delim' => false));
    686 
    687                                         $chrs = substr($str, 1, -1);
    688                                         $chrs = $this->reduce_string($chrs);
    689 
    690                                         if ($chrs == '') {
    691                                                 if (reset($stk) == SERVICES_JSON_IN_ARR) {
    692                                                         return $arr;
    693 
    694                                                 } else {
    695                                                         return $obj;
    696 
    697                                                 }
    698                                         }
    699 
    700                                         //print("\nparsing {$chrs}\n");
    701 
    702                                         $strlen_chrs = strlen($chrs);
    703 
    704                                         for ($c = 0; $c <= $strlen_chrs; ++$c) {
    705 
    706                                                 $top = end($stk);
    707                                                 $substr_chrs_c_2 = substr($chrs, $c, 2);
    708 
    709                                                 if (($c == $strlen_chrs) || (($chrs[$c] == ',') && ($top['what'] == SERVICES_JSON_SLICE))) {
    710                                                         // found a comma that is not inside a string, array, etc.,
    711                                                         // OR we've reached the end of the character list
    712                                                         $slice = substr($chrs, $top['where'], ($c - $top['where']));
    713                                                         array_push($stk, array('what' => SERVICES_JSON_SLICE, 'where' => ($c + 1), 'delim' => false));
    714                                                         //print("Found split at {$c}: ".substr($chrs, $top['where'], (1 + $c - $top['where']))."\n");
    715 
    716                                                         if (reset($stk) == SERVICES_JSON_IN_ARR) {
    717                                                                 // we are in an array, so just push an element onto the stack
    718                                                                 array_push($arr, $this->decode($slice));
    719 
    720                                                         } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
    721                                                                 // we are in an object, so figure
    722                                                                 // out the property name and set an
    723                                                                 // element in an associative array,
    724                                                                 // for now
    725                                                                 $parts = array();
    726 
    727                                                                 if (preg_match('/^\s*(["\'].*[^\\\]["\'])\s*:\s*(\S.*),?$/Uis', $slice, $parts)) {
    728                                                                         // "name":value pair
    729                                                                         $key = $this->decode($parts[1]);
    730                                                                         $val = $this->decode($parts[2]);
    731 
    732                                                                         if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
    733                                                                                 $obj[$key] = $val;
    734                                                                         } else {
    735                                                                                 $obj->$key = $val;
    736                                                                         }
    737                                                                 } elseif (preg_match('/^\s*(\w+)\s*:\s*(\S.*),?$/Uis', $slice, $parts)) {
    738                                                                         // name:value pair, where name is unquoted
    739                                                                         $key = $parts[1];
    740                                                                         $val = $this->decode($parts[2]);
    741 
    742                                                                         if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
    743                                                                                 $obj[$key] = $val;
    744                                                                         } else {
    745                                                                                 $obj->$key = $val;
    746                                                                         }
    747                                                                 }
    748 
    749                                                         }
    750 
    751                                                 } elseif ((($chrs[$c] == '"') || ($chrs[$c] == "'")) && ($top['what'] != SERVICES_JSON_IN_STR)) {
    752                                                         // found a quote, and we are not inside a string
    753                                                         array_push($stk, array('what' => SERVICES_JSON_IN_STR, 'where' => $c, 'delim' => $chrs[$c]));
    754                                                         //print("Found start of string at {$c}\n");
    755 
    756                                                 } elseif (($chrs[$c] == $top['delim']) &&
    757                                                                 ($top['what'] == SERVICES_JSON_IN_STR) &&
    758                                                                 ((strlen(substr($chrs, 0, $c)) - strlen(rtrim(substr($chrs, 0, $c), '\\'))) % 2 != 1)) {
    759                                                         // found a quote, we're in a string, and it's not escaped
    760                                                         // we know that it's not escaped becase there is _not_ an
    761                                                         // odd number of backslashes at the end of the string so far
    762                                                         array_pop($stk);
    763                                                         //print("Found end of string at {$c}: ".substr($chrs, $top['where'], (1 + 1 + $c - $top['where']))."\n");
    764 
    765                                                 } elseif (($chrs[$c] == '[') &&
    766                                                                 in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
    767                                                         // found a left-bracket, and we are in an array, object, or slice
    768                                                         array_push($stk, array('what' => SERVICES_JSON_IN_ARR, 'where' => $c, 'delim' => false));
    769                                                         //print("Found start of array at {$c}\n");
    770 
    771                                                 } elseif (($chrs[$c] == ']') && ($top['what'] == SERVICES_JSON_IN_ARR)) {
    772                                                         // found a right-bracket, and we're in an array
    773                                                         array_pop($stk);
    774                                                         //print("Found end of array at {$c}: ".substr($chrs, $top['where'], (1 + $c - $top['where']))."\n");
    775 
    776                                                 } elseif (($chrs[$c] == '{') &&
    777                                                                 in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
    778                                                         // found a left-brace, and we are in an array, object, or slice
    779                                                         array_push($stk, array('what' => SERVICES_JSON_IN_OBJ, 'where' => $c, 'delim' => false));
    780                                                         //print("Found start of object at {$c}\n");
    781 
    782                                                 } elseif (($chrs[$c] == '}') && ($top['what'] == SERVICES_JSON_IN_OBJ)) {
    783                                                         // found a right-brace, and we're in an object
    784                                                         array_pop($stk);
    785                                                         //print("Found end of object at {$c}: ".substr($chrs, $top['where'], (1 + $c - $top['where']))."\n");
    786 
    787                                                 } elseif (($substr_chrs_c_2 == '/*') &&
    788                                                                 in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
    789                                                         // found a comment start, and we are in an array, object, or slice
    790                                                         array_push($stk, array('what' => SERVICES_JSON_IN_CMT, 'where' => $c, 'delim' => false));
    791                                                         $c++;
    792                                                         //print("Found start of comment at {$c}\n");
    793 
    794                                                 } elseif (($substr_chrs_c_2 == '*/') && ($top['what'] == SERVICES_JSON_IN_CMT)) {
    795                                                         // found a comment end, and we're in one now
    796                                                         array_pop($stk);
    797                                                         $c++;
    798 
    799                                                         for ($i = $top['where']; $i <= $c; ++$i)
    800                                                                 $chrs = substr_replace($chrs, ' ', $i, 1);
    801 
    802                                                         //print("Found end of comment at {$c}: ".substr($chrs, $top['where'], (1 + $c - $top['where']))."\n");
    803 
    804                                                 }
    805 
    806                                         }
    807 
    808                                         if (reset($stk) == SERVICES_JSON_IN_ARR) {
    809                                                 return $arr;
    810 
    811                                         } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
    812                                                 return $obj;
    813 
    814                                         }
    815 
    816                                 }
    817                 }
    818         }
    819 
    820         /**
    821         * @todo Ultimately, this should just call PEAR::isError()
    822         */
    823         function isError($data, $code = null)
    824         {
    825                 if (class_exists('pear')) {
    826                         return PEAR::isError($data, $code);
    827                 } elseif (is_object($data) && (get_class($data) == 'services_json_error' ||
    828                                                                 is_subclass_of($data, 'services_json_error'))) {
    829                         return true;
    830                 }
    831 
    832                 return false;
    833         }
     122   /**
     123    * constructs a new JSON instance
     124    *
     125    * @param    int     $use    object behavior flags; combine with boolean-OR
     126    *
     127    *                           possible values:
     128    *                           - SERVICES_JSON_LOOSE_TYPE:  loose typing.
     129    *                                   "{...}" syntax creates associative arrays
     130    *                                   instead of objects in decode().
     131    *                           - SERVICES_JSON_SUPPRESS_ERRORS:  error suppression.
     132    *                                   Values which can't be encoded (e.g. resources)
     133    *                                   appear as NULL instead of throwing errors.
     134    *                                   By default, a deeply-nested resource will
     135    *                                   bubble up with an error, so all return values
     136    *                                   from encode() should be checked with isError()
     137    *                           - SERVICES_JSON_USE_TO_JSON:  call toJSON when serializing objects
     138    *                                   It serializes the return value from the toJSON call rather
     139    *                                   than the object it'self,  toJSON can return associative arrays,
     140    *                                   strings or numbers, if you return an object, make sure it does
     141    *                                   not have a toJSON method, otherwise an error will occur.
     142    */
     143    function Services_JSON($use = 0)
     144    {
     145        $this->use = $use;
     146        $this->_mb_strlen            = function_exists('mb_strlen');
     147        $this->_mb_convert_encoding  = function_exists('mb_convert_encoding');
     148        $this->_mb_substr            = function_exists('mb_substr');
     149    }
     150    // private - cache the mbstring lookup results..
     151    var $_mb_strlen = false;
     152    var $_mb_substr = false;
     153    var $_mb_convert_encoding = false;
     154   
     155   /**
     156    * convert a string from one UTF-16 char to one UTF-8 char
     157    *
     158    * Normally should be handled by mb_convert_encoding, but
     159    * provides a slower PHP-only method for installations
     160    * that lack the multibye string extension.
     161    *
     162    * @param    string  $utf16  UTF-16 character
     163    * @return   string  UTF-8 character
     164    * @access   private
     165    */
     166    function utf162utf8($utf16)
     167    {
     168        // oh please oh please oh please oh please oh please
     169        if($this->_mb_convert_encoding) {
     170            return mb_convert_encoding($utf16, 'UTF-8', 'UTF-16');
     171        }
     172
     173        $bytes = (ord($utf16{0}) << 8) | ord($utf16{1});
     174
     175        switch(true) {
     176            case ((0x7F & $bytes) == $bytes):
     177                // this case should never be reached, because we are in ASCII range
     178                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     179                return chr(0x7F & $bytes);
     180
     181            case (0x07FF & $bytes) == $bytes:
     182                // return a 2-byte UTF-8 character
     183                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     184                return chr(0xC0 | (($bytes >> 6) & 0x1F))
     185                     . chr(0x80 | ($bytes & 0x3F));
     186
     187            case (0xFFFF & $bytes) == $bytes:
     188                // return a 3-byte UTF-8 character
     189                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     190                return chr(0xE0 | (($bytes >> 12) & 0x0F))
     191                     . chr(0x80 | (($bytes >> 6) & 0x3F))
     192                     . chr(0x80 | ($bytes & 0x3F));
     193        }
     194
     195        // ignoring UTF-32 for now, sorry
     196        return '';
     197    }
     198
     199   /**
     200    * convert a string from one UTF-8 char to one UTF-16 char
     201    *
     202    * Normally should be handled by mb_convert_encoding, but
     203    * provides a slower PHP-only method for installations
     204    * that lack the multibye string extension.
     205    *
     206    * @param    string  $utf8   UTF-8 character
     207    * @return   string  UTF-16 character
     208    * @access   private
     209    */
     210    function utf82utf16($utf8)
     211    {
     212        // oh please oh please oh please oh please oh please
     213        if($this->_mb_convert_encoding) {
     214            return mb_convert_encoding($utf8, 'UTF-16', 'UTF-8');
     215        }
     216
     217        switch($this->strlen8($utf8)) {
     218            case 1:
     219                // this case should never be reached, because we are in ASCII range
     220                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     221                return $utf8;
     222
     223            case 2:
     224                // return a UTF-16 character from a 2-byte UTF-8 char
     225                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     226                return chr(0x07 & (ord($utf8{0}) >> 2))
     227                     . chr((0xC0 & (ord($utf8{0}) << 6))
     228                         | (0x3F & ord($utf8{1})));
     229
     230            case 3:
     231                // return a UTF-16 character from a 3-byte UTF-8 char
     232                // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     233                return chr((0xF0 & (ord($utf8{0}) << 4))
     234                         | (0x0F & (ord($utf8{1}) >> 2)))
     235                     . chr((0xC0 & (ord($utf8{1}) << 6))
     236                         | (0x7F & ord($utf8{2})));
     237        }
     238
     239        // ignoring UTF-32 for now, sorry
     240        return '';
     241    }
     242
     243   /**
     244    * encodes an arbitrary variable into JSON format (and sends JSON Header)
     245    *
     246    * @param    mixed   $var    any number, boolean, string, array, or object to be encoded.
     247    *                           see argument 1 to Services_JSON() above for array-parsing behavior.
     248    *                           if var is a strng, note that encode() always expects it
     249    *                           to be in ASCII or UTF-8 format!
     250    *
     251    * @return   mixed   JSON string representation of input var or an error if a problem occurs
     252    * @access   public
     253    */
     254    function encode($var)
     255    {
     256        header('Content-type: application/json');
     257        return $this->encodeUnsafe($var);
     258    }
     259    /**
     260    * encodes an arbitrary variable into JSON format without JSON Header - warning - may allow XSS!!!!)
     261    *
     262    * @param    mixed   $var    any number, boolean, string, array, or object to be encoded.
     263    *                           see argument 1 to Services_JSON() above for array-parsing behavior.
     264    *                           if var is a strng, note that encode() always expects it
     265    *                           to be in ASCII or UTF-8 format!
     266    *
     267    * @return   mixed   JSON string representation of input var or an error if a problem occurs
     268    * @access   public
     269    */
     270    function encodeUnsafe($var)
     271    {
     272        // see bug #16908 - regarding numeric locale printing
     273        $lc = setlocale(LC_NUMERIC, 0);
     274        setlocale(LC_NUMERIC, 'C');
     275        $ret = $this->_encode($var);
     276        setlocale(LC_NUMERIC, $lc);
     277        return $ret;
     278       
     279    }
     280    /**
     281    * PRIVATE CODE that does the work of encodes an arbitrary variable into JSON format
     282    *
     283    * @param    mixed   $var    any number, boolean, string, array, or object to be encoded.
     284    *                           see argument 1 to Services_JSON() above for array-parsing behavior.
     285    *                           if var is a strng, note that encode() always expects it
     286    *                           to be in ASCII or UTF-8 format!
     287    *
     288    * @return   mixed   JSON string representation of input var or an error if a problem occurs
     289    * @access   public
     290    */
     291    function _encode($var)
     292    {
     293         
     294        switch (gettype($var)) {
     295            case 'boolean':
     296                return $var ? 'true' : 'false';
     297
     298            case 'NULL':
     299                return 'null';
     300
     301            case 'integer':
     302                return (int) $var;
     303
     304            case 'double':
     305            case 'float':
     306                return  (float) $var;
     307
     308            case 'string':
     309                // STRINGS ARE EXPECTED TO BE IN ASCII OR UTF-8 FORMAT
     310                $ascii = '';
     311                $strlen_var = $this->strlen8($var);
     312
     313               /*
     314                * Iterate over every character in the string,
     315                * escaping with a slash or encoding to UTF-8 where necessary
     316                */
     317                for ($c = 0; $c < $strlen_var; ++$c) {
     318
     319                    $ord_var_c = ord($var{$c});
     320
     321                    switch (true) {
     322                        case $ord_var_c == 0x08:
     323                            $ascii .= '\b';
     324                            break;
     325                        case $ord_var_c == 0x09:
     326                            $ascii .= '\t';
     327                            break;
     328                        case $ord_var_c == 0x0A:
     329                            $ascii .= '\n';
     330                            break;
     331                        case $ord_var_c == 0x0C:
     332                            $ascii .= '\f';
     333                            break;
     334                        case $ord_var_c == 0x0D:
     335                            $ascii .= '\r';
     336                            break;
     337
     338                        case $ord_var_c == 0x22:
     339                        case $ord_var_c == 0x2F:
     340                        case $ord_var_c == 0x5C:
     341                            // double quote, slash, slosh
     342                            $ascii .= '\\'.$var{$c};
     343                            break;
     344
     345                        case (($ord_var_c >= 0x20) && ($ord_var_c <= 0x7F)):
     346                            // characters U-00000000 - U-0000007F (same as ASCII)
     347                            $ascii .= $var{$c};
     348                            break;
     349
     350                        case (($ord_var_c & 0xE0) == 0xC0):
     351                            // characters U-00000080 - U-000007FF, mask 110XXXXX
     352                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     353                            if ($c+1 >= $strlen_var) {
     354                                $c += 1;
     355                                $ascii .= '?';
     356                                break;
     357                            }
     358                           
     359                            $char = pack('C*', $ord_var_c, ord($var{$c + 1}));
     360                            $c += 1;
     361                            $utf16 = $this->utf82utf16($char);
     362                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
     363                            break;
     364
     365                        case (($ord_var_c & 0xF0) == 0xE0):
     366                            if ($c+2 >= $strlen_var) {
     367                                $c += 2;
     368                                $ascii .= '?';
     369                                break;
     370                            }
     371                            // characters U-00000800 - U-0000FFFF, mask 1110XXXX
     372                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     373                            $char = pack('C*', $ord_var_c,
     374                                         @ord($var{$c + 1}),
     375                                         @ord($var{$c + 2}));
     376                            $c += 2;
     377                            $utf16 = $this->utf82utf16($char);
     378                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
     379                            break;
     380
     381                        case (($ord_var_c & 0xF8) == 0xF0):
     382                            if ($c+3 >= $strlen_var) {
     383                                $c += 3;
     384                                $ascii .= '?';
     385                                break;
     386                            }
     387                            // characters U-00010000 - U-001FFFFF, mask 11110XXX
     388                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     389                            $char = pack('C*', $ord_var_c,
     390                                         ord($var{$c + 1}),
     391                                         ord($var{$c + 2}),
     392                                         ord($var{$c + 3}));
     393                            $c += 3;
     394                            $utf16 = $this->utf82utf16($char);
     395                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
     396                            break;
     397
     398                        case (($ord_var_c & 0xFC) == 0xF8):
     399                            // characters U-00200000 - U-03FFFFFF, mask 111110XX
     400                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     401                            if ($c+4 >= $strlen_var) {
     402                                $c += 4;
     403                                $ascii .= '?';
     404                                break;
     405                            }
     406                            $char = pack('C*', $ord_var_c,
     407                                         ord($var{$c + 1}),
     408                                         ord($var{$c + 2}),
     409                                         ord($var{$c + 3}),
     410                                         ord($var{$c + 4}));
     411                            $c += 4;
     412                            $utf16 = $this->utf82utf16($char);
     413                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
     414                            break;
     415
     416                        case (($ord_var_c & 0xFE) == 0xFC):
     417                        if ($c+5 >= $strlen_var) {
     418                                $c += 5;
     419                                $ascii .= '?';
     420                                break;
     421                            }
     422                            // characters U-04000000 - U-7FFFFFFF, mask 1111110X
     423                            // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     424                            $char = pack('C*', $ord_var_c,
     425                                         ord($var{$c + 1}),
     426                                         ord($var{$c + 2}),
     427                                         ord($var{$c + 3}),
     428                                         ord($var{$c + 4}),
     429                                         ord($var{$c + 5}));
     430                            $c += 5;
     431                            $utf16 = $this->utf82utf16($char);
     432                            $ascii .= sprintf('\u%04s', bin2hex($utf16));
     433                            break;
     434                    }
     435                }
     436                return  '"'.$ascii.'"';
     437
     438            case 'array':
     439               /*
     440                * As per JSON spec if any array key is not an integer
     441                * we must treat the the whole array as an object. We
     442                * also try to catch a sparsely populated associative
     443                * array with numeric keys here because some JS engines
     444                * will create an array with empty indexes up to
     445                * max_index which can cause memory issues and because
     446                * the keys, which may be relevant, will be remapped
     447                * otherwise.
     448                *
     449                * As per the ECMA and JSON specification an object may
     450                * have any string as a property. Unfortunately due to
     451                * a hole in the ECMA specification if the key is a
     452                * ECMA reserved word or starts with a digit the
     453                * parameter is only accessible using ECMAScript's
     454                * bracket notation.
     455                */
     456
     457                // treat as a JSON object
     458                if (is_array($var) && count($var) && (array_keys($var) !== range(0, sizeof($var) - 1))) {
     459                    $properties = array_map(array($this, 'name_value'),
     460                                            array_keys($var),
     461                                            array_values($var));
     462
     463                    foreach($properties as $property) {
     464                        if(Services_JSON::isError($property)) {
     465                            return $property;
     466                        }
     467                    }
     468
     469                    return '{' . join(',', $properties) . '}';
     470                }
     471
     472                // treat it like a regular array
     473                $elements = array_map(array($this, '_encode'), $var);
     474
     475                foreach($elements as $element) {
     476                    if(Services_JSON::isError($element)) {
     477                        return $element;
     478                    }
     479                }
     480
     481                return '[' . join(',', $elements) . ']';
     482
     483            case 'object':
     484           
     485                // support toJSON methods.
     486                if (($this->use & SERVICES_JSON_USE_TO_JSON) && method_exists($var, 'toJSON')) {
     487                    // this may end up allowing unlimited recursion
     488                    // so we check the return value to make sure it's not got the same method.
     489                    $recode = $var->toJSON();
     490                   
     491                    if (method_exists($recode, 'toJSON')) {
     492                       
     493                        return ($this->use & SERVICES_JSON_SUPPRESS_ERRORS)
     494                        ? 'null'
     495                        : new Services_JSON_Error(class_name($var).
     496                            " toJSON returned an object with a toJSON method.");
     497                           
     498                    }
     499                   
     500                    return $this->_encode( $recode );
     501                }
     502               
     503                $vars = get_object_vars($var);
     504               
     505                $properties = array_map(array($this, 'name_value'),
     506                                        array_keys($vars),
     507                                        array_values($vars));
     508
     509                foreach($properties as $property) {
     510                    if(Services_JSON::isError($property)) {
     511                        return $property;
     512                    }
     513                }
     514
     515                return '{' . join(',', $properties) . '}';
     516
     517            default:
     518                return ($this->use & SERVICES_JSON_SUPPRESS_ERRORS)
     519                    ? 'null'
     520                    : new Services_JSON_Error(gettype($var)." can not be encoded as JSON string");
     521        }
     522    }
     523
     524   /**
     525    * array-walking function for use in generating JSON-formatted name-value pairs
     526    *
     527    * @param    string  $name   name of key to use
     528    * @param    mixed   $value  reference to an array element to be encoded
     529    *
     530    * @return   string  JSON-formatted name-value pair, like '"name":value'
     531    * @access   private
     532    */
     533    function name_value($name, $value)
     534    {
     535        $encoded_value = $this->_encode($value);
     536
     537        if(Services_JSON::isError($encoded_value)) {
     538            return $encoded_value;
     539        }
     540
     541        return $this->_encode(strval($name)) . ':' . $encoded_value;
     542    }
     543
     544   /**
     545    * reduce a string by removing leading and trailing comments and whitespace
     546    *
     547    * @param    $str    string      string value to strip of comments and whitespace
     548    *
     549    * @return   string  string value stripped of comments and whitespace
     550    * @access   private
     551    */
     552    function reduce_string($str)
     553    {
     554        $str = preg_replace(array(
     555
     556                // eliminate single line comments in '// ...' form
     557                '#^\s*//(.+)$#m',
     558
     559                // eliminate multi-line comments in '/* ... */' form, at start of string
     560                '#^\s*/\*(.+)\*/#Us',
     561
     562                // eliminate multi-line comments in '/* ... */' form, at end of string
     563                '#/\*(.+)\*/\s*$#Us'
     564
     565            ), '', $str);
     566
     567        // eliminate extraneous space
     568        return trim($str);
     569    }
     570
     571   /**
     572    * decodes a JSON string into appropriate variable
     573    *
     574    * @param    string  $str    JSON-formatted string
     575    *
     576    * @return   mixed   number, boolean, string, array, or object
     577    *                   corresponding to given JSON input string.
     578    *                   See argument 1 to Services_JSON() above for object-output behavior.
     579    *                   Note that decode() always returns strings
     580    *                   in ASCII or UTF-8 format!
     581    * @access   public
     582    */
     583    function decode($str)
     584    {
     585        $str = $this->reduce_string($str);
     586
     587        switch (strtolower($str)) {
     588            case 'true':
     589                return true;
     590
     591            case 'false':
     592                return false;
     593
     594            case 'null':
     595                return null;
     596
     597            default:
     598                $m = array();
     599
     600                if (is_numeric($str)) {
     601                    // Lookie-loo, it's a number
     602
     603                    // This would work on its own, but I'm trying to be
     604                    // good about returning integers where appropriate:
     605                    // return (float)$str;
     606
     607                    // Return float or int, as appropriate
     608                    return ((float)$str == (integer)$str)
     609                        ? (integer)$str
     610                        : (float)$str;
     611
     612                } elseif (preg_match('/^("|\').*(\1)$/s', $str, $m) && $m[1] == $m[2]) {
     613                    // STRINGS RETURNED IN UTF-8 FORMAT
     614                    $delim = $this->substr8($str, 0, 1);
     615                    $chrs = $this->substr8($str, 1, -1);
     616                    $utf8 = '';
     617                    $strlen_chrs = $this->strlen8($chrs);
     618
     619                    for ($c = 0; $c < $strlen_chrs; ++$c) {
     620
     621                        $substr_chrs_c_2 = $this->substr8($chrs, $c, 2);
     622                        $ord_chrs_c = ord($chrs{$c});
     623
     624                        switch (true) {
     625                            case $substr_chrs_c_2 == '\b':
     626                                $utf8 .= chr(0x08);
     627                                ++$c;
     628                                break;
     629                            case $substr_chrs_c_2 == '\t':
     630                                $utf8 .= chr(0x09);
     631                                ++$c;
     632                                break;
     633                            case $substr_chrs_c_2 == '\n':
     634                                $utf8 .= chr(0x0A);
     635                                ++$c;
     636                                break;
     637                            case $substr_chrs_c_2 == '\f':
     638                                $utf8 .= chr(0x0C);
     639                                ++$c;
     640                                break;
     641                            case $substr_chrs_c_2 == '\r':
     642                                $utf8 .= chr(0x0D);
     643                                ++$c;
     644                                break;
     645
     646                            case $substr_chrs_c_2 == '\\"':
     647                            case $substr_chrs_c_2 == '\\\'':
     648                            case $substr_chrs_c_2 == '\\\\':
     649                            case $substr_chrs_c_2 == '\\/':
     650                                if (($delim == '"' && $substr_chrs_c_2 != '\\\'') ||
     651                                   ($delim == "'" && $substr_chrs_c_2 != '\\"')) {
     652                                    $utf8 .= $chrs{++$c};
     653                                }
     654                                break;
     655
     656                            case preg_match('/\\\u[0-9A-F]{4}/i', $this->substr8($chrs, $c, 6)):
     657                                // single, escaped unicode character
     658                                $utf16 = chr(hexdec($this->substr8($chrs, ($c + 2), 2)))
     659                                       . chr(hexdec($this->substr8($chrs, ($c + 4), 2)));
     660                                $utf8 .= $this->utf162utf8($utf16);
     661                                $c += 5;
     662                                break;
     663
     664                            case ($ord_chrs_c >= 0x20) && ($ord_chrs_c <= 0x7F):
     665                                $utf8 .= $chrs{$c};
     666                                break;
     667
     668                            case ($ord_chrs_c & 0xE0) == 0xC0:
     669                                // characters U-00000080 - U-000007FF, mask 110XXXXX
     670                                //see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     671                                $utf8 .= $this->substr8($chrs, $c, 2);
     672                                ++$c;
     673                                break;
     674
     675                            case ($ord_chrs_c & 0xF0) == 0xE0:
     676                                // characters U-00000800 - U-0000FFFF, mask 1110XXXX
     677                                // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     678                                $utf8 .= $this->substr8($chrs, $c, 3);
     679                                $c += 2;
     680                                break;
     681
     682                            case ($ord_chrs_c & 0xF8) == 0xF0:
     683                                // characters U-00010000 - U-001FFFFF, mask 11110XXX
     684                                // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     685                                $utf8 .= $this->substr8($chrs, $c, 4);
     686                                $c += 3;
     687                                break;
     688
     689                            case ($ord_chrs_c & 0xFC) == 0xF8:
     690                                // characters U-00200000 - U-03FFFFFF, mask 111110XX
     691                                // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     692                                $utf8 .= $this->substr8($chrs, $c, 5);
     693                                $c += 4;
     694                                break;
     695
     696                            case ($ord_chrs_c & 0xFE) == 0xFC:
     697                                // characters U-04000000 - U-7FFFFFFF, mask 1111110X
     698                                // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
     699                                $utf8 .= $this->substr8($chrs, $c, 6);
     700                                $c += 5;
     701                                break;
     702
     703                        }
     704
     705                    }
     706
     707                    return $utf8;
     708
     709                } elseif (preg_match('/^\[.*\]$/s', $str) || preg_match('/^\{.*\}$/s', $str)) {
     710                    // array, or object notation
     711
     712                    if ($str{0} == '[') {
     713                        $stk = array(SERVICES_JSON_IN_ARR);
     714                        $arr = array();
     715                    } else {
     716                        if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
     717                            $stk = array(SERVICES_JSON_IN_OBJ);
     718                            $obj = array();
     719                        } else {
     720                            $stk = array(SERVICES_JSON_IN_OBJ);
     721                            $obj = new stdClass();
     722                        }
     723                    }
     724
     725                    array_push($stk, array('what'  => SERVICES_JSON_SLICE,
     726                                           'where' => 0,
     727                                           'delim' => false));
     728
     729                    $chrs = $this->substr8($str, 1, -1);
     730                    $chrs = $this->reduce_string($chrs);
     731
     732                    if ($chrs == '') {
     733                        if (reset($stk) == SERVICES_JSON_IN_ARR) {
     734                            return $arr;
     735
     736                        } else {
     737                            return $obj;
     738
     739                        }
     740                    }
     741
     742                    //print("\nparsing {$chrs}\n");
     743
     744                    $strlen_chrs = $this->strlen8($chrs);
     745
     746                    for ($c = 0; $c <= $strlen_chrs; ++$c) {
     747
     748                        $top = end($stk);
     749                        $substr_chrs_c_2 = $this->substr8($chrs, $c, 2);
     750
     751                        if (($c == $strlen_chrs) || (($chrs{$c} == ',') && ($top['what'] == SERVICES_JSON_SLICE))) {
     752                            // found a comma that is not inside a string, array, etc.,
     753                            // OR we've reached the end of the character list
     754                            $slice = $this->substr8($chrs, $top['where'], ($c - $top['where']));
     755                            array_push($stk, array('what' => SERVICES_JSON_SLICE, 'where' => ($c + 1), 'delim' => false));
     756                            //print("Found split at {$c}: ".$this->substr8($chrs, $top['where'], (1 + $c - $top['where']))."\n");
     757
     758                            if (reset($stk) == SERVICES_JSON_IN_ARR) {
     759                                // we are in an array, so just push an element onto the stack
     760                                array_push($arr, $this->decode($slice));
     761
     762                            } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
     763                                // we are in an object, so figure
     764                                // out the property name and set an
     765                                // element in an associative array,
     766                                // for now
     767                                $parts = array();
     768                               
     769                               if (preg_match('/^\s*(["\'].*[^\\\]["\'])\s*:/Uis', $slice, $parts)) {
     770                                      // "name":value pair
     771                                    $key = $this->decode($parts[1]);
     772                                    $val = $this->decode(trim(substr($slice, strlen($parts[0])), ", \t\n\r\0\x0B"));
     773                                    if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
     774                                        $obj[$key] = $val;
     775                                    } else {
     776                                        $obj->$key = $val;
     777                                    }
     778                                } elseif (preg_match('/^\s*(\w+)\s*:/Uis', $slice, $parts)) {
     779                                    // name:value pair, where name is unquoted
     780                                    $key = $parts[1];
     781                                    $val = $this->decode(trim(substr($slice, strlen($parts[0])), ", \t\n\r\0\x0B"));
     782
     783                                    if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
     784                                        $obj[$key] = $val;
     785                                    } else {
     786                                        $obj->$key = $val;
     787                                    }
     788                                }
     789
     790                            }
     791
     792                        } elseif ((($chrs{$c} == '"') || ($chrs{$c} == "'")) && ($top['what'] != SERVICES_JSON_IN_STR)) {
     793                            // found a quote, and we are not inside a string
     794                            array_push($stk, array('what' => SERVICES_JSON_IN_STR, 'where' => $c, 'delim' => $chrs{$c}));
     795                            //print("Found start of string at {$c}\n");
     796
     797                        } elseif (($chrs{$c} == $top['delim']) &&
     798                                 ($top['what'] == SERVICES_JSON_IN_STR) &&
     799                                 (($this->strlen8($this->substr8($chrs, 0, $c)) - $this->strlen8(rtrim($this->substr8($chrs, 0, $c), '\\'))) % 2 != 1)) {
     800                            // found a quote, we're in a string, and it's not escaped
     801                            // we know that it's not escaped becase there is _not_ an
     802                            // odd number of backslashes at the end of the string so far
     803                            array_pop($stk);
     804                            //print("Found end of string at {$c}: ".$this->substr8($chrs, $top['where'], (1 + 1 + $c - $top['where']))."\n");
     805
     806                        } elseif (($chrs{$c} == '[') &&
     807                                 in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
     808                            // found a left-bracket, and we are in an array, object, or slice
     809                            array_push($stk, array('what' => SERVICES_JSON_IN_ARR, 'where' => $c, 'delim' => false));
     810                            //print("Found start of array at {$c}\n");
     811
     812                        } elseif (($chrs{$c} == ']') && ($top['what'] == SERVICES_JSON_IN_ARR)) {
     813                            // found a right-bracket, and we're in an array
     814                            array_pop($stk);
     815                            //print("Found end of array at {$c}: ".$this->substr8($chrs, $top['where'], (1 + $c - $top['where']))."\n");
     816
     817                        } elseif (($chrs{$c} == '{') &&
     818                                 in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
     819                            // found a left-brace, and we are in an array, object, or slice
     820                            array_push($stk, array('what' => SERVICES_JSON_IN_OBJ, 'where' => $c, 'delim' => false));
     821                            //print("Found start of object at {$c}\n");
     822
     823                        } elseif (($chrs{$c} == '}') && ($top['what'] == SERVICES_JSON_IN_OBJ)) {
     824                            // found a right-brace, and we're in an object
     825                            array_pop($stk);
     826                            //print("Found end of object at {$c}: ".$this->substr8($chrs, $top['where'], (1 + $c - $top['where']))."\n");
     827
     828                        } elseif (($substr_chrs_c_2 == '/*') &&
     829                                 in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
     830                            // found a comment start, and we are in an array, object, or slice
     831                            array_push($stk, array('what' => SERVICES_JSON_IN_CMT, 'where' => $c, 'delim' => false));
     832                            $c++;
     833                            //print("Found start of comment at {$c}\n");
     834
     835                        } elseif (($substr_chrs_c_2 == '*/') && ($top['what'] == SERVICES_JSON_IN_CMT)) {
     836                            // found a comment end, and we're in one now
     837                            array_pop($stk);
     838                            $c++;
     839
     840                            for ($i = $top['where']; $i <= $c; ++$i)
     841                                $chrs = substr_replace($chrs, ' ', $i, 1);
     842
     843                            //print("Found end of comment at {$c}: ".$this->substr8($chrs, $top['where'], (1 + $c - $top['where']))."\n");
     844
     845                        }
     846
     847                    }
     848
     849                    if (reset($stk) == SERVICES_JSON_IN_ARR) {
     850                        return $arr;
     851
     852                    } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
     853                        return $obj;
     854
     855                    }
     856
     857                }
     858        }
     859    }
     860
     861    /**
     862     * @todo Ultimately, this should just call PEAR::isError()
     863     */
     864    function isError($data, $code = null)
     865    {
     866        if (class_exists('pear')) {
     867            return PEAR::isError($data, $code);
     868        } elseif (is_object($data) && (get_class($data) == 'services_json_error' ||
     869                                 is_subclass_of($data, 'services_json_error'))) {
     870            return true;
     871        }
     872
     873        return false;
     874    }
     875   
     876    /**
     877    * Calculates length of string in bytes
     878    * @param string
     879    * @return integer length
     880    */
     881    function strlen8( $str )
     882    {
     883        if ( $this->_mb_strlen ) {
     884            return mb_strlen( $str, "8bit" );
     885        }
     886        return strlen( $str );
     887    }
     888   
     889    /**
     890    * Returns part of a string, interpreting $start and $length as number of bytes.
     891    * @param string
     892    * @param integer start
     893    * @param integer length
     894    * @return integer length
     895    */
     896    function substr8( $string, $start, $length=false )
     897    {
     898        if ( $length === false ) {
     899            $length = $this->strlen8( $string ) - $start;
     900        }
     901        if ( $this->_mb_substr ) {
     902            return mb_substr( $string, $start, $length, "8bit" );
     903        }
     904        return substr( $string, $start, $length );
     905    }
     906
    834907}
    835908
    836909if (class_exists('PEAR_Error')) {
    837910
    838         class Services_JSON_Error extends PEAR_Error
    839         {
    840                 function Services_JSON_Error($message = 'unknown error', $code = null,
    841                                                                         $mode = null, $options = null, $userinfo = null)
    842                 {
    843                         parent::PEAR_Error($message, $code, $mode, $options, $userinfo);
    844                 }
    845         }
     911    class Services_JSON_Error extends PEAR_Error
     912    {
     913        function Services_JSON_Error($message = 'unknown error', $code = null,
     914                                     $mode = null, $options = null, $userinfo = null)
     915        {
     916            parent::PEAR_Error($message, $code, $mode, $options, $userinfo);
     917        }
     918    }
    846919
    847920} else {
    848921
    849         /**
    850         * @todo Ultimately, this class shall be descended from PEAR_Error
    851         */
    852         class Services_JSON_Error
    853         {
    854                 function Services_JSON_Error($message = 'unknown error', $code = null,
    855                                                                         $mode = null, $options = null, $userinfo = null)
    856                 {
    857 
    858                 }
    859         }
    860 
     922    /**
     923     * @todo Ultimately, this class shall be descended from PEAR_Error
     924     */
     925    class Services_JSON_Error
     926    {
     927        function Services_JSON_Error($message = 'unknown error', $code = null,
     928                                     $mode = null, $options = null, $userinfo = null)
     929        {
     930
     931        }
     932    }
     933   
    861934}
    862 endif;
     935
     936endif;
     937 No newline at end of file