<?PHP
/* vim: set expandtab tabstop=4 shiftwidth=4 softtabstop=4: */

/**
 * XML_Unserializer
 *
 * Parses any XML document into PHP data structures.
 *
 * PHP versions 4 and 5
 *
 * LICENSE:
 *
 * Copyright (c) 2003-2008 Stephan Schmidt <schst@php.net>
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 *
 *    * Redistributions of source code must retain the above copyright
 *      notice, this list of conditions and the following disclaimer.
 *    * Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in the
 *      documentation and/or other materials provided with the distribution.
 *    * The name of the author may not be used to endorse or promote products
 *      derived from this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
 * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * @category  XML
 * @package   XML_Serializer
 * @author    Stephan Schmidt <schst@php.net>
 * @copyright 2003-2008 Stephan Schmidt <schst@php.net>
 * @license   http://opensource.org/licenses/bsd-license New BSD License
 * @version   CVS: $Id: Unserializer.php 61 2012-09-13 18:44:52Z gerd $
 * @link      http://pear.php.net/package/XML_Serializer
 * @see       XML_Unserializer
 */

/**
 * uses PEAR error managemt
 */
require_once 'PEAR.php';

/**
 * uses XML_Parser to unserialize document
 */
require_once 'XML/Parser.php';

/**
 * option: Convert nested tags to array or object
 *
 * Possible values:
 * - array
 * - object
 * - associative array to define this option per tag name
 */
define('XML_UNSERIALIZER_OPTION_COMPLEXTYPE', 'complexType');

/**
 * option: Name of the attribute that stores the original key
 *
 * Possible values:
 * - any string
 */
define('XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY', 'keyAttribute');

/**
 * option: Name of the attribute that stores the type
 *
 * Possible values:
 * - any string
 */
define('XML_UNSERIALIZER_OPTION_ATTRIBUTE_TYPE', 'typeAttribute');

/**
 * option: Name of the attribute that stores the class name
 *
 * Possible values:
 * - any string
 */
define('XML_UNSERIALIZER_OPTION_ATTRIBUTE_CLASS', 'classAttribute');

/**
 * option: Whether to use the tag name as a class name
 *
 * Possible values:
 * - true or false
 */
define('XML_UNSERIALIZER_OPTION_TAG_AS_CLASSNAME', 'tagAsClass');

/**
 * option: Name of the default class
 *
 * Possible values:
 * - any string
 */
define('XML_UNSERIALIZER_OPTION_DEFAULT_CLASS', 'defaultClass');

/**
 * option: Whether to parse attributes
 *
 * Possible values:
 * - true or false
 */
define('XML_UNSERIALIZER_OPTION_ATTRIBUTES_PARSE', 'parseAttributes');

/**
 * option: Key of the array to store attributes (if any)
 *
 * Possible values:
 * - any string
 * - false (disabled)
 */
define('XML_UNSERIALIZER_OPTION_ATTRIBUTES_ARRAYKEY', 'attributesArray');

/**
 * option: string to prepend attribute name (if any)
 *
 * Possible values:
 * - any string
 * - false (disabled)
 */
define('XML_UNSERIALIZER_OPTION_ATTRIBUTES_PREPEND', 'prependAttributes');

/**
 * option: key to store the content,
 * if XML_UNSERIALIZER_OPTION_ATTRIBUTES_PARSE is used
 *
 * Possible values:
 * - any string
 */
define('XML_UNSERIALIZER_OPTION_CONTENT_KEY', 'contentName');

/**
 * option: map tag names
 *
 * Possible values:
 * - associative array
 */
define('XML_UNSERIALIZER_OPTION_TAG_MAP', 'tagMap');

/**
 * option: list of tags that will always be enumerated
 *
 * Possible values:
 * - indexed array
 */
define('XML_UNSERIALIZER_OPTION_FORCE_ENUM', 'forceEnum');

/**
 * option: Encoding of the XML document
 *
 * Possible values:
 * - UTF-8
 * - ISO-8859-1
 */
define('XML_UNSERIALIZER_OPTION_ENCODING_SOURCE', 'encoding');

/**
 * option: Desired target encoding of the data
 *
 * Possible values:
 * - UTF-8
 * - ISO-8859-1
 */
define('XML_UNSERIALIZER_OPTION_ENCODING_TARGET', 'targetEncoding');

/**
 * option: Callback that will be applied to textual data
 *
 * Possible values:
 * - any valid PHP callback
 */
define('XML_UNSERIALIZER_OPTION_DECODE_FUNC', 'decodeFunction');

/**
 * option: whether to return the result of the unserialization from unserialize()
 *
 * Possible values:
 * - true
 * - false (default)
 */
define('XML_UNSERIALIZER_OPTION_RETURN_RESULT', 'returnResult');

/**
 * option: set the whitespace behaviour
 *
 * Possible values:
 * - XML_UNSERIALIZER_WHITESPACE_KEEP
 * - XML_UNSERIALIZER_WHITESPACE_TRIM
 * - XML_UNSERIALIZER_WHITESPACE_NORMALIZE
 */
define('XML_UNSERIALIZER_OPTION_WHITESPACE', 'whitespace');

/**
 * Keep all whitespace
 */
define('XML_UNSERIALIZER_WHITESPACE_KEEP', 'keep');

/**
 * remove whitespace from start and end of the data
 */
define('XML_UNSERIALIZER_WHITESPACE_TRIM', 'trim');

/**
 * normalize whitespace
 */
define('XML_UNSERIALIZER_WHITESPACE_NORMALIZE', 'normalize');

/**
 * option: whether to ovverride all options that have been set before
 *
 * Possible values:
 * - true
 * - false (default)
 */
define('XML_UNSERIALIZER_OPTION_OVERRIDE_OPTIONS', 'overrideOptions');

/**
 * option: list of tags, that will not be used as keys
 */
define('XML_UNSERIALIZER_OPTION_IGNORE_KEYS', 'ignoreKeys');

/**
 * option: whether to use type guessing for scalar values
 */
define('XML_UNSERIALIZER_OPTION_GUESS_TYPES', 'guessTypes');

/**
 * error code for no serialization done
 */
define('XML_UNSERIALIZER_ERROR_NO_UNSERIALIZATION', 151);

/**
 * XML_Unserializer
 *
 * class to unserialize XML documents that have been created with
 * XML_Serializer. To unserialize an XML document you have to add
 * type hints to the XML_Serializer options.
 *
 * If no type hints are available, XML_Unserializer will guess how
 * the tags should be treated, that means complex structures will be
 * arrays and tags with only CData in them will be strings.
 *
 * <code>
 * require_once 'XML/Unserializer.php';
 *
 * //  be careful to always use the ampersand in front of the new operator
 * $unserializer = &new XML_Unserializer();
 *
 * $unserializer->unserialize($xml);
 *
 * $data = $unserializer->getUnserializedData();
 * </code>
 *
 * @category  XML
 * @package   XML_Serializer
 * @author    Stephan Schmidt <schst@php.net>
 * @copyright 2003-2008 Stephan Schmidt <schst@php.net>
 * @license   http://opensource.org/licenses/bsd-license New BSD License
 * @version   Release: @package_version@
 * @link      http://pear.php.net/package/XML_Serializer
 * @see       XML_Serializer
 */
class XML_Unserializer extends PEAR
{
    /**
     * list of all available options
     *
     * @access private
     * @var    array
     */
    var $_knownOptions = array(
                                XML_UNSERIALIZER_OPTION_COMPLEXTYPE,
                                XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY,
                                XML_UNSERIALIZER_OPTION_ATTRIBUTE_TYPE,
                                XML_UNSERIALIZER_OPTION_ATTRIBUTE_CLASS,
                                XML_UNSERIALIZER_OPTION_TAG_AS_CLASSNAME,
                                XML_UNSERIALIZER_OPTION_DEFAULT_CLASS,
                                XML_UNSERIALIZER_OPTION_ATTRIBUTES_PARSE,
                                XML_UNSERIALIZER_OPTION_ATTRIBUTES_ARRAYKEY,
                                XML_UNSERIALIZER_OPTION_ATTRIBUTES_PREPEND,
                                XML_UNSERIALIZER_OPTION_CONTENT_KEY,
                                XML_UNSERIALIZER_OPTION_TAG_MAP,
                                XML_UNSERIALIZER_OPTION_FORCE_ENUM,
                                XML_UNSERIALIZER_OPTION_ENCODING_SOURCE,
                                XML_UNSERIALIZER_OPTION_ENCODING_TARGET,
                                XML_UNSERIALIZER_OPTION_DECODE_FUNC,
                                XML_UNSERIALIZER_OPTION_RETURN_RESULT,
                                XML_UNSERIALIZER_OPTION_WHITESPACE,
                                XML_UNSERIALIZER_OPTION_IGNORE_KEYS,
                                XML_UNSERIALIZER_OPTION_GUESS_TYPES
                              );
    /**
     * default options for the serialization
     *
     * @access private
     * @var    array
     */
    var $_defaultOptions = array(
        // complex types will be converted to arrays, if no type hint is given
        XML_UNSERIALIZER_OPTION_COMPLEXTYPE => 'array',

        // get array key/property name from this attribute
        XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY => '_originalKey',

        // get type from this attribute
        XML_UNSERIALIZER_OPTION_ATTRIBUTE_TYPE => '_type',

        // get class from this attribute (if not given, use tag name)
        XML_UNSERIALIZER_OPTION_ATTRIBUTE_CLASS => '_class',

        // use the tagname as the classname
        XML_UNSERIALIZER_OPTION_TAG_AS_CLASSNAME => true,

        // name of the class that is used to create objects
        XML_UNSERIALIZER_OPTION_DEFAULT_CLASS => 'stdClass',

        // parse the attributes of the tag into an array
        XML_UNSERIALIZER_OPTION_ATTRIBUTES_PARSE => false,

        // parse them into sperate array (specify name of array here)
        XML_UNSERIALIZER_OPTION_ATTRIBUTES_ARRAYKEY => false,

        // prepend attribute names with this string
        XML_UNSERIALIZER_OPTION_ATTRIBUTES_PREPEND => '',

        // put cdata found in a tag that has been converted
        // to a complex type in this key
        XML_UNSERIALIZER_OPTION_CONTENT_KEY => '_content',

        // use this to map tagnames
        XML_UNSERIALIZER_OPTION_TAG_MAP => array(),

        // these tags will always be an indexed array
        XML_UNSERIALIZER_OPTION_FORCE_ENUM => array(),

        // specify the encoding character of the document to parse
        XML_UNSERIALIZER_OPTION_ENCODING_SOURCE => null,

        // specify the target encoding
        XML_UNSERIALIZER_OPTION_ENCODING_TARGET => null,

        // function used to decode data
        XML_UNSERIALIZER_OPTION_DECODE_FUNC => null,

        // unserialize() returns the result of the unserialization instead of true
        XML_UNSERIALIZER_OPTION_RETURN_RESULT => false,

        // remove whitespace around data
        XML_UNSERIALIZER_OPTION_WHITESPACE => XML_UNSERIALIZER_WHITESPACE_TRIM,

        // List of tags that will automatically be added to the parent,
        // instead of adding a new key
        XML_UNSERIALIZER_OPTION_IGNORE_KEYS => array(),

        // Whether to use type guessing
        XML_UNSERIALIZER_OPTION_GUESS_TYPES => false
    );

    /**
     * current options for the serialization
     *
     * @access public
     * @var    array
     */
    var $options = array();

    /**
     * unserialized data
     *
     * @access private
     * @var    string
     */
    var $_unserializedData = null;

    /**
     * name of the root tag
     *
     * @access private
     * @var    string
     */
    var $_root = null;

    /**
     * stack for all data that is found
     *
     * @access private
     * @var    array
     */
    var $_dataStack = array();

    /**
     * stack for all values that are generated
     *
     * @access private
     * @var    array
     */
    var $_valStack = array();

    /**
     * current tag depth
     *
     * @access private
     * @var    int
     */
    var $_depth = 0;

    /**
     * XML_Parser instance
     *
     * @access   private
     * @var      object XML_Parser
     */
    var $_parser = null;

    /**
     * constructor
     *
     * @param mixed $options array containing options for the unserialization
     *
     * @access public
     */
    function XML_Unserializer($options = null)
    {
        if (is_array($options)) {
            $this->options = array_merge($this->_defaultOptions, $options);
        } else {
            $this->options = $this->_defaultOptions;
        }
    }

    /**
     * return API version
     *
     * @access   public
     * @return string  $version API version
     * @static
     */
    function apiVersion()
    {
        return '@package_version@';
    }

    /**
     * reset all options to default options
     *
     * @return void
     * @access public
     * @see setOption(), XML_Unserializer(), setOptions()
     */
    function resetOptions()
    {
        $this->options = $this->_defaultOptions;
    }

    /**
     * set an option
     *
     * You can use this method if you do not want
     * to set all options in the constructor
     *
     * @param string $name  name of option
     * @param mixed  $value value of option
     *
     * @return void
     * @access public
     * @see resetOption(), XML_Unserializer(), setOptions()
     */
    function setOption($name, $value)
    {
        $this->options[$name] = $value;
    }

    /**
     * sets several options at once
     *
     * You can use this method if you do not want
     * to set all options in the constructor
     *
     * @param array $options options array
     *
     * @return void
     * @access public
     * @see resetOption(), XML_Unserializer(), setOption()
     */
    function setOptions($options)
    {
        $this->options = array_merge($this->options, $options);
    }

    /**
     * unserialize data
     *
     * @param mixed   $data    data to unserialize (string, filename or resource)
     * @param boolean $isFile  data should be treated as a file
     * @param array   $options options that will override
     *                         the global options for this call
     *
     * @return boolean $success
     * @access public
     */
    function unserialize($data, $isFile = false, $options = null)
    {
        $this->_unserializedData = null;
        $this->_root             = null;

        // if options have been specified, use them instead
        // of the previously defined ones
        if (is_array($options)) {
            $optionsBak = $this->options;
            if (isset($options[XML_UNSERIALIZER_OPTION_OVERRIDE_OPTIONS])
                && $options[XML_UNSERIALIZER_OPTION_OVERRIDE_OPTIONS] == true
            ) {
                $this->options = array_merge($this->_defaultOptions, $options);
            } else {
                $this->options = array_merge($this->options, $options);
            }
        } else {
            $optionsBak = null;
        }

        $this->_valStack  = array();
        $this->_dataStack = array();
        $this->_depth     = 0;

        $this->_createParser();

        if (is_string($data)) {
            if ($isFile) {
                $result = $this->_parser->setInputFile($data);
                if (PEAR::isError($result)) {
                    return $result;
                }
                $result = $this->_parser->parse();
            } else {
                $result = $this->_parser->parseString($data, true);
            }
        } else {
            $this->_parser->setInput($data);
            $result = $this->_parser->parse();
        }

        if ($this->options[XML_UNSERIALIZER_OPTION_RETURN_RESULT] === true) {
            $return = $this->_unserializedData;
        } else {
            $return = true;
        }

        if ($optionsBak !== null) {
            $this->options = $optionsBak;
        }

        if (PEAR::isError($result)) {
            return $result;
        }

        return $return;
    }

    /**
     * get the result of the serialization
     *
     * @access public
     * @return string  $serializedData
     */
    function getUnserializedData()
    {
        if ($this->_root === null) {
            return $this->raiseError('No unserialized data available. '
                . 'Use XML_Unserializer::unserialize() first.',
                XML_UNSERIALIZER_ERROR_NO_UNSERIALIZATION);
        }
        return $this->_unserializedData;
    }

    /**
     * get the name of the root tag
     *
     * @access public
     * @return string  $rootName
     */
    function getRootName()
    {
        if ($this->_root === null) {
            return $this->raiseError('No unserialized data available. '
                . 'Use XML_Unserializer::unserialize() first.',
                XML_UNSERIALIZER_ERROR_NO_UNSERIALIZATION);
        }
        return $this->_root;
    }

    /**
     * Start element handler for XML parser
     *
     * @param object $parser  XML parser object
     * @param string $element XML element
     * @param array  $attribs attributes of XML tag
     *
     * @return void
     * @access private
     */
    function startHandler($parser, $element, $attribs)
    {
        if (isset($attribs[$this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_TYPE]])
        ) {
            $type = $attribs[$this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_TYPE]];

            $guessType = false;
        } else {
            $type = 'string';
            if ($this->options[XML_UNSERIALIZER_OPTION_GUESS_TYPES] === true) {
                $guessType = true;
            } else {
                $guessType = false;
            }
        }

        if ($this->options[XML_UNSERIALIZER_OPTION_DECODE_FUNC] !== null) {
            $attribs = array_map($this->options[XML_UNSERIALIZER_OPTION_DECODE_FUNC],
                $attribs);
        }

        $this->_depth++;
        $this->_dataStack[$this->_depth] = null;

        if (is_array($this->options[XML_UNSERIALIZER_OPTION_TAG_MAP])
            && isset($this->options[XML_UNSERIALIZER_OPTION_TAG_MAP][$element])
        ) {
            $element = $this->options[XML_UNSERIALIZER_OPTION_TAG_MAP][$element];
        }

        $val = array(
                     'name'         => $element,
                     'value'        => null,
                     'type'         => $type,
                     'guessType'    => $guessType,
                     'childrenKeys' => array(),
                     'aggregKeys'   => array()
                    );

        if ($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTES_PARSE] == true
            && (count($attribs) > 0)
        ) {
            $val['children'] = array();
            $val['type']     = $this->_getComplexType($element);
            $val['class']    = $element;

            if ($this->options[XML_UNSERIALIZER_OPTION_GUESS_TYPES] === true) {
                $attribs = $this->_guessAndSetTypes($attribs);
            }
            if ($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTES_ARRAYKEY] != false
            ) {
                $val['children'][$this->
                    options[XML_UNSERIALIZER_OPTION_ATTRIBUTES_ARRAYKEY]] = $attribs;
            } else {
                foreach ($attribs as $attrib => $value) {
                    $val['children'][$this->
                        options[XML_UNSERIALIZER_OPTION_ATTRIBUTES_PREPEND]
                        . $attrib] = $value;
                }
            }
        }

        $keyAttr = false;

        if (is_string($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY])) {
            $keyAttr = $this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY];
        } elseif (is_array($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY])) {
            if (isset($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY]
                [$element])
            ) {
                $keyAttr =
                    $this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY][$element];
            } elseif (isset($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY]
                ['#default'])
            ) {
                $keyAttr = $this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY]
                ['#default'];
            } elseif (isset($this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY]
                ['__default'])
            ) {
                // keep this for BC
                $keyAttr =
                    $this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_KEY]
                    ['__default'];
            }
        }

        if ($keyAttr !== false && isset($attribs[$keyAttr])) {
            $val['name'] = $attribs[$keyAttr];
        }

        if (isset($attribs[$this->
            options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_CLASS]])
        ) {
            $val['class'] =
                $attribs[$this->options[XML_UNSERIALIZER_OPTION_ATTRIBUTE_CLASS]];
        }

        array_push($this->_valStack, $val);
    }

    /**
     * Try to guess the type of several values and
     * set them accordingly
     *
     * @param array $array array containing the values
     *
     * @return array array, containing the values with their correct types
     * @access private
     */
    function _guessAndSetTypes($array)
    {
        foreach ($array as $key => $value) {
            $array[$key] = $this->_guessAndSetType($value);
        }
        return $array;
    }

    /**
     * Try to guess the type of a value and
     * set it accordingly
     *
     * @param string $value character data
     *
     * @return mixed value with the best matching type
     * @access private
     */
    function _guessAndSetType($value)
    {
        if ($value === 'true') {
            return true;
        }
        if ($value === 'false') {
            return false;
        }
        if ($value === 'NULL') {
            return null;
        }
        if (preg_match('/^[-+]?[0-9]{1,}\\z/', $value)) {
            return intval($value);
        }
        if (preg_match('/^[-+]?[0-9]{1,}\.[0-9]{1,}\\z/', $value)) {
            return doubleval($value);
        }
        return (string)$value;
    }

    /**
     * End element handler for XML parser
     *
     * @param object $parser  XML parser object
     * @param string $element element
     *
     * @return void
     * @access private
     */
    function endHandler($parser, $element)
    {
        $value = array_pop($this->_valStack);
        switch ($this->options[XML_UNSERIALIZER_OPTION_WHITESPACE]) {
        case XML_UNSERIALIZER_WHITESPACE_KEEP:
            $data = $this->_dataStack[$this->_depth];
            break;
        case XML_UNSERIALIZER_WHITESPACE_NORMALIZE:
            $data = trim(preg_replace('/\s\s+/m', ' ',
                $this->_dataStack[$this->_depth]));
            break;
        case XML_UNSERIALIZER_WHITESPACE_TRIM:
        default:
            $data = trim($this->_dataStack[$this->_depth]);
            break;
        }

        // adjust type of the value
        switch(strtolower($value['type'])) {

        // unserialize an object
        case 'object':
            if (isset($value['class'])) {
                $classname = $value['class'];
            } else {
                $classname = '';
            }
            // instantiate the class
            if ($this->options[XML_UNSERIALIZER_OPTION_TAG_AS_CLASSNAME] === true
                && class_exists($classname)
            ) {
                $value['value'] = new $classname;
            } else {
                $value['value'] =
                    new $this->options[XML_UNSERIALIZER_OPTION_DEFAULT_CLASS];
            }
            if (trim($data) !== '') {
                if ($value['guessType'] === true) {
                    $data = $this->_guessAndSetType($data);
                }
                $value['children'][$this->
                    options[XML_UNSERIALIZER_OPTION_CONTENT_KEY]] = $data;
            }

            // set properties
            foreach ($value['children'] as $prop => $propVal) {
                // check whether there is a special method to set this property
                $setMethod = 'set'.$prop;
                if (method_exists($value['value'], $setMethod)) {
                    call_user_func(array(&$value['value'], $setMethod), $propVal);
                } else {
                    $value['value']->$prop = $propVal;
                }
            }
            //  check for magic function
            if (method_exists($value['value'], '__wakeup')) {
                $value['value']->__wakeup();
            }
            break;

        // unserialize an array
        case 'array':
            if (trim($data) !== '') {
                if ($value['guessType'] === true) {
                    $data = $this->_guessAndSetType($data);
                }
                $value['children'][$this->
                    options[XML_UNSERIALIZER_OPTION_CONTENT_KEY]] = $data;
            }
            if (isset($value['children'])) {
                $value['value'] = $value['children'];
            } else {
                $value['value'] = array();
            }
            break;

        // unserialize a null value
        case 'null':
            $data = null;
            break;

        // unserialize a resource => this is not possible :-(
        case 'resource':
            $value['value'] = $data;
            break;

        // unserialize any scalar value
        default:
            if ($value['guessType'] === true) {
                $data = $this->_guessAndSetType($data);
            } else {
                settype($data, $value['type']);
            }

            $value['value'] = $data;
            break;
        }
        $parent = array_pop($this->_valStack);
        if ($parent === null) {
            $this->_unserializedData = &$value['value'];
            $this->_root             = &$value['name'];
            return true;
        } else {
            // parent has to be an array
            if (!isset($parent['children']) || !is_array($parent['children'])) {
                $parent['children'] = array();
                if (!in_array($parent['type'], array('array', 'object'))) {
                    $parent['type'] = $this->_getComplexType($parent['name']);
                    if ($parent['type'] == 'object') {
                        $parent['class'] = $parent['name'];
                    }
                }
            }

            if (in_array($element,
                $this->options[XML_UNSERIALIZER_OPTION_IGNORE_KEYS])
            ) {
                $ignoreKey = true;
            } else {
                $ignoreKey = false;
            }

            if (!empty($value['name']) && $ignoreKey === false) {
                // there already has been a tag with this name
                if (in_array($value['name'], $parent['childrenKeys'])
                    || in_array($value['name'],
                    $this->options[XML_UNSERIALIZER_OPTION_FORCE_ENUM])
                ) {
                    // no aggregate has been created for this tag
                    if (!in_array($value['name'], $parent['aggregKeys'])) {
                        if (isset($parent['children'][$value['name']])) {
                            $parent['children'][$value['name']] =
                                array($parent['children'][$value['name']]);
                        } else {
                            $parent['children'][$value['name']] = array();
                        }
                        array_push($parent['aggregKeys'], $value['name']);
                    }
                    array_push($parent['children'][$value['name']], $value['value']);
                } else {
                    $parent['children'][$value['name']] = &$value['value'];
                    array_push($parent['childrenKeys'], $value['name']);
                }
            } else {
                array_push($parent['children'], $value['value']);
            }
            array_push($this->_valStack, $parent);
        }

        $this->_depth--;
    }

    /**
     * Handler for character data
     *
     * @param object $parser XML parser object
     * @param string $cdata  CDATA
     *
     * @return void
     * @access private
     */
    function cdataHandler($parser, $cdata)
    {
        if ($this->options[XML_UNSERIALIZER_OPTION_DECODE_FUNC] !== null) {
            $cdata = call_user_func($this->
                options[XML_UNSERIALIZER_OPTION_DECODE_FUNC], $cdata);
        }
        $this->_dataStack[$this->_depth] .= $cdata;
    }

    /**
     * get the complex type, that should be used for a specified tag
     *
     * @param string $tagname name of the tag
     *
     * @return string complex type ('array' or 'object')
     * @access private
     */
    function _getComplexType($tagname)
    {
        if (is_string($this->options[XML_UNSERIALIZER_OPTION_COMPLEXTYPE])) {
            return $this->options[XML_UNSERIALIZER_OPTION_COMPLEXTYPE];
        }
        if (isset($this->options[XML_UNSERIALIZER_OPTION_COMPLEXTYPE][$tagname])) {
            return $this->options[XML_UNSERIALIZER_OPTION_COMPLEXTYPE][$tagname];
        }
        if (isset($this->options[XML_UNSERIALIZER_OPTION_COMPLEXTYPE]['#default'])) {
            return $this->options[XML_UNSERIALIZER_OPTION_COMPLEXTYPE]['#default'];
        }
        return 'array';
    }

    /**
     * create the XML_Parser instance
     *
     * @return boolean
     * @access private
     */
    function _createParser()
    {
        if (is_object($this->_parser)) {
            $this->_parser->free();
            unset($this->_parser);
        }
        $this->_parser = new XML_Parser($this->
            options[XML_UNSERIALIZER_OPTION_ENCODING_SOURCE],
            'event', $this->options[XML_UNSERIALIZER_OPTION_ENCODING_TARGET]);

        $this->_parser->folding = false;
        $this->_parser->setHandlerObj($this);
        return true;
    }
}
?>