Source for file Services_JSON.phpclass

Documentation is available at Services_JSON.phpclass

  1. <?php
  2. /* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
  3.  
  4. /**
  5. * Converts to and from JSON format.
  6. *
  7. * JSON (JavaScript Object Notation) is a lightweight data-interchange
  8. * format. It is easy for humans to read and write. It is easy for machines
  9. * to parse and generate. It is based on a subset of the JavaScript
  10. * Programming Language, Standard ECMA-262 3rd Edition - December 1999.
  11. * This feature can also be found in  Python. JSON is a text format that is
  12. * completely language independent but uses conventions that are familiar
  13. * to programmers of the C-family of languages, including C, C++, C#, Java,
  14. * JavaScript, Perl, TCL, and many others. These properties make JSON an
  15. * ideal data-interchange language.
  16. *
  17. * This package provides a simple encoder and decoder for JSON notation. It
  18. * is intended for use with client-side Javascript applications that make
  19. * use of HTTPRequest to perform server communication functions - data can
  20. * be encoded into JSON notation for use in a client-side javascript, or
  21. * decoded from incoming Javascript requests. JSON format is native to
  22. * Javascript, and can be directly eval()'ed with no further parsing
  23. * overhead
  24. *
  25. * All strings should be in ASCII or UTF-8 format!
  26. *
  27. * LICENSE: Redistribution and use in source and binary forms, with or
  28. * without modification, are permitted provided that the following
  29. * conditions are met: Redistributions of source code must retain the
  30. * above copyright notice, this list of conditions and the following
  31. * disclaimer. Redistributions in binary form must reproduce the above
  32. * copyright notice, this list of conditions and the following disclaimer
  33. * in the documentation and/or other materials provided with the
  34. * distribution.
  35. *
  36. * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED
  37. * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  38. * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN
  39. * NO EVENT SHALL CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  40. * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
  41. * BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
  42. * OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43. * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
  44. * TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
  45. * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
  46. * DAMAGE.
  47. *
  48. * @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. * @license     http://www.opensource.org/licenses/bsd-license.php
  55. * @link        http://pear.php.net/pepr/pepr-proposal-show.php?id=198
  56. */
  57.  
  58. /**
  59. * Marker constant for Services_JSON::decode(), used to flag stack state
  60. */
  61. define('SERVICES_JSON_SLICE',   1);
  62.  
  63. /**
  64. * Marker constant for Services_JSON::decode(), used to flag stack state
  65. */
  66. define('SERVICES_JSON_IN_STR',  2);
  67.  
  68. /**
  69. * Marker constant for Services_JSON::decode(), used to flag stack state
  70. */
  71. define('SERVICES_JSON_IN_ARR',  3);
  72.  
  73. /**
  74. * Marker constant for Services_JSON::decode(), used to flag stack state
  75. */
  76. define('SERVICES_JSON_IN_OBJ',  4);
  77.  
  78. /**
  79. * Marker constant for Services_JSON::decode(), used to flag stack state
  80. */
  81. define('SERVICES_JSON_IN_CMT', 5);
  82.  
  83. /**
  84. * Behavior switch for Services_JSON::decode()
  85. */
  86. define('SERVICES_JSON_LOOSE_TYPE', 16);
  87.  
  88. /**
  89. * Behavior switch for Services_JSON::decode()
  90. */
  91. define('SERVICES_JSON_SUPPRESS_ERRORS', 32);
  92.  
  93. /**
  94. * Converts to and from JSON format.
  95. *
  96. * Brief example of use:
  97. *
  98. * <code>
  99. * // create a new instance of Services_JSON
  100. * $json = new Services_JSON();
  101. *
  102. * // convert a complexe value to JSON notation, and send it to the browser
  103. * $value = array('foo', 'bar', array(1, 2, 'baz'), array(3, array(4)));
  104. * $output = $json->encode($value);
  105. *
  106. * print($output);
  107. * // prints: ["foo","bar",[1,2,"baz"],[3,[4]]]
  108. *
  109. * // accept incoming POST data, assumed to be in JSON notation
  110. * $input = file_get_contents('php://input', 1000000);
  111. * $value = $json->decode($input);
  112. * </code>
  113. */
  114. class Services_JSON
  115. {
  116.     // ---------------------------------------------------------------------------
  117.     // constants
  118.     // ---------------------------------------------------------------------------
  119.     
  120.     // ---------------------------------------------------------------------------
  121.     // class (static)
  122.     // ---------------------------------------------------------------------------
  123.     
  124.     /*** class vars ------------------------------------------------------ */
  125.     
  126.     static protected $myInstance = null; 
  127.     
  128.     /*** class methods --------------------------------------------------- */
  129.     
  130.     // ---------------------------------------------------------------------------
  131.     // object vars
  132.     // ---------------------------------------------------------------------------
  133.     
  134.     /*** compostion --------------------------------------------------- */
  135.     
  136.     /*** attributes  -------------------------------------------------- */
  137.     
  138.     protected $use = 0;
  139.     
  140.     // ---------------------------------------------------------------------------
  141.     // factory / construct
  142.     // ---------------------------------------------------------------------------
  143.     
  144.     public static function &getInstance($use=0)
  145.     {
  146.         if (!isset(self::$myInstance))
  147.         {
  148.             self::$myInstance = new Services_JSON($use);
  149.         }
  150.         self::$myInstance->setUse($use);
  151.         return self::$myInstance;
  152.     }
  153.     
  154.     
  155.    /**
  156.     * constructs a new JSON instance
  157.     *
  158.     * @param    int     $use    object behavior flags; combine with boolean-OR
  159.     *
  160.     *                            possible values:
  161.     *                            - SERVICES_JSON_LOOSE_TYPE:  loose typing.
  162.     *                                    "{...}" syntax creates associative arrays
  163.     *                                    instead of objects in decode().
  164.     *                            - SERVICES_JSON_SUPPRESS_ERRORS:  error suppression.
  165.     *                                    Values which can't be encoded (e.g. resources)
  166.     *                                    appear as NULL instead of throwing errors.
  167.     *                                    By default, a deeply-nested resource will
  168.     *                                    bubble up with an error, so all return values
  169.     *                                    from encode() should be checked with isError()
  170.     */
  171.     function Services_JSON($use = 0)
  172.     {
  173.         $this->use = $use;
  174.     }
  175.     
  176.     // ---------------------------------------------------------------------------
  177.     // getter / setter
  178.     // ---------------------------------------------------------------------------    
  179.     
  180.     /**
  181.      * sets use
  182.      *
  183.      * @param int $use 
  184.      */
  185.     public function setUse($use)
  186.     {
  187.         $this->use = $use;
  188.     }
  189.  
  190.    /**
  191.     * convert a string from one UTF-16 char to one UTF-8 char
  192.     *
  193.     * Normally should be handled by mb_convert_encoding, but
  194.     * provides a slower PHP-only method for installations
  195.     * that lack the multibye string extension.
  196.     *
  197.     * @param    string  $utf16  UTF-16 character
  198.     * @return   string  UTF-8 character
  199.     * @access   private
  200.     */
  201.     function utf162utf8($utf16)
  202.     {
  203.         // oh please oh please oh please oh please oh please
  204.         if(function_exists('mb_convert_encoding'))
  205.             return mb_convert_encoding($utf16, 'UTF-8', 'UTF-16');
  206.         
  207.         $bytes = (ord($utf16{0}) << 8) | ord($utf16{1});
  208.  
  209.         switch(true) {
  210.             case ((0x7F & $bytes) == $bytes):
  211.                 // this case should never be reached, because we are in ASCII range
  212.                 // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  213.                 return chr(0x7F & $bytes);
  214.  
  215.             case (0x07FF & $bytes) == $bytes:
  216.                 // return a 2-byte UTF-8 character
  217.                 // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  218.                 return chr(0xC0 | (($bytes >> 6) & 0x1F))
  219.                      . chr(0x80 | ($bytes & 0x3F));
  220.  
  221.             case (0xFFFF & $bytes) == $bytes:
  222.                 // return a 3-byte UTF-8 character
  223.                 // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  224.                 return chr(0xE0 | (($bytes >> 12) & 0x0F))
  225.                      . chr(0x80 | (($bytes >> 6) & 0x3F))
  226.                      . chr(0x80 | ($bytes & 0x3F));
  227.         }
  228.  
  229.         // ignoring UTF-32 for now, sorry
  230.         return '';
  231.     }        
  232.  
  233.    /**
  234.     * convert a string from one UTF-8 char to one UTF-16 char
  235.     *
  236.     * Normally should be handled by mb_convert_encoding, but
  237.     * provides a slower PHP-only method for installations
  238.     * that lack the multibye string extension.
  239.     *
  240.     * @param    string  $utf8   UTF-8 character
  241.     * @return   string  UTF-16 character
  242.     * @access   private
  243.     */
  244.     function utf82utf16($utf8)
  245.     {
  246.         // oh please oh please oh please oh please oh please
  247.         if(function_exists('mb_convert_encoding'))
  248.             return mb_convert_encoding($utf8, 'UTF-16', 'UTF-8');
  249.         
  250.         switch(strlen($utf8)) {
  251.             case 1:
  252.                 // this case should never be reached, because we are in ASCII range
  253.                 // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  254.                 return $ut8;
  255.  
  256.             case 2:
  257.                 // return a UTF-16 character from a 2-byte UTF-8 char
  258.                 // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  259.                 return chr(0x07 & (ord($utf8{0}) >> 2))
  260.                      . chr((0xC0 & (ord($utf8{0}) << 6))
  261.                          | (0x3F & ord($utf8{1})));
  262.                 
  263.             case 3:
  264.                 // return a UTF-16 character from a 3-byte UTF-8 char
  265.                 // see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  266.                 return chr((0xF0 & (ord($utf8{0}) << 4))
  267.                          | (0x0F & (ord($utf8{1}) >> 2)))
  268.                      . chr((0xC0 & (ord($utf8{1}) << 6))
  269.                          | (0x7F & ord($utf8{2})));
  270.         }
  271.  
  272.         // ignoring UTF-32 for now, sorry
  273.         return '';
  274.     }        
  275.  
  276.    /**
  277.     * encodes an arbitrary variable into JSON format
  278.     *
  279.     * @param    mixed   $var    any number, boolean, string, array, or object to be encoded.
  280.     *                            see argument 1 to Services_JSON() above for array-parsing behavior.
  281.     *                            if var is a strng, note that encode() always expects it
  282.     *                            to be in ASCII or UTF-8 format!
  283.     *
  284.     * @return   mixed   JSON string representation of input var or an error if a problem occurs
  285.     * @access   public
  286.     */
  287.     function encode($var)
  288.     {
  289.         switch (gettype($var)) {
  290.             case 'boolean':
  291.                 return $var ? 'true' : 'false';
  292.             
  293.             case 'NULL':
  294.                 return 'null';
  295.             
  296.             case 'integer':
  297.                 return (int) $var;
  298.                 
  299.             case 'double':
  300.             case 'float':
  301.                 return (float) $var;
  302.                 
  303.             case 'string':
  304.                 // STRINGS ARE EXPECTED TO BE IN ASCII OR UTF-8 FORMAT
  305.                 $ascii = '';
  306.                 $strlen_var = strlen($var);
  307.  
  308.                /*
  309.                 * Iterate over every character in the string,
  310.                 * escaping with a slash or encoding to UTF-8 where necessary
  311.                 */
  312.                 for ($c = 0; $c < $strlen_var; ++$c) {
  313.                     
  314.                     $ord_var_c = ord($var{$c});
  315.                     
  316.                     switch (true) {
  317.                         case $ord_var_c == 0x08:
  318.                             $ascii .= '\b';
  319.                             break;
  320.                         case $ord_var_c == 0x09:
  321.                             $ascii .= '\t';
  322.                             break;
  323.                         case $ord_var_c == 0x0A:
  324.                             $ascii .= '\n';
  325.                             break;
  326.                         case $ord_var_c == 0x0C:
  327.                             $ascii .= '\f';
  328.                             break;
  329.                         case $ord_var_c == 0x0D:
  330.                             $ascii .= '\r';
  331.                             break;
  332.  
  333.                         case $ord_var_c == 0x22:
  334. // CFR                        case $ord_var_c == 0x2F:
  335.                         case $ord_var_c == 0x5C:
  336.                             // double quote, slash, slosh
  337.                             $ascii .= '\\'.$var{$c};
  338.                             break;
  339.                             
  340.                         case (($ord_var_c >= 0x20) && ($ord_var_c <= 0x7F)):
  341.                             // characters U-00000000 - U-0000007F (same as ASCII)
  342.                             $ascii .= $var{$c};
  343.                             break;
  344.                         
  345.                         case (($ord_var_c & 0xE0) == 0xC0):
  346.                             // characters U-00000080 - U-000007FF, mask 110XXXXX
  347.                             // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  348.                             $char = pack('C*', $ord_var_c, ord($var{$c + 1}));
  349.                             $c += 1;
  350.                             $utf16 = $this->utf82utf16($char);
  351.                             $ascii .= sprintf('\u%04s', bin2hex($utf16));
  352.                             break;
  353.     
  354.                         case (($ord_var_c & 0xF0) == 0xE0):
  355.                             // characters U-00000800 - U-0000FFFF, mask 1110XXXX
  356.                             // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  357.                             $char = pack('C*', $ord_var_c,
  358.                                          ord($var{$c + 1}),
  359.                                          ord($var{$c + 2}));
  360.                             $c += 2;
  361.                             $utf16 = $this->utf82utf16($char);
  362.                             $ascii .= sprintf('\u%04s', bin2hex($utf16));
  363.                             break;
  364.     
  365.                         case (($ord_var_c & 0xF8) == 0xF0):
  366.                             // characters U-00010000 - U-001FFFFF, mask 11110XXX
  367.                             // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  368.                             $char = pack('C*', $ord_var_c,
  369.                                          ord($var{$c + 1}),
  370.                                          ord($var{$c + 2}),
  371.                                          ord($var{$c + 3}));
  372.                             $c += 3;
  373.                             $utf16 = $this->utf82utf16($char);
  374.                             $ascii .= sprintf('\u%04s', bin2hex($utf16));
  375.                             break;
  376.     
  377.                         case (($ord_var_c & 0xFC) == 0xF8):
  378.                             // characters U-00200000 - U-03FFFFFF, mask 111110XX
  379.                             // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  380.                             $char = pack('C*', $ord_var_c,
  381.                                          ord($var{$c + 1}),
  382.                                          ord($var{$c + 2}),
  383.                                          ord($var{$c + 3}),
  384.                                          ord($var{$c + 4}));
  385.                             $c += 4;
  386.                             $utf16 = $this->utf82utf16($char);
  387.                             $ascii .= sprintf('\u%04s', bin2hex($utf16));
  388.                             break;
  389.     
  390.                         case (($ord_var_c & 0xFE) == 0xFC):
  391.                             // characters U-04000000 - U-7FFFFFFF, mask 1111110X
  392.                             // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  393.                             $char = pack('C*', $ord_var_c,
  394.                                          ord($var{$c + 1}),
  395.                                          ord($var{$c + 2}),
  396.                                          ord($var{$c + 3}),
  397.                                          ord($var{$c + 4}),
  398.                                          ord($var{$c + 5}));
  399.                             $c += 5;
  400.                             $utf16 = $this->utf82utf16($char);
  401.                             $ascii .= sprintf('\u%04s', bin2hex($utf16));
  402.                             break;
  403.                     }
  404.                 }
  405.                 
  406.                 return '"'.$ascii.'"';
  407.                 
  408.             case 'array':
  409.                /*
  410.                 * As per JSON spec if any array key is not an integer
  411.                 * we must treat the the whole array as an object. We
  412.                 * also try to catch a sparsely populated associative
  413.                 * array with numeric keys here because some JS engines
  414.                 * will create an array with empty indexes up to
  415.                 * max_index which can cause memory issues and because
  416.                 * the keys, which may be relevant, will be remapped
  417.                 * otherwise.
  418.                 *
  419.                 * As per the ECMA and JSON specification an object may
  420.                 * have any string as a property. Unfortunately due to
  421.                 * a hole in the ECMA specification if the key is a
  422.                 * ECMA reserved word or starts with a digit the
  423.                 * parameter is only accessible using ECMAScript's
  424.                 * bracket notation.
  425.                 */
  426.                 
  427.                 // treat as a JSON object  
  428.                 if (is_array($var) && count($var) && (array_keys($var) !== range(0, sizeof($var) - 1))) {
  429.                     $properties = array_map(array($this, 'name_value'),
  430.                                             array_keys($var),
  431.                                             array_values($var));
  432.                 
  433.                     foreach($properties as $property)
  434.                         if(Services_JSON::isError($property))
  435.                             return $property;
  436.                     
  437.                     return '{' . join(',', $properties) . '}';
  438.                 }
  439.  
  440.                 // treat it like a regular array
  441.                 $elements = array_map(array($this, 'encode'), $var);
  442.                 
  443.                 foreach($elements as $element)
  444.                     if(Services_JSON::isError($element))
  445.                         return $element;
  446.                 
  447.                 return '[' . join(',', $elements) . ']';
  448.                 
  449.             case 'object':
  450.         if($var instanceof JsFunction || $var instanceof ClassTemplate || $var instanceof JsLitteral) // CFR
  451.             return $var; // CFR
  452.  
  453.                 $vars = get_object_vars($var);
  454.  
  455.                 $properties = array_map(array($this, 'name_value'),
  456.                                         array_keys($vars),
  457.                                         array_values($vars));
  458.             
  459.                 foreach($properties as $property)
  460.                     if(Services_JSON::isError($property))
  461.                         return $property;
  462.                 
  463.                 return '{' . join(',', $properties) . '}';
  464.  
  465.             default:
  466.                 return ($this->use & SERVICES_JSON_SUPPRESS_ERRORS)
  467.                     ? 'null'
  468.                     : new Services_JSON_Error(gettype($var)." can not be encoded as JSON string");
  469.         }
  470.     }
  471.     
  472.    /**
  473.     * array-walking function for use in generating JSON-formatted name-value pairs
  474.     *
  475.     * @param    string  $name   name of key to use
  476.     * @param    mixed   $value  reference to an array element to be encoded
  477.     *
  478.     * @return   string  JSON-formatted name-value pair, like '"name":value'
  479.     * @access   private
  480.     */
  481.     function name_value($name, $value)
  482.     {
  483.         $encoded_value = $this->encode($value);
  484.         
  485.         if(Services_JSON::isError($encoded_value))
  486.             return $encoded_value;
  487.     
  488.         return $this->encode(strval($name)) . ':' . $encoded_value;
  489.     }        
  490.  
  491.    /**
  492.     * reduce a string by removing leading and trailing comments and whitespace
  493.     *
  494.     * @param    $str    string      string value to strip of comments and whitespace
  495.     *
  496.     * @return   string  string value stripped of comments and whitespace
  497.     * @access   private
  498.     */
  499.     function reduce_string($str)
  500.     {
  501.         $str = preg_replace(array(
  502.         
  503.                 // eliminate single line comments in '// ...' form
  504.                 '#^\s*//(.+)$#m',
  505.     
  506.                 // eliminate multi-line comments in '/* ... */' form, at start of string
  507.                 '#^\s*/\*(.+)\*/#Us',
  508.     
  509.                 // eliminate multi-line comments in '/* ... */' form, at end of string
  510.                 '#/\*(.+)\*/\s*$#Us'
  511.     
  512.             ), '', $str);
  513.         
  514.         // eliminate extraneous space
  515.         return trim($str);
  516.     }
  517.  
  518.    /**
  519.     * decodes a JSON string into appropriate variable
  520.     *
  521.     * @param    string  $str    JSON-formatted string
  522.     *
  523.     * @return   mixed   number, boolean, string, array, or object
  524.     *                    corresponding to given JSON input string.
  525.     *                    See argument 1 to Services_JSON() above for object-output behavior.
  526.     *                    Note that decode() always returns strings
  527.     *                    in ASCII or UTF-8 format!
  528.     * @access   public
  529.     */
  530.     function decode($str)
  531.     {
  532.         $str = $this->reduce_string($str);
  533.     
  534.         switch (strtolower($str)) {
  535.             case 'true':
  536.                 return true;
  537.  
  538.             case 'false':
  539.                 return false;
  540.             
  541.             case 'null':
  542.                 return null;
  543.             
  544.             default:
  545.                 if (is_numeric($str)) {
  546.                     // Lookie-loo, it's a number
  547.  
  548.                     // This would work on its own, but I'm trying to be
  549.                     // good about returning integers where appropriate:
  550.                     // return (float)$str;
  551.  
  552.                     // Return float or int, as appropriate
  553.                     return ((float)$str == (integer)$str)
  554.                         ? (integer)$str
  555.                         : (float)$str;
  556.                     
  557.                 } elseif (preg_match('/^("|\').*(\1)$/s', $str, $m) && $m[1] == $m[2]) {
  558.                     // STRINGS RETURNED IN UTF-8 FORMAT
  559.                     $delim = substr($str, 0, 1);
  560.                     $chrs = substr($str, 1, -1);
  561.                     $utf8 = '';
  562.                     $strlen_chrs = strlen($chrs);
  563.                     
  564.                     for ($c = 0; $c < $strlen_chrs; ++$c) {
  565.                     
  566.                         $substr_chrs_c_2 = substr($chrs, $c, 2);
  567.                         $ord_chrs_c = ord($chrs{$c});
  568.                         
  569.                         switch (true) {
  570.                             case $substr_chrs_c_2 == '\b':
  571.                                 $utf8 .= chr(0x08);
  572.                                 ++$c;
  573.                                 break;
  574.                             case $substr_chrs_c_2 == '\t':
  575.                                 $utf8 .= chr(0x09);
  576.                                 ++$c;
  577.                                 break;
  578.                             case $substr_chrs_c_2 == '\n':
  579.                                 $utf8 .= chr(0x0A);
  580.                                 ++$c;
  581.                                 break;
  582.                             case $substr_chrs_c_2 == '\f':
  583.                                 $utf8 .= chr(0x0C);
  584.                                 ++$c;
  585.                                 break;
  586.                             case $substr_chrs_c_2 == '\r':
  587.                                 $utf8 .= chr(0x0D);
  588.                                 ++$c;
  589.                                 break;
  590.  
  591.                             case $substr_chrs_c_2 == '\\"':
  592.                             case $substr_chrs_c_2 == '\\\'':
  593.                             case $substr_chrs_c_2 == '\\\\':
  594.                             case $substr_chrs_c_2 == '\\/':
  595.                                 if (($delim == '"' && $substr_chrs_c_2 != '\\\'') ||
  596.                                    ($delim == "'" && $substr_chrs_c_2 != '\\"')) {
  597.                                     $utf8 .= $chrs{++$c};
  598.                                 }
  599.                                 break;
  600.                                 
  601.                             case preg_match('/\\\u[0-9A-F]{4}/i', substr($chrs, $c, 6)):
  602.                                 // single, escaped unicode character
  603.                                 $utf16 = chr(hexdec(substr($chrs, ($c + 2), 2)))
  604.                                        . chr(hexdec(substr($chrs, ($c + 4), 2)));
  605.                                 $utf8 .= $this->utf162utf8($utf16);
  606.                                 $c += 5;
  607.                                 break;
  608.         
  609.                             case ($ord_chrs_c >= 0x20) && ($ord_chrs_c <= 0x7F):
  610.                                 $utf8 .= $chrs{$c};
  611.                                 break;
  612.         
  613.                             case ($ord_chrs_c & 0xE0) == 0xC0:
  614.                                 // characters U-00000080 - U-000007FF, mask 110XXXXX
  615.                                 //see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  616.                                 $utf8 .= substr($chrs, $c, 2);
  617.                                 ++$c;
  618.                                 break;
  619.     
  620.                             case ($ord_chrs_c & 0xF0) == 0xE0:
  621.                                 // characters U-00000800 - U-0000FFFF, mask 1110XXXX
  622.                                 // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  623.                                 $utf8 .= substr($chrs, $c, 3);
  624.                                 $c += 2;
  625.                                 break;
  626.     
  627.                             case ($ord_chrs_c & 0xF8) == 0xF0:
  628.                                 // characters U-00010000 - U-001FFFFF, mask 11110XXX
  629.                                 // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  630.                                 $utf8 .= substr($chrs, $c, 4);
  631.                                 $c += 3;
  632.                                 break;
  633.     
  634.                             case ($ord_chrs_c & 0xFC) == 0xF8:
  635.                                 // characters U-00200000 - U-03FFFFFF, mask 111110XX
  636.                                 // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  637.                                 $utf8 .= substr($chrs, $c, 5);
  638.                                 $c += 4;
  639.                                 break;
  640.     
  641.                             case ($ord_chrs_c & 0xFE) == 0xFC:
  642.                                 // characters U-04000000 - U-7FFFFFFF, mask 1111110X
  643.                                 // see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
  644.                                 $utf8 .= substr($chrs, $c, 6);
  645.                                 $c += 5;
  646.                                 break;
  647.  
  648.                         }
  649.  
  650.                     }
  651.                     
  652.                     return $utf8;
  653.                 
  654.                 } elseif (preg_match('/^\[.*\]$/s', $str) || preg_match('/^\{.*\}$/s', $str)) {
  655.                     // array, or object notation
  656.  
  657.                     if ($str{0} == '[') {
  658.                         $stk = array(SERVICES_JSON_IN_ARR);
  659.                         $arr = array();
  660.                     } else {
  661.                         if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
  662.                             $stk = array(SERVICES_JSON_IN_OBJ);
  663.                             $obj = array();
  664.                         } else {
  665.                             $stk = array(SERVICES_JSON_IN_OBJ);
  666.                             $obj = new stdClass();
  667.                         }
  668.                     }
  669.                     
  670.                     array_push($stk, array('what'  => SERVICES_JSON_SLICE,
  671.                                            'where' => 0,
  672.                                            'delim' => false));
  673.  
  674.                     $chrs = substr($str, 1, -1);
  675.                     $chrs = $this->reduce_string($chrs);
  676.                     
  677.                     if ($chrs == '') {
  678.                         if (reset($stk) == SERVICES_JSON_IN_ARR) {
  679.                             return $arr;
  680.  
  681.                         } else {
  682.                             return $obj;
  683.  
  684.                         }
  685.                     }
  686.  
  687.                     //print("\nparsing {$chrs}\n");
  688.                     
  689.                     $strlen_chrs = strlen($chrs);
  690.                     
  691.                     for ($c = 0; $c <= $strlen_chrs; ++$c) {
  692.                     
  693.                         $top = end($stk);
  694.                         $substr_chrs_c_2 = substr($chrs, $c, 2);
  695.                     
  696.                         if (($c == $strlen_chrs) || (($chrs{$c} == ',') && ($top['what'] == SERVICES_JSON_SLICE))) {
  697.                             // found a comma that is not inside a string, array, etc.,
  698.                             // OR we've reached the end of the character list
  699.                             $slice = substr($chrs, $top['where'], ($c - $top['where']));
  700.                             array_push($stk, array('what' => SERVICES_JSON_SLICE, 'where' => ($c + 1), 'delim' => false));
  701.                             //print("Found split at {$c}: ".substr($chrs, $top['where'], (1 + $c - $top['where']))."\n");
  702.  
  703.                             if (reset($stk) == SERVICES_JSON_IN_ARR) {
  704.                                 // we are in an array, so just push an element onto the stack
  705.                                 array_push($arr, $this->decode($slice));
  706.  
  707.                             } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
  708.                                 // we are in an object, so figure
  709.                                 // out the property name and set an
  710.                                 // element in an associative array,
  711.                                 // for now
  712.                                 if (preg_match('/^\s*(["\'].*[^\\\]["\'])\s*:\s*(\S.*),?$/Uis', $slice, $parts)) {
  713.                                     // "name":value pair
  714.                                     $key = $this->decode($parts[1]);
  715.                                     $val = $this->decode($parts[2]);
  716.  
  717.                                     if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
  718.                                         $obj[$key] = $val;
  719.                                     } else {
  720.                                         $obj->$key = $val;
  721.                                     }
  722.                                 } elseif (preg_match('/^\s*(\w+)\s*:\s*(\S.*),?$/Uis', $slice, $parts)) {
  723.                                     // name:value pair, where name is unquoted
  724.                                     $key = $parts[1];
  725.                                     $val = $this->decode($parts[2]);
  726.  
  727.                                     if ($this->use & SERVICES_JSON_LOOSE_TYPE) {
  728.                                         $obj[$key] = $val;
  729.                                     } else {
  730.                                         $obj->$key = $val;
  731.                                     }
  732.                                 }
  733.  
  734.                             }
  735.  
  736.                         } elseif ((($chrs{$c} == '"') || ($chrs{$c} == "'")) && ($top['what'] != SERVICES_JSON_IN_STR)) {
  737.                             // found a quote, and we are not inside a string
  738.                             array_push($stk, array('what' => SERVICES_JSON_IN_STR, 'where' => $c, 'delim' => $chrs{$c}));
  739.                             //print("Found start of string at {$c}\n");
  740.  
  741.                         } elseif (($chrs{$c} == $top['delim']) &&
  742.                                  ($top['what'] == SERVICES_JSON_IN_STR) &&
  743.                                  (($chrs{$c - 1} != '\\') ||
  744.                                  ($chrs{$c - 1} == '\\' && $chrs{$c - 2} == '\\'))) {
  745.                             // found a quote, we're in a string, and it's not escaped
  746.                             array_pop($stk);
  747.                             //print("Found end of string at {$c}: ".substr($chrs, $top['where'], (1 + 1 + $c - $top['where']))."\n");
  748.  
  749.                         } elseif (($chrs{$c} == '[') &&
  750.                                  in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
  751.                             // found a left-bracket, and we are in an array, object, or slice
  752.                             array_push($stk, array('what' => SERVICES_JSON_IN_ARR, 'where' => $c, 'delim' => false));
  753.                             //print("Found start of array at {$c}\n");
  754.  
  755.                         } elseif (($chrs{$c} == ']') && ($top['what'] == SERVICES_JSON_IN_ARR)) {
  756.                             // found a right-bracket, and we're in an array
  757.                             array_pop($stk);
  758.                             //print("Found end of array at {$c}: ".substr($chrs, $top['where'], (1 + $c - $top['where']))."\n");
  759.  
  760.                         } elseif (($chrs{$c} == '{') &&
  761.                                  in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
  762.                             // found a left-brace, and we are in an array, object, or slice
  763.                             array_push($stk, array('what' => SERVICES_JSON_IN_OBJ, 'where' => $c, 'delim' => false));
  764.                             //print("Found start of object at {$c}\n");
  765.  
  766.                         } elseif (($chrs{$c} == '}') && ($top['what'] == SERVICES_JSON_IN_OBJ)) {
  767.                             // found a right-brace, and we're in an object
  768.                             array_pop($stk);
  769.                             //print("Found end of object at {$c}: ".substr($chrs, $top['where'], (1 + $c - $top['where']))."\n");
  770.  
  771.                         } elseif (($substr_chrs_c_2 == '/*') &&
  772.                                  in_array($top['what'], array(SERVICES_JSON_SLICE, SERVICES_JSON_IN_ARR, SERVICES_JSON_IN_OBJ))) {
  773.                             // found a comment start, and we are in an array, object, or slice
  774.                             array_push($stk, array('what' => SERVICES_JSON_IN_CMT, 'where' => $c, 'delim' => false));
  775.                             $c++;
  776.                             //print("Found start of comment at {$c}\n");
  777.  
  778.                         } elseif (($substr_chrs_c_2 == '*/') && ($top['what'] == SERVICES_JSON_IN_CMT)) {
  779.                             // found a comment end, and we're in one now
  780.                             array_pop($stk);
  781.                             $c++;
  782.                             
  783.                             for ($i = $top['where']; $i <= $c; ++$i)
  784.                                 $chrs = substr_replace($chrs, ' ', $i, 1);
  785.                             
  786.                             //print("Found end of comment at {$c}: ".substr($chrs, $top['where'], (1 + $c - $top['where']))."\n");
  787.  
  788.                         }
  789.                     
  790.                     }
  791.                     
  792.                     if (reset($stk) == SERVICES_JSON_IN_ARR) {
  793.                         return $arr;
  794.  
  795.                     } elseif (reset($stk) == SERVICES_JSON_IN_OBJ) {
  796.                         return $obj;
  797.  
  798.                     }
  799.                 
  800.                 }
  801.         }
  802.     }
  803.     
  804.     /**
  805.      * @todo Ultimately, this should just call PEAR::isError()
  806.      */
  807.     function isError($data, $code = null)
  808.     {
  809.         return (pcf_is_instance_of($date,'Service_JSON_Error'));
  810.     }
  811. }
  812.  
  813. class Services_JSON_Error
  814. {
  815.     function Services_JSON_Error($message = 'unknown error', $code = null,
  816.                                      $mode = null, $options = null, $userinfo = null)
  817.     {
  818.         
  819.     }
  820. }
  821.  
  822. ?>

Documentation generated on Thu, 08 Jan 2009 17:48:29 +0100 by phpDocumentor 1.4.0a2