[Summary view] [Print] [Text view]

   1  <?php
   2  /**
   3   * $Id: JSON.php 40 2007-06-18 11:43:15Z spocke $
   4   *
   5   * @package MCManager.utils
   6   * @author Moxiecode
   7   * @copyright Copyright © 2007, Moxiecode Systems AB, All rights reserved.
   8   */
   9  
  10  define('JSON_BOOL', 1);
  11  define('JSON_INT', 2);
  12  define('JSON_STR', 3);
  13  define('JSON_FLOAT', 4);
  14  define('JSON_NULL', 5);
  15  define('JSON_START_OBJ', 6);
  16  define('JSON_END_OBJ', 7);
  17  define('JSON_START_ARRAY', 8);
  18  define('JSON_END_ARRAY', 9);
  19  define('JSON_KEY', 10);
  20  define('JSON_SKIP', 11);
  21  
  22  define('JSON_IN_ARRAY', 30);
  23  define('JSON_IN_OBJECT', 40);
  24  define('JSON_IN_BETWEEN', 50);
  25  
  26  class Moxiecode_JSONReader {
  27      var $_data, $_len, $_pos;
  28      var $_value, $_token;
  29      var $_location, $_lastLocations;
  30      var $_needProp;
  31  
  32  	function Moxiecode_JSONReader($data) {
  33          $this->_data = $data;
  34          $this->_len = strlen($data);
  35          $this->_pos = -1;
  36          $this->_location = JSON_IN_BETWEEN;
  37          $this->_lastLocations = array();
  38          $this->_needProp = false;
  39      }
  40  
  41  	function getToken() {
  42          return $this->_token;
  43      }
  44  
  45  	function getLocation() {
  46          return $this->_location;
  47      }
  48  
  49  	function getTokenName() {
  50          switch ($this->_token) {
  51              case JSON_BOOL:
  52                  return 'JSON_BOOL';
  53  
  54              case JSON_INT:
  55                  return 'JSON_INT';
  56  
  57              case JSON_STR:
  58                  return 'JSON_STR';
  59  
  60              case JSON_FLOAT:
  61                  return 'JSON_FLOAT';
  62  
  63              case JSON_NULL:
  64                  return 'JSON_NULL';
  65  
  66              case JSON_START_OBJ:
  67                  return 'JSON_START_OBJ';
  68  
  69              case JSON_END_OBJ:
  70                  return 'JSON_END_OBJ';
  71  
  72              case JSON_START_ARRAY:
  73                  return 'JSON_START_ARRAY';
  74  
  75              case JSON_END_ARRAY:
  76                  return 'JSON_END_ARRAY';
  77  
  78              case JSON_KEY:
  79                  return 'JSON_KEY';
  80          }
  81  
  82          return 'UNKNOWN';
  83      }
  84  
  85  	function getValue() {
  86          return $this->_value;
  87      }
  88  
  89  	function readToken() {
  90          $chr = $this->read();
  91  
  92          if ($chr != null) {
  93              switch ($chr) {
  94                  case '[':
  95                      $this->_lastLocation[] = $this->_location;
  96                      $this->_location = JSON_IN_ARRAY;
  97                      $this->_token = JSON_START_ARRAY;
  98                      $this->_value = null;
  99                      $this->readAway();
 100                      return true;
 101  
 102                  case ']':
 103                      $this->_location = array_pop($this->_lastLocation);
 104                      $this->_token = JSON_END_ARRAY;
 105                      $this->_value = null;
 106                      $this->readAway();
 107  
 108                      if ($this->_location == JSON_IN_OBJECT)
 109                          $this->_needProp = true;
 110  
 111                      return true;
 112  
 113                  case '{':
 114                      $this->_lastLocation[] = $this->_location;
 115                      $this->_location = JSON_IN_OBJECT;
 116                      $this->_needProp = true;
 117                      $this->_token = JSON_START_OBJ;
 118                      $this->_value = null;
 119                      $this->readAway();
 120                      return true;
 121  
 122                  case '}':
 123                      $this->_location = array_pop($this->_lastLocation);
 124                      $this->_token = JSON_END_OBJ;
 125                      $this->_value = null;
 126                      $this->readAway();
 127  
 128                      if ($this->_location == JSON_IN_OBJECT)
 129                          $this->_needProp = true;
 130  
 131                      return true;
 132  
 133                  // String
 134                  case '"':
 135                  case '\'':
 136                      return $this->_readString($chr);
 137  
 138                  // Null
 139                  case 'n':
 140                      return $this->_readNull();
 141  
 142                  // Bool
 143                  case 't':
 144                  case 'f':
 145                      return $this->_readBool($chr);
 146  
 147                  default:
 148                      // Is number
 149                      if (is_numeric($chr) || $chr == '-' || $chr == '.')
 150                          return $this->_readNumber($chr);
 151  
 152                      return true;
 153              }
 154          }
 155  
 156          return false;
 157      }
 158  
 159  	function _readBool($chr) {
 160          $this->_token = JSON_BOOL;
 161          $this->_value = $chr == 't';
 162  
 163          if ($chr == 't')
 164              $this->skip(3); // rue
 165          else
 166              $this->skip(4); // alse
 167  
 168          $this->readAway();
 169  
 170          if ($this->_location == JSON_IN_OBJECT && !$this->_needProp)
 171              $this->_needProp = true;
 172  
 173          return true;
 174      }
 175  
 176  	function _readNull() {
 177          $this->_token = JSON_NULL;
 178          $this->_value = null;
 179  
 180          $this->skip(3); // ull
 181          $this->readAway();
 182  
 183          if ($this->_location == JSON_IN_OBJECT && !$this->_needProp)
 184              $this->_needProp = true;
 185  
 186          return true;
 187      }
 188  
 189  	function _readString($quote) {
 190          $output = "";
 191          $this->_token = JSON_STR;
 192          $endString = false;
 193  
 194          while (($chr = $this->peek()) != -1) {
 195              switch ($chr) {
 196                  case '\\':
 197                      // Read away slash
 198                      $this->read();
 199  
 200                      // Read escape code
 201                      $chr = $this->read();
 202                      switch ($chr) {
 203                              case 't':
 204                                  $output .= "\t";
 205                                  break;
 206  
 207                              case 'b':
 208                                  $output .= "\b";
 209                                  break;
 210  
 211                              case 'f':
 212                                  $output .= "\f";
 213                                  break;
 214  
 215                              case 'r':
 216                                  $output .= "\r";
 217                                  break;
 218  
 219                              case 'n':
 220                                  $output .= "\n";
 221                                  break;
 222  
 223                              case 'u':
 224                                  $output .= $this->_int2utf8(hexdec($this->read(4)));
 225                                  break;
 226  
 227                              default:
 228                                  $output .= $chr;
 229                                  break;
 230                      }
 231  
 232                      break;
 233  
 234                      case '\'':
 235                      case '"':
 236                          if ($chr == $quote)
 237                              $endString = true;
 238  
 239                          $chr = $this->read();
 240                          if ($chr != -1 && $chr != $quote)
 241                              $output .= $chr;
 242  
 243                          break;
 244  
 245                      default:
 246                          $output .= $this->read();
 247              }
 248  
 249              // String terminated
 250              if ($endString)
 251                  break;
 252          }
 253  
 254          $this->readAway();
 255          $this->_value = $output;
 256  
 257          // Needed a property
 258          if ($this->_needProp) {
 259              $this->_token = JSON_KEY;
 260              $this->_needProp = false;
 261              return true;
 262          }
 263  
 264          if ($this->_location == JSON_IN_OBJECT && !$this->_needProp)
 265              $this->_needProp = true;
 266  
 267          return true;
 268      }
 269  
 270  	function _int2utf8($int) {
 271          $int = intval($int);
 272  
 273          switch ($int) {
 274              case 0:
 275                  return chr(0);
 276  
 277              case ($int & 0x7F):
 278                  return chr($int);
 279  
 280              case ($int & 0x7FF):
 281                  return chr(0xC0 | (($int >> 6) & 0x1F)) . chr(0x80 | ($int & 0x3F));
 282  
 283              case ($int & 0xFFFF):
 284                  return chr(0xE0 | (($int >> 12) & 0x0F)) . chr(0x80 | (($int >> 6) & 0x3F)) . chr (0x80 | ($int & 0x3F));
 285  
 286              case ($int & 0x1FFFFF):
 287                  return chr(0xF0 | ($int >> 18)) . chr(0x80 | (($int >> 12) & 0x3F)) . chr(0x80 | (($int >> 6) & 0x3F)) . chr(0x80 | ($int & 0x3F));
 288          }
 289      }
 290  
 291  	function _readNumber($start) {
 292          $value = "";
 293          $isFloat = false;
 294  
 295          $this->_token = JSON_INT;
 296          $value .= $start;
 297  
 298          while (($chr = $this->peek()) != -1) {
 299              if (is_numeric($chr) || $chr == '-' || $chr == '.') {
 300                  if ($chr == '.')
 301                      $isFloat = true;
 302  
 303                  $value .= $this->read();
 304              } else
 305                  break;
 306          }
 307  
 308          $this->readAway();
 309  
 310          if ($isFloat) {
 311              $this->_token = JSON_FLOAT;
 312              $this->_value = floatval($value);
 313          } else
 314              $this->_value = intval($value);
 315  
 316          if ($this->_location == JSON_IN_OBJECT && !$this->_needProp)
 317              $this->_needProp = true;
 318  
 319          return true;
 320      }
 321  
 322  	function readAway() {
 323          while (($chr = $this->peek()) != null) {
 324              if ($chr != ':' && $chr != ',' && $chr != ' ')
 325                  return;
 326  
 327              $this->read();
 328          }
 329      }
 330  
 331  	function read($len = 1) {
 332          if ($this->_pos < $this->_len) {
 333              if ($len > 1) {
 334                  $str = substr($this->_data, $this->_pos + 1, $len);
 335                  $this->_pos += $len;
 336  
 337                  return $str;
 338              } else
 339                  return $this->_data[++$this->_pos];
 340          }
 341  
 342          return null;
 343      }
 344  
 345  	function skip($len) {
 346          $this->_pos += $len;
 347      }
 348  
 349  	function peek() {
 350          if ($this->_pos < $this->_len)
 351              return $this->_data[$this->_pos + 1];
 352  
 353          return null;
 354      }
 355  }
 356  
 357  /**
 358   * This class handles JSON stuff.
 359   *
 360   * @package MCManager.utils
 361   */
 362  class Moxiecode_JSON {
 363  	function Moxiecode_JSON() {
 364      }
 365  
 366  	function decode($input) {
 367          $reader = new Moxiecode_JSONReader($input);
 368  
 369          return $this->readValue($reader);
 370      }
 371  
 372  	function readValue(&$reader) {
 373          $this->data = array();
 374          $this->parents = array();
 375          $this->cur =& $this->data;
 376          $key = null;
 377          $loc = JSON_IN_ARRAY;
 378  
 379          while ($reader->readToken()) {
 380              switch ($reader->getToken()) {
 381                  case JSON_STR:
 382                  case JSON_INT:
 383                  case JSON_BOOL:
 384                  case JSON_FLOAT:
 385                  case JSON_NULL:
 386                      switch ($reader->getLocation()) {
 387                          case JSON_IN_OBJECT:
 388                              $this->cur[$key] = $reader->getValue();
 389                              break;
 390  
 391                          case JSON_IN_ARRAY:
 392                              $this->cur[] = $reader->getValue();
 393                              break;
 394  
 395                          default:
 396                              return $reader->getValue();
 397                      }
 398                      break;
 399  
 400                  case JSON_KEY:
 401                      $key = $reader->getValue();
 402                      break;
 403  
 404                  case JSON_START_OBJ:
 405                  case JSON_START_ARRAY:
 406                      if ($loc == JSON_IN_OBJECT)
 407                          $this->addArray($key);
 408                      else
 409                          $this->addArray(null);
 410  
 411                      $cur =& $obj;
 412  
 413                      $loc = $reader->getLocation();
 414                      break;
 415  
 416                  case JSON_END_OBJ:
 417                  case JSON_END_ARRAY:
 418                      $loc = $reader->getLocation();
 419  
 420                      if (count($this->parents) > 0) {
 421                          $this->cur =& $this->parents[count($this->parents) - 1];
 422                          array_pop($this->parents);
 423                      }
 424                      break;
 425              }
 426          }
 427  
 428          return $this->data[0];
 429      }
 430  
 431      // This method was needed since PHP is crapy and doesn't have pointers/references
 432  	function addArray($key) {
 433          $this->parents[] =& $this->cur;
 434          $ar = array();
 435  
 436          if ($key)
 437              $this->cur[$key] =& $ar;
 438          else
 439              $this->cur[] =& $ar;
 440  
 441          $this->cur =& $ar;
 442      }
 443  
 444  	function getDelim($index, &$reader) {
 445          switch ($reader->getLocation()) {
 446              case JSON_IN_ARRAY:
 447              case JSON_IN_OBJECT:
 448                  if ($index > 0)
 449                      return ",";
 450                  break;
 451          }
 452  
 453          return "";
 454      }
 455  
 456  	function encode($input) {
 457          switch (gettype($input)) {
 458              case 'boolean':
 459                  return $input ? 'true' : 'false';
 460  
 461              case 'integer':
 462                  return (int) $input;
 463  
 464              case 'float':
 465              case 'double':
 466                  return (float) $input;
 467  
 468              case 'NULL':
 469                  return 'null';
 470  
 471              case 'string':
 472                  return $this->encodeString($input);
 473  
 474              case 'array':
 475                  return $this->_encodeArray($input);
 476  
 477              case 'object':
 478                  return $this->_encodeArray(get_object_vars($input));
 479          }
 480  
 481          return '';
 482      }
 483  
 484  	function encodeString($input) {
 485          // Needs to be escaped
 486          if (preg_match('/[^a-zA-Z0-9]/', $input)) {
 487              $output = '';
 488  
 489              for ($i=0; $i<strlen($input); $i++) {
 490                  switch ($input[$i]) {
 491                      case "\b":
 492                          $output .= "\\b";
 493                          break;
 494  
 495                      case "\t":
 496                          $output .= "\\t";
 497                          break;
 498  
 499                      case "\f":
 500                          $output .= "\\f";
 501                          break;
 502  
 503                      case "\r":
 504                          $output .= "\\r";
 505                          break;
 506  
 507                      case "\n":
 508                          $output .= "\\n";
 509                          break;
 510  
 511                      case '\\':
 512                          $output .= "\\\\";
 513                          break;
 514  
 515                      case '\'':
 516                          $output .= "\\'";
 517                          break;
 518  
 519                      case '"':
 520                          $output .= '\"';
 521                          break;
 522  
 523                      default:
 524                          $byte = ord($input[$i]);
 525  
 526                          if (($byte & 0xE0) == 0xC0) {
 527                              $char = pack('C*', $byte, ord($input[$i + 1]));
 528                              $i += 1;
 529                              $output .= sprintf('\u%04s', bin2hex($this->_utf82utf16($char)));
 530                          } if (($byte & 0xF0) == 0xE0) {
 531                              $char = pack('C*', $byte, ord($input[$i + 1]), ord($input[$i + 2]));
 532                              $i += 2;
 533                              $output .= sprintf('\u%04s', bin2hex($this->_utf82utf16($char)));
 534                          } if (($byte & 0xF8) == 0xF0) {
 535                              $char = pack('C*', $byte, ord($input[$i + 1]), ord($input[$i + 2]), ord($input[$i + 3]));
 536                              $i += 3;
 537                              $output .= sprintf('\u%04s', bin2hex($this->_utf82utf16($char)));
 538                          } if (($byte & 0xFC) == 0xF8) {
 539                              $char = pack('C*', $byte, ord($input[$i + 1]), ord($input[$i + 2]), ord($input[$i + 3]), ord($input[$i + 4]));
 540                              $i += 4;
 541                              $output .= sprintf('\u%04s', bin2hex($this->_utf82utf16($char)));
 542                          } if (($byte & 0xFE) == 0xFC) {
 543                              $char = pack('C*', $byte, ord($input[$i + 1]), ord($input[$i + 2]), ord($input[$i + 3]), ord($input[$i + 4]), ord($input[$i + 5]));
 544                              $i += 5;
 545                              $output .= sprintf('\u%04s', bin2hex($this->_utf82utf16($char)));
 546                          } else if ($byte < 128)
 547                              $output .= $input[$i];
 548                  }
 549              }
 550  
 551              return '"' . $output . '"';
 552          }
 553  
 554          return '"' . $input . '"';
 555      }
 556  
 557  	function _utf82utf16($utf8) {
 558          if (function_exists('mb_convert_encoding'))
 559              return mb_convert_encoding($utf8, 'UTF-16', 'UTF-8');
 560  
 561          switch (strlen($utf8)) {
 562              case 1:
 563                  return $utf8;
 564  
 565              case 2:
 566                  return chr(0x07 & (ord($utf8[0]) >> 2)) . chr((0xC0 & (ord($utf8[0]) << 6)) | (0x3F & ord($utf8[1])));
 567  
 568              case 3:
 569                  return chr((0xF0 & (ord($utf8[0]) << 4)) | (0x0F & (ord($utf8[1]) >> 2))) . chr((0xC0 & (ord($utf8[1]) << 6)) | (0x7F & ord($utf8[2])));
 570          }
 571  
 572          return '';
 573      }
 574  
 575  	function _encodeArray($input) {
 576          $output = '';
 577          $isIndexed = true;
 578  
 579          $keys = array_keys($input);
 580          for ($i=0; $i<count($keys); $i++) {
 581              if (!is_int($keys[$i])) {
 582                  $output .= $this->encodeString($keys[$i]) . ':' . $this->encode($input[$keys[$i]]);
 583                  $isIndexed = false;
 584              } else
 585                  $output .= $this->encode($input[$keys[$i]]);
 586  
 587              if ($i != count($keys) - 1)
 588                  $output .= ',';
 589          }
 590  
 591          return $isIndexed ? '[' . $output . ']' : '{' . $output . '}';
 592      }
 593  }
 594  
 595  ?>