<?php

/**

 * Zend Framework

 *

 * LICENSE

 *

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

 * with this package in the file LICENSE.txt.

 * 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_Serializer

 * @subpackage Adapter

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

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

 * @version    $Id: PythonPickle.php 21187 2010-02-24 01:22:01Z stas $

 */

/** @see Zend_Serializer_Adapter_AdapterAbstract */

require_once 'Zend/Serializer/Adapter/AdapterAbstract.php';

/**

 * @link       http://www.python.org

 * @see        Phython3.1/Lib/pickle.py

 * @see        Phython3.1/Modules/_pickle.c

 * @link       http://pickle-js.googlecode.com

 * @category   Zend

 * @package    Zend_Serializer

 * @subpackage Adapter

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

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

 */

class Zend_Serializer_Adapter_PythonPickle extends Zend_Serializer_Adapter_AdapterAbstract

{

    /* Pickle opcodes. See pickletools.py for extensive docs.  The listing

       here is in kind-of alphabetical order of 1-character pickle code.

       pickletools groups them by purpose. */

    const OP_MARK            = '(';     // push special markobject on stack

    const OP_STOP            = '.';     // every pickle ends with STOP

    const OP_POP             = '0';     // discard topmost stack item

    const OP_POP_MARK        = '1';     // discard stack top through topmost markobject

    const OP_DUP             = '2';     // duplicate top stack item

    const OP_FLOAT           = 'F';     // push float object; decimal string argument

    const OP_INT             = 'I';     // push integer or bool; decimal string argument

    const OP_BININT          = 'J';     // push four-byte signed int

    const OP_BININT1         = 'K';     // push 1-byte unsigned int

    const OP_LONG            = 'L';     // push long; decimal string argument

    const OP_BININT2         = 'M';     // push 2-byte unsigned int

    const OP_NONE            = 'N';     // push None

    const OP_PERSID          = 'P';     // push persistent object; id is taken from string arg

    const OP_BINPERSID       = 'Q';     //  "       "         "  ;  "  "   "     "  stack

    const OP_REDUCE          = 'R';     // apply callable to argtuple, both on stack

    const OP_STRING          = 'S';     // push string; NL-terminated string argument

    const OP_BINSTRING       = 'T';     // push string; counted binary string argument

    const OP_SHORT_BINSTRING = 'U';     //  "     "   ;    "      "       "      " < 256 bytes

    const OP_UNICODE         = 'V';     // push Unicode string; raw-unicode-escaped'd argument

    const OP_BINUNICODE      = 'X';     //   "     "       "  ; counted UTF-8 string argument

    const OP_APPEND          = 'a';     // append stack top to list below it

    const OP_BUILD           = 'b';     // call __setstate__ or __dict__.update()

    const OP_GLOBAL          = 'c';     // push self.find_class(modname, name); 2 string args

    const OP_DICT            = 'd';     // build a dict from stack items

    const OP_EMPTY_DICT      = '}';     // push empty dict

    const OP_APPENDS         = 'e';     // extend list on stack by topmost stack slice

    const OP_GET             = 'g';     // push item from memo on stack; index is string arg

    const OP_BINGET          = 'h';     //   "    "    "    "   "   "  ;   "    " 1-byte arg

    const OP_INST            = 'i';     // build & push class instance

    const OP_LONG_BINGET     = 'j';     // push item from memo on stack; index is 4-byte arg

    const OP_LIST            = 'l';     // build list from topmost stack items

    const OP_EMPTY_LIST      = ']';     // push empty list

    const OP_OBJ             = 'o';     // build & push class instance

    const OP_PUT             = 'p';     // store stack top in memo; index is string arg

    const OP_BINPUT          = 'q';     //   "     "    "   "   " ;   "    " 1-byte arg

    const OP_LONG_BINPUT     = 'r';     //   "     "    "   "   " ;   "    " 4-byte arg

    const OP_SETITEM         = 's';     // add key+value pair to dict

    const OP_TUPLE           = 't';     // build tuple from topmost stack items

    const OP_EMPTY_TUPLE     = ')';     // push empty tuple

    const OP_SETITEMS        = 'u';     // modify dict by adding topmost key+value pairs

    const OP_BINFLOAT        = 'G';     // push float; arg is 8-byte float encoding

    /* Protocol 2 */

    const OP_PROTO           = "\x80";  // identify pickle protocol

    const OP_NEWOBJ          = "\x81";  // build object by applying cls.__new__ to argtuple

    const OP_EXT1            = "\x82";  // push object from extension registry; 1-byte index

    const OP_EXT2            = "\x83";  // ditto, but 2-byte index

    const OP_EXT4            = "\x84";  // ditto, but 4-byte index

    const OP_TUPLE1          = "\x85";  // build 1-tuple from stack top

    const OP_TUPLE2          = "\x86";  // build 2-tuple from two topmost stack items

    const OP_TUPLE3          = "\x87";  // build 3-tuple from three topmost stack items

    const OP_NEWTRUE         = "\x88";  // push True

    const OP_NEWFALSE        = "\x89";  // push False

    const OP_LONG1           = "\x8a";  // push long from < 256 bytes

    const OP_LONG4           = "\x8b";  // push really big long

    /* Protocol 3 (Python 3.x) */

    const OP_BINBYTES        = 'B';     // push bytes; counted binary string argument

    const OP_SHORT_BINBYTES  = 'C';     //  "     "   ;    "      "       "      " < 256 bytes

    /**

     * @var bool Whether or not this is a PHP 6 binary

     */

    protected static $_isPhp6 = null;

    /**

     * @var bool Whether or not the system is little-endian

     */

    protected static $_isLittleEndian = null;

    /**

     * @var array Strings representing quotes

     */

    protected static $_quoteString = array(

        '\\' => '\\\\',

        "\x00" => '\\x00', "\x01" => '\\x01', "\x02" => '\\x02', "\x03" => '\\x03',

        "\x04" => '\\x04', "\x05" => '\\x05', "\x06" => '\\x06', "\x07" => '\\x07',

        "\x08" => '\\x08', "\x09" => '\\t',   "\x0a" => '\\n',   "\x0b" => '\\x0b',

        "\x0c" => '\\x0c', "\x0d" => '\\r',   "\x0e" => '\\x0e', "\x0f" => '\\x0f',

        "\x10" => '\\x10', "\x11" => '\\x11', "\x12" => '\\x12', "\x13" => '\\x13',

        "\x14" => '\\x14', "\x15" => '\\x15', "\x16" => '\\x16', "\x17" => '\\x17',

        "\x18" => '\\x18', "\x19" => '\\x19', "\x1a" => '\\x1a', "\x1b" => '\\x1b',

        "\x1c" => '\\x1c', "\x1d" => '\\x1d', "\x1e" => '\\x1e', "\x1f" => '\\x1f',

        "\xff" => '\\xff'

    );

    /**

     * @var array Default options

     */

    protected $_options = array(

        'protocol'           => 0,

    );

    // process vars

    protected $_protocol           = 0;

    protected $_binary             = false;

    protected $_memo               = array();

    protected $_pickle             = '';

    protected $_pickleLen          = 0;

    protected $_pos                = 0;

    protected $_stack              = array();

    protected $_marker             = null;

    /**

     * Constructor

     *

     * @link Zend_Serializer_Adapter_AdapterAbstract::__construct()

     */

    public function __construct($opts=array())

    {

        parent::__construct($opts);

        // init

        if (self::$_isLittleEndian === null) {

            self::$_isLittleEndian = (pack('l', 1) === "\x01\x00\x00\x00");

        }

        if (self::$_isPhp6 === null) {

            self::$_isPhp6 = !version_compare(PHP_VERSION, '6.0.0', '<');

        }

        $this->_marker = new stdClass();

    }

    /**

     * Set an option

     *

     * @link   Zend_Serializer_Adapter_AdapterAbstract::setOption()

     * @param  string $name

     * @param  mixed $value

     * @return Zend_Serializer_Adapter_PythonPickle

     */

    public function setOption($name, $value)

    {

        switch ($name) {

            case 'protocol':

                $value = $this->_checkProtocolNumber($value);

                break;

        }

        return parent::setOption($name, $value);

    }

    /**

     * Check and normalize pickle protocol number

     *

     * @param  int $number

     * @return int

     * @throws Zend_Serializer_Exception

     */

    protected function _checkProtocolNumber($number)

    {

        $int = (int) $number;

        if ($int < 0 || $int > 3) {

            require_once 'Zend/Serializer/Exception.php';

            throw new Zend_Serializer_Exception('Invalid or unknown protocol version "'.$number.'"');

        }

        return $int;

    }

    /* serialize */

    /**

     * Serialize PHP to PythonPickle format

     *

     * @param  mixed $value

     * @param  array $opts

     * @return string

     */

    public function serialize($value, array $opts = array())

    {

        $opts = $opts + $this->_options;

        $this->_protocol = $this->_checkProtocolNumber($opts['protocol']);

        $this->_binary   = $this->_protocol != 0;

        // clear process vars before serializing

        $this->_memo   = array();

        $this->_pickle = '';

        // write

        if ($this->_protocol >= 2) {

            $this->_writeProto($this->_protocol);

        }

        $this->_write($value);

        $this->_writeStop();

        // clear process vars after serializing

        $this->_memo = array();

        $pickle = $this->_pickle;

        $this->_pickle = '';

        return $pickle;

    }

    /**

     * Write a value

     *

     * @param  mixed $value

     * @return void

     * @throws Zend_Serializer_Exception on invalid or unrecognized value type

     */

    protected function _write($value)

    {

        if ($value === null) {

            $this->_writeNull();

        } elseif ($value === true) {

            $this->_writeTrue();

        } elseif ($value === false) {

            $this->_writeFalse();

        } elseif (is_int($value)) {

            $this->_writeInt($value);

        } elseif (is_float($value)) {

            $this->_writeFloat($value);

        } elseif (is_string($value)) {

            // TODO: write unicode / binary

            $this->_writeString($value);

        } elseif (is_array($value)) {

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

                $this->_writeArrayDict($value);

            } else {

                $this->_writeArrayList($value);

            }

        } elseif (is_object($value)) {

            $this->_writeObject($value);

        } else {

            require_once 'Zend/Serializer/Exception.php';

            throw new Zend_Serializer_Exception(

                'PHP-Type "'.gettype($value).'" isn\'t serializable with '.get_class($this)

            );

        }

    }

    /**

     * Write pickle protocol

     *

     * @param  int $protocol

     * @return void

     */

    protected function _writeProto($protocol)

    {

        $this->_pickle .= self::OP_PROTO . $protocol;

    }

    /**

     * Write a get

     *

     * @param  int $id Id of memo

     * @return void

     */

    protected function _writeGet($id)

    {

        if ($this->_binary) {

            if ($id <= 0xff) {

                // BINGET + chr(i)

                $this->_pickle .= self::OP_BINGET . chr($id);

            } else {

                // LONG_BINGET + pack("<i", i)

                $idBin = pack('l', $id);

                if (self::$_isLittleEndian === false) {

                    $idBin = strrev($bin);

                }

                $this->_pickle .= self::OP_LONG_BINGET . $idBin;

            }

        } else {

            $this->_pickle .= self::OP_GET . $id . "\r\n";

        }

    }

    /**

     * Write a put

     *

     * @param  int $id Id of memo

     * @return void

     */

    protected function _writePut($id)

    {

        if ($this->_binary) {

            if ($id <= 0xff) {

                // BINPUT + chr(i)

                $this->_pickle .= self::OP_BINPUT . chr($id);

            } else {

                // LONG_BINPUT + pack("<i", i)

                $idBin = pack('l', $id);

                if (self::$_isLittleEndian === false) {

                    $idBin = strrev($bin);

                }

                $this->_pickle .= self::OP_LONG_BINPUT . $idBin;

            }

        } else {

            $this->_pickle .= self::OP_PUT . $id . "\r\n";

        }

    }

    /**

     * Write a null as None

     *

     * @return void

     */

    protected function _writeNull()

    {

        $this->_pickle .= self::OP_NONE;

    }

    /**

     * Write a boolean true

     *

     * @return void

     */

    protected function _writeTrue()

    {

        if ($this->_protocol >= 2) {

            $this->_pickle .= self::OP_NEWTRUE;

        } else {

            $this->_pickle .= self::OP_INT . "01\r\n";

        }

    }

    /**

     * Write a boolean false

     *

     * @return void

     */

    protected function _writeFalse()

    {

        if ($this->_protocol >= 2) {

            $this->_pickle .= self::OP_NEWFALSE;

        } else {

            $this->_pickle .= self::OP_INT . "00\r\n";

        }

    }

    /**

     * Write an integer value

     *

     * @param  int $value

     * @return void

     */

    protected function _writeInt($value)

    {

        if ($this->_binary) {

            if ($value >= 0) {

                if ($value <= 0xff) {

                    // self.write(BININT1 + chr(obj))

                    $this->_pickle .= self::OP_BININT1 . chr($value);

                } elseif ($value <= 0xffff) {

                    // self.write("%c%c%c" % (BININT2, obj&0xff, obj>>8))

                    $this->_pickle .= self::OP_BININT2 . pack('v', $value);

                }

                return;

            }

            // Next check for 4-byte signed ints:

            $highBits = $value >> 31;  // note that Python shift sign-extends

            if ($highBits == 0 || $highBits == -1) {

                // All high bits are copies of bit 2**31, so the value

                // fits in a 4-byte signed int.

                // self.write(BININT + pack("<i", obj))

                $bin = pack('l', $value);

                if (self::$_isLittleEndian === false) {

                    $bin = strrev($bin);

                }

                $this->_pickle .= self::OP_BININT . $bin;

                return;

            }

        }

        $this->_pickle .= self::OP_INT . $value . "\r\n";

    }

    /**

     * Write a float value

     *

     * @param  float $value

     * @return void

     */

    protected function _writeFloat($value)

    {

        if ($this->_binary) {

            // self.write(BINFLOAT + pack('>d', obj))