professional-ajax-07-JSON-PHP-Examples-JSON.php / php
<?php
// +----------------------------------------------------------------------+
// | PHP version 4 |
// +----------------------------------------------------------------------+
// | Copyright (c) 2005 Michal Migurski |
// +----------------------------------------------------------------------+
// | This source file is subject to version 3.0 of the PHP license, |
// | that is bundled with this package in the file LICENSE, and is |
// | available through the world-wide-web at the following url: |
// | http://www.php.net/license/3_0.txt. |
// | If you did not receive a copy of the PHP license and are unable to |
// | obtain it through the world-wide-web, please send a note to |
// | license@php.net so we can mail you a copy immediately. |
// +----------------------------------------------------------------------+
// | Author: Michal Migurski, mike-json[at]teczno[dot]com |
// | with contributions from: |
// | Matt Knapp, mdknapp[at]gmail[dot]com |
// | Brett Stimmerman, brettstimmerman[at]gmail[dot]com |
// +----------------------------------------------------------------------+
//
//
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */
define('JSON_SLICE', 1);
define('JSON_IN_STR', 2);
define('JSON_IN_ARR', 4);
define('JSON_IN_OBJ', 8);
define('JSON_IN_CMT', 16);
define('JSON_LOOSE_TYPE', 10);
define('JSON_STRICT_TYPE', 11);
JSON Conversion to and from JSON format. See http://json.org for details. note all strings should be in ASCII or UTF-8 format!
class JSON
{
function JSON constructor
parameter: use int object behavior: when encoding or decoding, be loose or strict about object/array usage possible values: JSON_STRICT_TYPE - strict typing, default "{...}" syntax creates objects in decode JSON_LOOSE_TYPE - loose typing "{...}" syntax creates associative arrays in decode
function JSON(this->use = function encode encode an arbitrary variable into JSON format
parameter: var mixed any number, boolean, string, array, or object to be encoded. see argument 1 to JSON() above for array-parsing behavior. if var is a strng, note that encode() always expects it to be in ASCII or UTF-8 format!
returns: string JSON string representation of input var
function encode(var)
{
switch(gettype(var ? 'true' : 'false';
case 'NULL':
return 'null';
case 'integer':
return sprintf('\ %d', \ %f', var);
case 'string': // STRINGS ARE EXPECTED TO BE IN ASCII OR UTF-8 FORMAT
strlen_var = strlen(c = 0; strlen_var; ord_var_c = ord(c});
if(ascii .= '\b';
} elseif(ascii .= '\t';
} elseif(ascii .= '\n';
} elseif(ascii .= '\f';
} elseif(ascii .= '\r';
} elseif((ord_var_c == 0x2F) || (ascii .= '\\'.c}; // double quote, slash, slosh
} elseif((ord_var_c <= 0x7F)) {
// characters U-00000000 - U-0000007F (same as ASCII)
var{}; // most normal ASCII chars
} elseif((ord_var_c & 0xE0) == 0xC0) {
// characters U-00000080 - U-000007FF, mask 110XXXXX, see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
ord_var_c, ord(c+1})); ascii .= sprintf('\u%04s', bin2hex(mb_convert_encoding(ord_var_c & 0xF0) == 0xE0) {
// characters U-00000800 - U-0000FFFF, mask 1110XXXX, see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
ord_var_c, ord(c+1}), ord(c+2})); ascii .= sprintf('\u%04s', bin2hex(mb_convert_encoding(ord_var_c & 0xF8) == 0xF0) {
// characters U-00010000 - U-001FFFFF, mask 11110XXX, see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
ord_var_c, ord(c+1}), ord(c+2}), ord(c+3})); ascii .= sprintf('\u%04s', bin2hex(mb_convert_encoding(ord_var_c & 0xFC) == 0xF8) {
// characters U-00200000 - U-03FFFFFF, mask 111110XX, see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
ord_var_c, ord(c+1}), ord(c+2}), ord(c+3}), ord(c+4})); ascii .= sprintf('\u%04s', bin2hex(mb_convert_encoding(ord_var_c & 0xFE) == 0xFC) {
// characters U-04000000 - U-7FFFFFFF, mask 1111110X, see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
ord_var_c, ord(c+1}), ord(c+2}), ord(c+3}), ord(c+4}), ord(c+5})); ascii .= sprintf('\u%04s', bin2hex(mb_convert_encoding(\ %s"', ascii);
case 'array':
// As per JSON spec if any array key is not an integer we must treat the the whole array as an object.
// We also try to catch a sparsely populated associative array with numeric keys here because some JS
// engines will create an array with empty indexes up to max_index which can cause memory issues
// and because the keys, which may be relevant, will be remapped otherwise.
//
// As per the ECMA and JSON specification an object may have any string as a property. Unfortunately due to a
// hole in the ECMA specification if the key is a ECMA reserved word or starts with a digit the parameter is only
// accessible using ECMAScript's bracket notation.
// treat as a JSON object
if(is_array(var) !== range(0, sizeof(\ %s}', join(',', array_map(array(this, 'name_value'), array_keys(var))));
// treat it like a regular array
return sprintf('[\ %s]', join(',', array_map(array(var)));
case 'object':
var);
return sprintf('{\ %s}', join(',', array_map(array(vars), array_values(function enc alias for encode()
function enc(var)
{
return var);
}
function name_value array-walking function for use in generating JSON-formatted name-value pairs
parameter: name string name of key to use
parameter: value mixed reference to an array element to be encoded
returns: string JSON-formatted name-value pair, like '"name":value'
function name_value(value)
{
return (sprintf("\ %s:\ %s", name)), value)));
}
function reduce_string reduce a string by removing leading and trailing comments and whitespace
parameter: str string string value to strip of comments and whitespace
returns: string string value stripped of comments and whitespace
function reduce_string(str = preg_replace('#^\s*//(.+)str); // eliminate single line comments in '// ...' form
str); // eliminate multi-line comments in '/* ... */' form, at start of string
#Us', '', // eliminate multi-line comments in '/* ... */' form, at end of string
str = trim(// eliminate extraneous space
return str;
}
function decode decode a JSON string into appropriate variable
parameter: str string JSON-formatted string
returns: mixed number, boolean, string, array, or object corresponding to given JSON input string. see argument 1 to JSON() above for object-output behavior. note that decode() always returns strings in ASCII or UTF-8 format!
function decode(str = str);
switch(strtolower(str)) { // Lookie-loo, it's a number
// return (float)str == (integer)str
: (float)/s', /s', delim = substr(chrs = substr(utf8 = '';
chrs);
for(c < c++) {
chrs, ord_chrs_c = ord(c});
if(utf8 .= chr(0x08); substr_chrs_c_2 == '\t') {
c+=1;
} elseif(utf8 .= chr(0x0A); substr_chrs_c_2 == '\f') {
c+=1;
} elseif(utf8 .= chr(0x0D); delim == '"') && ((substr_chrs_c_2 == '\\\\') || (utf8 .= c};
} elseif((substr_chrs_c_2 == '\\\'') || (substr_chrs_c_2 == '\\/'))) {
chrs{++};
} elseif(preg_match('/\\\u[0-9A-F]{4}/i', substr(chrs, utf16 = chr(hexdec(substr(c+2), 2))) . chr(hexdec(substr(c+4), 2)));
utf16, 'UTF-8', 'UTF-16');
ord_chrs_c >= 0x20) && (utf8 .= c};
} elseif((utf8 .= substr(c, 2); ord_chrs_c & 0xF0) == 0xE0) {
// characters U-00000800 - U-0000FFFF, mask 1110XXXX, see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
chrs, c += 2;
} elseif((utf8 .= substr(c, 4); ord_chrs_c & 0xFC) == 0xF8) {
// characters U-00200000 - U-03FFFFFF, mask 111110XX, see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8
chrs, c += 4;
} elseif((utf8 .= substr(c, 6); utf8;
} elseif(preg_match('/^\[.*\]str) || preg_match('/^{.*}str)) { // array, or object notation
if(stk = array(JSON_IN_ARR);
this->use == JSON_LOOSE_TYPE) {
obj = array();
} else {
obj = new ObjectFromJSON();
}
}
array_push(chrs = substr(chrs = chrs);
if(stk) == JSON_IN_ARR) {
return obj;
}
}
//print("\nparsing {strlen_chrs = strlen(c = 0; strlen_chrs; top = end(substr_chrs_c_2 = substr(c, 2);
if((strlen_chrs) || ((c} == ',') && (slice = substr(top['where'], (top['where']));
array_push(c + 1), 'delim' => false));
//print("Found split at {chrs, c - stk) == JSON_IN_ARR) { // we are in an array, so just push an element onto the stack
array_push(this->decode(stk) == JSON_IN_OBJ) { // we are in an object, so figure out the property name and set an element in an associative array, for now
if(preg_match('/^\s*(["\'].*[^\\\]["\'])\s*:\s*(\S.*),?slice, key = parts[1]);
this->decode(this->use == JSON_LOOSE_TYPE) {
key] = obj->val;
}
} elseif(preg_match('/^\s*(\w+)\s*:\s*(\S.*),?slice, key = val = parts[2]);
if(obj[val;
} else {
key = chrs{chrs{top['what'] != JSON_IN_STR)) { // found a quote, and we are not inside a string
array_push(c, 'delim' => c}));
//print("Found start of string at {chrs{top['delim']) && (chrs{chrs{chrs{stk);
//print("Found end of string at {chrs, c - chrs{top['what'], array(JSON_SLICE, JSON_IN_ARR, JSON_IN_OBJ))) { // found a left-bracket, and we are in an array, object, or slice
array_push(c, 'delim' => false));
//print("Found start of array at {chrs{top['what'] == JSON_IN_ARR)) { // found a right-bracket, and we're in an array
array_pop(c}: ".substr(top['where'], (1 + top['where']))."\n");
} elseif((c} == '{') && in_array(stk, array('what' => JSON_IN_OBJ, 'where' => c}\n");
} elseif((c} == '}') && (stk);
//print("Found end of object at {chrs, c - substr_chrs_c_2 == '/*') && in_array(stk, array('what' => JSON_IN_CMT, 'where' => c++;
//print("Found start of comment at {substr_chrs_c_2 == '*/') && (// found a comment end, and we're in one now
array_pop(stk);
i = i <= i++)
chrs, ' ', c}: ".substr(top['where'], (1 + top['where']))."\n");
}
}
if(reset(arr;
} elseif(reset(obj;
}
}
}
}
function dec alias for decode()
function dec(this->decode(ObjectFromJSON Generic object wrapper, used in object returns from decode()
class ObjectFromJSON { function ObjectFromJSON() {} }
?>
(C) Æliens 20/2/2008
You may not copy or print any of this material without explicit permission of the author or the publisher. In case of other copyright issues, contact the author.
