<?php

/**

 * Zend Framework

 *

 * LICENSE

 *

 * This source file is subject to the new BSD license that is bundled

 * with this package in the file licenses/bsdlic.html.

 * It is also available through the world-wide-web at this URL:

 * http://framework.zend.com/license/new-bsd

 * If you did not receive a copy of the license and are unable to

 * obtain it through the world-wide-web, please send an email

 * to license@zend.com so we can send you a copy immediately.

 *

 * @category   Zend

 * @package    Zend_Json

 * @copyright  Copyright (c) 2005-2007 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 */

/**

 * Encode PHP constructs to JSON

 *

 * @category   Zend

 * @package    Zend_Json

 * @copyright  Copyright (c) 2005-2007 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 */

class Zend_Json_Encoder

{

    /**

     * Whether or not to check for possible cycling

     *

     * @var boolean

     */

    protected $_cycleCheck;

    /**

     * Array of visited objects; used to prevent cycling.

     *

     * @var array

     */

    protected $_visited = array();

    /**

     * Constructor

     *

     * @param boolean $cycleCheck Whether or not to check for recursion when encoding

     * @return void

     */

    protected function __construct($cycleCheck = false)

    {

        $this->_cycleCheck = $cycleCheck;

    }

    /**

     * Use the JSON encoding scheme for the value specified

     *

     * @param mixed $value The value to be encoded

     * @param boolean $cycleCheck Whether or not to check for possible object recursion when encoding

     * @return string  The encoded value

     */

    public static function encode($value, $cycleCheck = false)

    {

        $encoder = new Zend_Json_Encoder(($cycleCheck) ? true : false);

        return $encoder->_encodeValue($value);

    }

    /**

     * Recursive driver which determines the type of value to be encoded

     * and then dispatches to the appropriate method. $values are either

     *    - objects (returns from {@link _encodeObject()})

     *    - arrays (returns from {@link _encodeArray()})

     *    - basic datums (e.g. numbers or strings) (returns from {@link _encodeDatum()})

     *

     * @param $value mixed The value to be encoded

     * @return string Encoded value

     */

    protected function _encodeValue(&$value)

    {

        if (is_object($value)) {

            return $this->_encodeObject($value);

        } else if (is_array($value)) {

            return $this->_encodeArray($value);

        }

        return $this->_encodeDatum($value);

    }

    /**

     * Encode an object to JSON by encoding each of the public properties

     *

     * A special property is added to the JSON object called '__className'

     * that contains the name of the class of $value. This is used to decode

     * the object on the client into a specific class.

     *

     * @param $value object

     * @return string

     * @throws Zend_Json_Exception If recursive checks are enabled and the object has been serialized previously

     */

    protected function _encodeObject(&$value)

    {

        if ($this->_cycleCheck) {

            if ($this->_wasVisited($value)) {

                throw new Zend_Json_Exception(

                    'Cycles not supported in JSON encoding, cycle introduced by '

                    . 'class "' . get_class($value) . '"'

                );

            }

            $this->_visited[] = $value;

        }

        $props = '';

        foreach (get_object_vars($value) as $name => $propValue) {

            if (isset($propValue)) {

                $props .= ','

                        . $this->_encodeValue($name)

                        . ':'

                        . $this->_encodeValue($propValue);

            }

        }

        return '{"__className":"' . get_class($value) . '"'

                . $props . '}';

    }

    /**

     * Determine if an object has been serialized already

     *

     * @param mixed $value

     * @return boolean

     */

    protected function _wasVisited(&$value)

    {

        if (in_array($value, $this->_visited, true)) {

            return true;

        }

        return false;

    }

    /**

     * JSON encode an array value

     *

     * Recursively encodes each value of an array and returns a JSON encoded

     * array string.

     *

     * Arrays are defined as integer-indexed arrays starting at index 0, where

     * the last index is (count($array) -1); any deviation from that is

     * considered an associative array, and will be encoded as such.

     *

     * @param $array array

     * @return string

     */

    protected function _encodeArray(&$array)

    {

        $tmpArray = array();

        // Check for associative array

        if (!empty($array) && (array_keys($array) !== range(0, count($array) - 1))) {

            // Associative array

            $result = '{';

            foreach ($array as $key => $value) {

                $key = (string) $key;

                $tmpArray[] = $this->_encodeString($key)

                            . ':'

                            . $this->_encodeValue($value);

            }

            $result .= implode(',', $tmpArray);

            $result .= '}';

        } else {

            // Indexed array

            $result = '[';

            $length = count($array);

            for ($i = 0; $i < $length; $i++) {

                $tmpArray[] = $this->_encodeValue($array[$i]);

            }

            $result .= implode(',', $tmpArray);

            $result .= ']';

        }

        return $result;

    }

    /**

     * JSON encode a basic data type (string, number, boolean, null)

     *

     * If value type is not a string, number, boolean, or null, the string

     * 'null' is returned.

     *

     * @param $value mixed

     * @return string

     */

    protected function _encodeDatum(&$value)

    {

        $result = 'null';

        if (is_int($value) || is_float($value)) {

            $result = (string)$value;

        } elseif (is_string($value)) {

            $result = $this->_encodeString($value);

        } elseif (is_bool($value)) {

            $result = $value ? 'true' : 'false';

        }

        return $result;

    }

    /**

     * JSON encode a string value by escaping characters as necessary

     *

     * @param $value string

     * @return string

     */

    protected function _encodeString(&$string)

    {

        // Escape these characters with a backslash:

        // " \ / \n \r \t \b \f

        $search  = array('\\', "\n", "\t", "\r", "\b", "\f", '"');

        $replace = array('\\\\', '\\n', '\\t', '\\r', '\\b', '\\f', '\"');

        $string  = str_replace($search, $replace, $string);

        // Escape certain ASCII characters:

        // 0x08 => \b

        // 0x0c => \f

        $string = str_replace(array(chr(0x08), chr(0x0C)), array('\b', '\f'), $string);

        return '"' . $string . '"';

    }

    /**

     * Encode the constants associated with the ReflectionClass

     * parameter. The encoding format is based on the class2 format

     *

     * @param $cls ReflectionClass

     * @return string Encoded constant block in class2 format

     */

    private static function _encodeConstants(ReflectionClass $cls)

    {

        $result    = "constants : {";

        $constants = $cls->getConstants();

        $tmpArray = array();

        if (!empty($constants)) {

            foreach ($constants as $key => $value) {

                $tmpArray[] = "$key: " . self::encode($value);

            }

            $result .= implode(', ', $tmpArray);

        }

        return $result . "}";

    }

    /**

     * Encode the public methods of the ReflectionClass in the

     * class2 format

     *

     * @param $cls ReflectionClass

     * @return string Encoded method fragment

     *

     */

    private static function _encodeMethods(ReflectionClass $cls)

    {

        $methods = $cls->getMethods();

        $result = 'methods:{';

        $started = false;

        foreach ($methods as $method) {

            if (! $method->isPublic() || !$method->isUserDefined()) {

                continue;

            }

            if ($started) {

                $result .= ',';

            }

            $started = true;

            $result .= '' . $method->getName(). ':function(';

            if ('__construct' != $method->getName()) {

                $parameters  = $method->getParameters();

                $paramCount  = count($parameters);

                $argsStarted = false;

                $argNames = "var argNames=[";

                foreach ($parameters as $param) {

                    if ($argsStarted) {

                        $result .= ',';

                    }

                    $result .= $param->getName();

                    if ($argsStarted) {

                        $argNames .= ',';

                    }

                    $argNames .= '"' . $param->getName() . '"';

                    $argsStarted = true;

                }

                $argNames .= "];";

                $result .= "){"

                         . $argNames

                         . 'var result = ZAjaxEngine.invokeRemoteMethod('

                         . "this, '" . $method->getName()

                         . "',argNames,arguments);"

                         . 'return(result);}';

            } else {

                $result .= "){}";

            }

        }

        return $result . "}";

    }

    /**

     * Encode the public properties of the ReflectionClass in the class2

     * format.

     *

     * @param $cls ReflectionClass

     * @return string Encode properties list

     *

     */

    private static function _encodeVariables(ReflectionClass $cls)

    {

        $properties = $cls->getProperties();

        $propValues = get_class_vars($cls->getName());

        $result = "variables:{";

        $cnt = 0;

        $tmpArray = array();

        foreach ($properties as $prop) {

            if (! $prop->isPublic()) {

                continue;

            }

            $tmpArray[] = $prop->getName()

                        . ':'

                        . self::encode($propValues[$prop->getName()]);

        }

        $result .= implode(',', $tmpArray);

        return $result . "}";

    }

    /**

     * Encodes the given $className into the class2 model of encoding PHP

     * classes into JavaScript class2 classes.

     * NOTE: Currently only public methods and variables are proxied onto

     * the client machine

     *

     * @param $className string The name of the class, the class must be

     * instantiable using a null constructor

     * @param $package string Optional package name appended to JavaScript

     * proxy class name

     * @return string The class2 (JavaScript) encoding of the class

     * @throws Zend_Json_Exception

     */

    public static function encodeClass($className, $package = '')

    {

        $cls = new ReflectionClass($className);

        if (! $cls->isInstantiable()) {

            throw new Zend_Json_Exception("$className must be instantiable");

        }

        return "Class.create('$package$className',{"

                . self::_encodeConstants($cls)    .","

                . self::_encodeMethods($cls)      .","

                . self::_encodeVariables($cls)    .'});';

    }

    /**

     * Encode several classes at once

     *

     * Returns JSON encoded classes, using {@link encodeClass()}.

     *

     * @param array $classNames

     * @param string $package

     * @return string

     */

    public static function encodeClasses(array $classNames, $package = '')

    {

        $result = '';

        foreach ($classNames as $className) {

            $result .= self::encodeClass($className, $package);

        }

        return $result;

    }

}

/**

 * Decode JSON encoded string to PHP variable constructs

 *

 * @category   Zend

 * @package    Zend_Json

 * @copyright  Copyright (c) 2005-2007 Zend Technologies USA Inc. (http://www.zend.com)

 * @license    http://framework.zend.com/license/new-bsd     New BSD License

 */

class Zend_Json_Decoder

{

    /**

     * Parse tokens used to decode the JSON object. These are not

     * for public consumption, they are just used internally to the

     * class.

     */

    const EOF          = 0;

    const DATUM        = 1;

    const LBRACE       = 2;

    const LBRACKET     = 3;

    const RBRACE       = 4;

    const RBRACKET     = 5;

    const COMMA        = 6;

    const COLON        = 7;

    /**

     * Use to maintain a "pointer" to the source being decoded

     *

     * @var string

     */

    protected $_source;

    /**

     * Caches the source length

     *

     * @var int

     */

    protected $_sourceLength;

    /**

     * The offset within the souce being decoded

     *

     * @var int

     *

     */

    protected $_offset;

    /**

     * The current token being considered in the parser cycle

     *

     * @var int

     */

    protected $_token;

    /**

     * Flag indicating how objects should be decoded

     *

     * @var int

     * @access protected

     */

    protected $_decodeType;

    /**

     * Constructor

     *

     * @param string $source String source to decode

     * @param int $decodeType How objects should be decoded -- see

     * {@link Zend_Json::TYPE_ARRAY} and {@link Zend_Json::TYPE_OBJECT} for

     * valid values

     * @return void

     */

    protected function __construct($source, $decodeType)

    {

        // eliminate comments

        $source = 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'

              ), '', $source);

        // Set defaults

        $this->_source       = $source;

        $this->_sourceLength = strlen($source);

        $this->_token        = self::EOF;

        $this->_offset       = 0;

        // Normalize and set $decodeType

        if (!in_array($decodeType, array(Zend_Json::TYPE_ARRAY, Zend_Json::TYPE_OBJECT)))

        {

            $decodeType = Zend_Json::TYPE_ARRAY;

        }

        $this->_decodeType   = $decodeType;

        // Set pointer at first token

        $this->_getNextToken();

    }

    /**

     * Decode a JSON source string

     *

     * Decodes a JSON encoded string. The value returned will be one of the

     * following:

     *        - integer

     *        - float

     *        - boolean

     *        - null

     *      - StdClass

     *      - array

     *         - array of one or more of the above types

     *

     * By default, decoded objects will be returned as associative arrays; to

     * return a StdClass object instead, pass {@link Zend_Json::TYPE_OBJECT} to

     * the $objectDecodeType parameter.

     *