|
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 ?> |