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