// create a new instance of Services_JSON

 	$json = new Services_JSON();

 	// convert a complexe value to JSON notation, and send it to the browser

 	$value = array('foo', 'bar', array(1, 2, 'baz'), array(3, array(4)));

 	$output = $json->encode($value);

 	print($output);

 	// prints: ["foo","bar",[1,2,"baz"],[3,[4]]]

 	// accept incoming POST data, assumed to be in JSON notation

 	$input = file_get_contents('php://input', 1000000);

 	$value = $json->decode($input);

 	</code>

 	/**

		* constructs a new JSON instance

		*

		* @param    int     $use    object behavior flags; combine with boolean-OR

		*

		*                           possible values:

		*                           - SERVICES_JSON_LOOSE_TYPE:  loose typing.

		*                                   "{...}" syntax creates associative arrays

		*                                   instead of objects in decode().

		*                           - SERVICES_JSON_SUPPRESS_ERRORS:  error suppression.

		*                                   Values which can't be encoded (e.g. resources)

		*                                   appear as NULL instead of throwing errors.

		*                                   By default, a deeply-nested resource will

		*                                   bubble up with an error, so all return values

		*                                   from encode() should be checked with isError()

		*/

		function Services_JSON($use = 0)

		{

				$this->use = $use;

		}

 	/**

		* convert a string from one UTF-16 char to one UTF-8 char

		*

		* Normally should be handled by mb_convert_encoding, but

		* provides a slower PHP-only method for installations

		* that lack the multibye string extension.

		*

		* @param    string  $utf16  UTF-16 character

		* @return   string  UTF-8 character

		* @access   private

		*/

		function utf162utf8($utf16)

		{

				// oh please oh please oh please oh please oh please

				if(function_exists('mb_convert_encoding')) {

						return mb_convert_encoding($utf16, 'UTF-8', 'UTF-16');

				}

				$bytes = (ord($utf16{0}) << 8) | ord($utf16{1});

				switch(true) {

						case ((0x7F & $bytes) == $bytes):

								// this case should never be reached, because we are in ASCII range

								// see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8

								return chr(0x7F & $bytes);

						case (0x07FF & $bytes) == $bytes:

								// return a 2-byte UTF-8 character

								// see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8

								return chr(0xC0 | (($bytes >> 6) & 0x1F))

 										. chr(0x80 | ($bytes & 0x3F));

						case (0xFFFF & $bytes) == $bytes:

								// return a 3-byte UTF-8 character

								// see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8

								return chr(0xE0 | (($bytes >> 12) & 0x0F))

 										. chr(0x80 | (($bytes >> 6) & 0x3F))

 										. chr(0x80 | ($bytes & 0x3F));

				}

				// ignoring UTF-32 for now, sorry

				return '';

		}

 	/**

		* convert a string from one UTF-8 char to one UTF-16 char

		*

		* Normally should be handled by mb_convert_encoding, but

		* provides a slower PHP-only method for installations

		* that lack the multibye string extension.

		*

		* @param    string  $utf8   UTF-8 character

		* @return   string  UTF-16 character

		* @access   private

		*/

		function utf82utf16($utf8)

		{

				// oh please oh please oh please oh please oh please

				if(function_exists('mb_convert_encoding')) {

						return mb_convert_encoding($utf8, 'UTF-16', 'UTF-8');

				}

				switch(strlen($utf8)) {

						case 1:

								// this case should never be reached, because we are in ASCII range

								// see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8

								return $utf8;

						case 2:

								// return a UTF-16 character from a 2-byte UTF-8 char

								// see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8

								return chr(0x07 & (ord($utf8{0}) >> 2))

 										. chr((0xC0 & (ord($utf8{0}) << 6))

 												| (0x3F & ord($utf8{1})));

						case 3:

								// return a UTF-16 character from a 3-byte UTF-8 char

								// see: http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8

								return chr((0xF0 & (ord($utf8{0}) << 4))

 												| (0x0F & (ord($utf8{1}) >> 2)))

 										. chr((0xC0 & (ord($utf8{1}) << 6))

 												| (0x7F & ord($utf8{2})));

				}

				// ignoring UTF-32 for now, sorry

				return '';

		}

 	/**

		* encodes an arbitrary variable into JSON format

		*

		* @param    mixed   $var    any number, boolean, string, array, or object to be encoded.

		*                           see argument 1 to Services_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!

		*

		* @return   mixed   JSON string representation of input var or an error if a problem occurs

		* @access   public

		*/

		function encode($var)

		{

				switch (gettype($var)) {

						case 'boolean':

								return $var ? 'true' : 'false';

						case 'NULL':

								return 'null';

						case 'integer':

								return (int) $var;

						case 'double':

						case 'float':

								return (float) $var;

						case 'string':

								// STRINGS ARE EXPECTED TO BE IN ASCII OR UTF-8 FORMAT

								$ascii = '';

								$strlen_var = strlen($var);

 							/*

								* Iterate over every character in the string,

								* escaping with a slash or encoding to UTF-8 where necessary

								*/

								for ($c = 0; $c < $strlen_var; ++$c) {

										$ord_var_c = ord($var{$c});

										switch (true) {

												case $ord_var_c == 0x08:

														$ascii .= '\b';

														break;

												case $ord_var_c == 0x09:

														$ascii .= '\t';

														break;

												case $ord_var_c == 0x0A:

														$ascii .= '\n';

														break;

												case $ord_var_c == 0x0C:

														$ascii .= '\f';

														break;

												case $ord_var_c == 0x0D:

														$ascii .= '\r';

														break;

												case $ord_var_c == 0x22:

												case $ord_var_c == 0x2F:

												case $ord_var_c == 0x5C:

														// double quote, slash, slosh

														$ascii .= '\\'.$var{$c};

														break;

												case (($ord_var_c >= 0x20) && ($ord_var_c <= 0x7F)):

														// characters U-00000000 - U-0000007F (same as ASCII)

														$ascii .= $var{$c};

														break;

												case (($ord_var_c & 0xE0) == 0xC0):

														// characters U-00000080 - U-000007FF, mask 110XXXXX

														// see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8

														$char = pack('C*', $ord_var_c, ord($var{$c + 1}));

														$c += 1;

														$utf16 = $this->utf82utf16($char);

														$ascii .= sprintf('\u%04s', bin2hex($utf16));

														break;

												case (($ord_var_c & 0xF0) == 0xE0):

														// characters U-00000800 - U-0000FFFF, mask 1110XXXX

														// see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8

														$char = pack('C*', $ord_var_c,

 																				ord($var{$c + 1}),

 																				ord($var{$c + 2}));

														$c += 2;

														$utf16 = $this->utf82utf16($char);

														$ascii .= sprintf('\u%04s', bin2hex($utf16));

														break;

												case (($ord_var_c & 0xF8) == 0xF0):

														// characters U-00010000 - U-001FFFFF, mask 11110XXX

														// see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8

														$char = pack('C*', $ord_var_c,

 																				ord($var{$c + 1}),

 																				ord($var{$c + 2}),

 																				ord($var{$c + 3}));

														$c += 3;

														$utf16 = $this->utf82utf16($char);

														$ascii .= sprintf('\u%04s', bin2hex($utf16));

														break;

												case (($ord_var_c & 0xFC) == 0xF8):

														// characters U-00200000 - U-03FFFFFF, mask 111110XX

														// see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8

														$char = pack('C*', $ord_var_c,

 																				ord($var{$c + 1}),

 																				ord($var{$c + 2}),

 																				ord($var{$c + 3}),

 																				ord($var{$c + 4}));

														$c += 4;

														$utf16 = $this->utf82utf16($char);

														$ascii .= sprintf('\u%04s', bin2hex($utf16));

														break;

												case (($ord_var_c & 0xFE) == 0xFC):

														// characters U-04000000 - U-7FFFFFFF, mask 1111110X

														// see http://www.cl.cam.ac.uk/~mgk25/unicode.html#utf-8

														$char = pack('C*', $ord_var_c,

 																				ord($var{$c + 1}),

 																				ord($var{$c + 2}),

 																				ord($var{$c + 3}),

 																				ord($var{$c + 4}),

 																				ord($var{$c + 5}));

														$c += 5;

														$utf16 = $this->utf82utf16($char);

														$ascii .= sprintf('\u%04s', bin2hex($utf16));

														break;

										}

								}

								return '"'.$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) && count($var) && (array_keys($var) !== range(0, sizeof($var) - 1))) {

										$properties = array_map(array($this, 'name_value'),

																						array_keys($var),

																						array_values($var));

										foreach($properties as $property) {

												if(Services_JSON::isError($property)) {

														return $property;

												}

										}

										return '{' . join(',', $properties) . '}';

								}

								// treat it like a regular array

								$elements = array_map(array($this, 'encode'), $var);

								foreach($elements as $element) {

										if(Services_JSON::isError($element)) {

												return $element;

										}

								}

								return '[' . join(',', $elements) . ']';

						case 'object':

								$vars = get_object_vars($var);

								$properties = array_map(array($this, 'name_value'),

																				array_keys($vars),

																				array_values($vars));

								foreach($properties as $property) {

										if(Services_JSON::isError($property)) {

												return $property;

										}

								}

								return '{' . join(',', $properties) . '}';

						default:

								return ($this->use & SERVICES_JSON_SUPPRESS_ERRORS)

										? 'null'

										: new Services_JSON_Error(gettype($var)." can not be encoded as JSON string");

				}

		}

 	/**

		* array-walking function for use in generating JSON-formatted name-value pairs

		*

		* @param    string  $name   name of key to use

		* @param    mixed   $value  reference to an array element to be encoded

		*

		* @return   string  JSON-formatted name-value pair, like '"name":value'

		* @access   private

		*/

		function name_value($name, $value)

		{

				$encoded_value = $this->encode($value);

				if(Services_JSON::isError($encoded_value)) {

						return $encoded_value;

				}

				return $this->encode(strval($name)) . ':' . $encoded_value;

		}

 	/**

		* reduce a string by removing leading and trailing comments and whitespace

		*

		* @param    $str    string      string value to strip of comments and whitespace

		*

		* @return   string  string value stripped of comments and whitespace

		* @access   private

		*/

		function reduce_string($str)

		{

				$str = preg_replace(array(

								// eliminate single line comments in '// ...' form

								'#^\s*//(.+)$#m',

								// eliminate multi-line comments in '/* ... */' form, at start of string

								'#^\s*/\*(.+)\*/#Us',

								// eliminate multi-line comments in '/* ... */' form, at end of string

								'#/\*(.+)\*/\s*$#Us'

						), '', $str);

				// eliminate extraneous space

				return trim($str);

		}

 	/**

		* decodes a JSON string into appropriate variable

		*

		* @param    string  $str    JSON-formatted string

		*

		* @return   mixed   number, boolean, string, array, or object

		*                   corresponding to given JSON input string.

		*                   See argument 1 to Services_JSON() above for object-output behavior.

		*                   Note that decode() always returns strings

		*                   in ASCII or UTF-8 format!

		* @access   public

		*/

		function decode($str)

		{

				$str = $this->reduce_string($str);

				switch (strtolower($str)) {

						case 'true':

								return true;

						case 'false':

								return false;

						case 'null':

								return null;

						default:

								$m = array();