public function __construct($input, $maxDepth = 20)
 {
     if (!is_string($input)) {
         throw new XmlToArrayException('No valid input.');
     }
     $this->_maxDepth = $maxDepth;
     $XMLParser = xml_parser_create();
     xml_parser_set_option($XMLParser, XML_OPTION_SKIP_WHITE, false);
     xml_parser_set_option($XMLParser, XML_OPTION_CASE_FOLDING, false);
     xml_parser_set_option($XMLParser, XML_OPTION_TARGET_ENCODING, 'UTF-8');
     xml_set_character_data_handler($XMLParser, array($this, '_contents'));
     xml_set_default_handler($XMLParser, array($this, '_default'));
     xml_set_element_handler($XMLParser, array($this, '_start'), array($this, '_end'));
     xml_set_external_entity_ref_handler($XMLParser, array($this, '_externalEntity'));
     xml_set_notation_decl_handler($XMLParser, array($this, '_notationDecl'));
     xml_set_processing_instruction_handler($XMLParser, array($this, '_processingInstruction'));
     xml_set_unparsed_entity_decl_handler($XMLParser, array($this, '_unparsedEntityDecl'));
     if (!xml_parse($XMLParser, $input, true)) {
         $errorCode = xml_get_error_code($XMLParser);
         $message = sprintf('%s. line: %d, char: %d' . ($this->_tagStack ? ', tag: %s' : ''), xml_error_string($errorCode), xml_get_current_line_number($XMLParser), xml_get_current_column_number($XMLParser) + 1, implode('->', $this->_tagStack));
         xml_parser_free($XMLParser);
         throw new XmlToArrayException($message, $errorCode);
     }
     xml_parser_free($XMLParser);
 }

 function AbstractSAXParser()
 {
     // create a parser
     $this->parserResource = xml_parser_create();
     if (isset($this->parserResource)) {
         // allowing object instance to use the xml parser
         xml_set_object($this->parserResource, $this);
         // set tag event handler
         xml_set_element_handler($this->parserResource, "startTagElement", "endTagElement");
         // set CDATA event handler
         xml_set_character_data_handler($this->parserResource, "cdataElement");
         // set processing instruction handler
         xml_set_processing_instruction_handler($this->parserResource, "instructionElement");
         // set undeclare entity
         xml_set_unparsed_entity_decl_handler($this->parserResource, "undeclaredEntityElement");
         // set notation delcaration handler
         xml_set_notation_decl_handler($this->parserResource, "notationDeclarationElement");
         // set external entity handler
         xml_set_external_entity_ref_handler($this->parserResource, "externalEntityElement");
         // seat default parser option
         xml_parser_set_option($this->parserResource, XML_OPTION_SKIP_WHITE, 1);
         xml_parser_set_option($this->parserResource, XML_OPTION_CASE_FOLDING, 0);
         xml_parser_set_option($this->parserResource, XML_OPTION_TARGET_ENCODING, 'UTF-8');
     }
 }

 function parse($data)
 {
     $parser = xml_parser_create();
     xml_set_object($parser, $this);
     xml_set_processing_instruction_handler($parser, "PIHandler");
     xml_parse($parser, $data, true);
     xml_parser_free($parser);
 }

 function XMLParser()
 {
     $this->parser = xml_parser_create();
     xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, FALSE);
     xml_set_element_handler($this->parser, "startElementhandler", "endElementHandler");
     xml_set_character_data_handler($this->parser, "cdataHandler");
     xml_set_processing_instruction_handler($this->parser, "processingInstructionHandler");
     xml_set_default_handler($this->parser, "defaultHandler");
 }

function createParser($filename)
{
    $fh = fopen($filename, 'r');
    $parser = xml_parser_create();
    xml_set_element_handler($parser, "startElement", "endElement");
    xml_set_character_data_handler($parser, "characterData");
    xml_set_processing_instruction_handler($parser, "processingInstruction");
    xml_set_default_handler($parser, "default");
    return array($parser, $fh);
}

 protected function createXmlParser($encoding = 'utf-8')
 {
     $xp = xml_parser_create($encoding);
     xml_parser_set_option($xp, XML_OPTION_CASE_FOLDING, true);
     xml_parser_set_option($xp, XML_OPTION_SKIP_WHITE, true);
     xml_set_object($xp, $this);
     xml_set_element_handler($xp, 'handleElementStart', 'handleElementEnd');
     xml_set_character_data_handler($xp, 'handleCharacterData');
     xml_set_processing_instruction_handler($xp, 'handleProcessingInstruction');
     return $xp;
 }

 /**
  * Class constructor
  * 
  * @param   string  The path of the file to parse
  * @param   string  A prefix path to add to all 'src' and 'href' attributes, if relative
  * @param   string  The output charset (default is UTF-8)
  * @return  void
  */
 public function __construct($file, $charset = 'UTF-8')
 {
     // The charset must be uppercase
     $charset = strtoupper($charset);
     // Checks if the file exists
     if (!file_exists($file) || !is_file($file)) {
         // The file does not exist
         throw new Woops_Xml_Parser_Exception('The specified XML file (\'' . $file . '\') does not exist', Woops_Xml_Parser_Exception::EXCEPTION_NO_FILE);
     }
     // Checks if the file is readable
     if (!is_readable($file)) {
         // Cannot read the file
         throw new Woops_Xml_Parser_Exception('The specified XML file (\'' . $file . '\') is not readable', Woops_Xml_Parser_Exception::EXCEPTION_FILE_NOT_READABLE);
     }
     // Checks if the charset is supported
     if (!isset(self::$_charsets[$charset])) {
         // Unsupported charset
         throw new Woops_Xml_Parser_Exception('The specified charset (' . $charset . ') is not supported', Woops_Xml_Parser_Exception::EXCEPTION_INVALID_CHARSET);
     }
     // Creates an XML parser
     $this->_parser = xml_parser_create($charset);
     // Sets the current instance as the XML parser object
     xml_set_object($this->_parser, $this);
     // Disables case-folding
     xml_parser_set_option($this->_parser, XML_OPTION_CASE_FOLDING, false);
     // Sets the element handler methods
     xml_set_element_handler($this->_parser, '_startElementHandler', '_endElementHandler');
     // Sets the character data handler method
     xml_set_character_data_handler($this->_parser, '_characterDataHandler');
     // Sets the processing instruction handler method
     xml_set_processing_instruction_handler($this->_parser, '_processingInstructionHandler');
     // Sets the default data handler method
     xml_set_default_handler($this->_parser, '_defaultHandler');
     // Tries to open a file handler
     if ($fileHandler = fopen($file, 'r')) {
         // Reads data from the file
         while ($data = fread($fileHandler, 4096)) {
             // Tries to parse the data
             if (!xml_parse($this->_parser, $data, feof($fileHandler))) {
                 // Gets the error string and line number
                 $errorString = xml_error_string(xml_get_error_code($this->_parser));
                 $errorLine = xml_get_current_line_number($this->_parser);
                 // Throws an exception, as we have an XML error
                 throw new Woops_Xml_Parser_Exception('XML parser error: ' . $errorString . ' at line number ' . $errorLine, Woops_Xml_Parser_Exception::EXCEPTION_XML_PARSER_ERROR);
             }
         }
         // Closes the file handler
         fclose($fileHandler);
     }
     // Frees the parser
     xml_parser_free($this->_parser);
 }

 function parse($xml)
 {
     $this->node_list = array(0 => array('type' => 'start', 'children' => array()));
     $this->cur_nodeid = 0;
     $this->parser = xml_parser_create();
     xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, 0);
     xml_parser_set_option($this->parser, XML_OPTION_SKIP_WHITE, 1);
     xml_set_element_handler($this->parser, array(&$this, 'handle_element_open'), array(&$this, 'handle_element_close'));
     xml_set_character_data_handler($this->parser, array(&$this, 'handle_cdata'));
     xml_set_processing_instruction_handler($this->parser, array(&$this, 'handle_instruction'));
     xml_set_default_handler($this->parser, array(&$this, 'handle_default'));
     xml_parse($this->parser, $xml, true);
     xml_parser_free($this->parser);
     $this->parser = null;
     return $this->node_list;
 }

 /**
  * Take the input $xml and turn it into WBXML. This is _not_ the
  * intended way of using this class. It is derived from
  * Contenthandler and one should use it as a ContentHandler and
  * produce the XML-structure with startElement(), endElement(),
  * and characters().
  *
  * @throws Horde_Xml_Wbxml_Exception
  */
 public function encode($xml)
 {
     // Create the XML parser and set method references.
     $this->_parser = xml_parser_create_ns($this->_charset);
     xml_set_object($this->_parser, $this);
     xml_parser_set_option($this->_parser, XML_OPTION_CASE_FOLDING, false);
     xml_set_element_handler($this->_parser, '_startElement', '_endElement');
     xml_set_character_data_handler($this->_parser, '_characters');
     xml_set_processing_instruction_handler($this->_parser, '');
     xml_set_external_entity_ref_handler($this->_parser, '');
     if (!xml_parse($this->_parser, $xml)) {
         throw new Horde_Xml_Wbxml_Exception(sprintf('XML error: %s at line %d', xml_error_string(xml_get_error_code($this->_parser)), xml_get_current_line_number($this->_parser)));
     }
     xml_parser_free($this->_parser);
     return $this->_output;
 }

 function SaxParser(&$input)
 {
     $this->level = 0;
     $this->parser = xml_parser_create('UTF-8');
     xml_set_object($this->parser, $this);
     $this->input =& $input;
     $this->setCaseFolding(false);
     $this->useUtfEncoding();
     xml_set_element_handler($this->parser, 'handleBeginElement', 'handleEndElement');
     xml_set_character_data_handler($this->parser, 'handleCharacterData');
     xml_set_processing_instruction_handler($this->parser, 'handleProcessingInstruction');
     xml_set_default_handler($this->parser, 'handleDefault');
     xml_set_unparsed_entity_decl_handler($this->parser, 'handleUnparsedEntityDecl');
     xml_set_notation_decl_handler($this->parser, 'handleNotationDecl');
     xml_set_external_entity_ref_handler($this->parser, 'handleExternalEntityRef');
 }

 protected function parse($xmlData)
 {
     $this->parser = xml_parser_create();
     xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, false);
     xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, "ISO-8859-1");
     xml_set_object($this->parser, $this);
     xml_set_element_handler($this->parser, 'onTagStart', 'onTagEnd');
     xml_set_character_data_handler($this->parser, 'onTagContent');
     xml_set_processing_instruction_handler($this->parser, "onPiHandler");
     xml_set_default_handler($this->parser, "onDefaultHandler");
     if (!xml_parse($this->parser, $xmlData)) {
         $xmlErroCode = xml_get_error_code($this->parser);
         $xmlErroString = xml_error_string($xmlErroCode);
         $xmlLine = xml_get_current_line_number($this->parser);
         die(sprintf("XML error: %s at line %d", $xmlErroString, $xmlLine));
     }
     xml_parser_free($this->parser);
     $this->parser = NULL;
 }

 protected final function init()
 {
     if ($this instanceof Features\IXmlNamespaceParser) {
         $this->parser = xml_parser_create_ns('UTF-8');
         // Set up start namespace declaration handler
         xml_set_start_namespace_decl_handler($this->parser, 'ns_start');
         // Set up end namespace declaration handler
         xml_set_end_namespace_decl_handler($this->parser, 'ns_end');
     } elseif ($this instanceof Features\IXmlBasicParser) {
         $this->parser = xml_parser_create('UTF-8');
     } else {
         throw new \BadMethodCallException('This class does not implements the XML Parser capabilities. Please implement either IXmlBasicParser or IXmlNamespaceParser.');
     }
     xml_set_object($this->parser, $this);
     foreach ($this->options as $option => $value) {
         xml_parser_set_option($this->parser, $option, $value);
     }
     if ($this instanceof Features\IXmlProcessorParser) {
         // Set up processing instruction (PI) handler
         xml_set_processing_instruction_handler($this->parser, 'pi_handler');
     }
     if ($this instanceof Features\IXmlEntityHandler) {
         // Set up external entity reference handler
         xml_set_external_entity_ref_handler($this->parser, 'entity_handler');
     }
     if ($this instanceof Features\IXmlNdataHandler) {
         // Set up notation declaration handler
         xml_set_notation_decl_handler($this->parser, 'notation_handler');
         // Set up unparsed entity declaration handler
         xml_set_unparsed_entity_decl_handler($this->parser, 'ndata_handler');
     }
     xml_set_element_handler($this->parser, "element_start", "element_end");
     xml_set_character_data_handler($this->parser, "cdata_handler");
     if ($this instanceof Features\IXmlDefaultHandler) {
         if (!defined('ACTIVATE_XML_PARSER_DEFAULT_HANDLER_I_KNOW_WHAT_AM_I_DOING')) {
             trigger_error('Active default handler interferes with many XML features like internal parsable entities.', E_USER_WARNING);
         }
         // Set up default (fallback) handler.
         // Warning: Interferes with INTERNAL ENTITY declarations like
         // <!ENTITY a 'b'>
         xml_set_default_handler($this->parser, "default_handler");
     }
 }

 function runtest($num, $i)
 {
     $this->readfile($num);
     echo "parsing xml data file {$this->currentFile} iteration {$i}\n";
     $xml_parser = xml_parser_create();
     xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, 1);
     xml_set_object($xml_parser, $this);
     xml_set_element_handler($xml_parser, 'startElement', 'endElement');
     xml_set_character_data_handler($xml_parser, 'cDataHandler');
     xml_set_external_entity_ref_handler($xml_parser, 'externalEntityRefHandler');
     xml_set_processing_instruction_handler($xml_parser, 'piHandler');
     xml_set_unparsed_entity_decl_handler($xml_parser, 'unparsedEntityDeclHandler');
     xml_set_notation_decl_handler($xml_parser, 'entityDeclHandler');
     xml_set_default_handler($xml_parser, 'defaultHandler');
     if (!xml_parse($xml_parser, $this->contentBuffer, true)) {
         $this->currentFile != '' ? $inFile = "in file {$this->currentFile}" : ($inFile = '');
         $this->fatalErrorPage(sprintf(get_class($this) . ": XML error: %s at line %d {$inFile}", xml_error_string(xml_get_error_code($xml_parser)), xml_get_current_line_number($xml_parser)));
     }
     xml_parser_free($xml_parser);
 }

 function __construct($xml = '', $params = self::XML_ENCLOSE)
 {
     $this->_params = $params;
     if ($xml) {
         if ($this->_params & self::XML_ARRAY2XML_FORMAT) {
             $domDocument = new CMS_DOMDocument();
             $domDocument->loadXML($xml, 0, false, false);
             $this->_arrOutput = $this->_xml2Array($domDocument->documentElement, $domDocument->encoding);
         } else {
             $parser = xml_parser_create(APPLICATION_DEFAULT_ENCODING);
             xml_set_object($parser, $this);
             xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
             xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);
             xml_set_element_handler($parser, "_tagOpen", "_tagClosed");
             xml_set_character_data_handler($parser, "_charData");
             xml_set_processing_instruction_handler($parser, "_piData");
             xml_set_default_handler($parser, "_tagData");
             //enclose with html tag
             if ($this->_params & self::XML_ENCLOSE) {
                 $xml = '<html>' . $xml . '</html>';
             }
             //add encoding declaration
             if ($this->_params ^ self::XML_DONT_ADD_XMLDECL) {
                 $xml = '<?xml version="1.0" encoding="' . APPLICATION_DEFAULT_ENCODING . '"?>' . "\n" . $xml;
             }
             if ($this->_params & self::XML_PROTECT_ENTITIES) {
                 $xml = $this->_codeEntities($xml);
             }
             if (!xml_parse($parser, $xml)) {
                 $this->_parsingError = sprintf("Parse error %s at line %d", xml_error_string(xml_get_error_code($parser)), xml_get_current_line_number($parser));
                 if ($this->_params & ~self::XML_DONT_THROW_ERROR) {
                     $this->raiseError($this->_parsingError . " :\n" . $xml, true);
                 }
             }
             xml_parser_free($parser);
             unset($parser);
         }
     }
 }

 /**
  * Initializes the parser.
  *
  * The constructor method instantiates and configures the underlying XML
  * parser and its handlers.
  *
  * \param $encoding The character encoding to use for this parser. This
  * parameter is optional (defaults to null) and can be safely omitted. See
  * the PHP manual for xml_parser_create for more information about
  * encodings.
  */
 public function __construct($encoding = null)
 {
     $this->finalized = false;
     $this->cdata_buffer = array();
     $this->tags = array();
     /* Create the parser instance */
     if (is_null($encoding)) {
         $this->parser = xml_parser_create();
     } else {
         assert('is_string($encoding)');
         $this->parser = xml_parser_create($encoding);
     }
     /* Set some options */
     xml_parser_set_option($this->parser, XML_OPTION_SKIP_WHITE, 1);
     xml_parser_set_option($this->parser, XML_OPTION_CASE_FOLDING, false);
     /* Always use UTF-8 */
     xml_parser_set_option($this->parser, XML_OPTION_TARGET_ENCODING, 'UTF-8');
     /* Setup the handlers */
     xml_set_element_handler($this->parser, array(&$this, 'start_element_handler'), array(&$this, 'end_element_handler'));
     xml_set_character_data_handler($this->parser, array(&$this, '_handle_data'));
     xml_set_processing_instruction_handler($this->parser, array(&$this, 'handle_pi'));
     xml_set_default_handler($this->parser, array(&$this, '_default_handler'));
 }

 /**
  * Contructor.
  *
  * Initializes XML Parser object and pass it to $this->_parser.
  *
  * @access public
  */
 public function __construct()
 {
     $this->_parser = xml_parser_create();
     xml_parser_set_option($this->_parser, XML_OPTION_CASE_FOLDING, false);
     xml_set_object($this->_parser, $this);
     xml_set_element_handler($this->_parser, '_tagOpen', '_tagClose');
     xml_set_character_data_handler($this->_parser, '_cdata');
     xml_set_default_handler($this->_parser, '_hDefault');
     xml_set_processing_instruction_handler($this->_parser, '_PIHandler');
 }

 /**
  * Parses string.
  * 
  * This method parses string given in the passed parameter.
  * 
  * @param   string      XML data.
  * @param   boolean     end of file.
  * @access  public
  * @see     parseFile()
  */
 function parse($data, $eof = true)
 {
     if (!is_resource($this->_parser)) {
         $this->_parser = xml_parser_create();
         xml_set_object($this->_parser, &$this);
         xml_parser_set_option($this->_parser, XML_OPTION_CASE_FOLDING, 0);
         xml_set_element_handler($this->_parser, '_startElementHandler', '_endElementHandler');
         xml_set_character_data_handler($this->_parser, '_characterDataHandler');
         xml_set_processing_instruction_handler($this->_parser, '_processingInstructionHandler');
         xml_set_default_handler($this->_parser, '_defaultHandler');
         //xml_set_external_entity_ref_handler($this->_parser, '_externalEntityRefHandler');
         //xml_set_start_namespace_decl_handler($this->_parser, '_namespaceDeclHandler');
     }
     if (!xml_parse($this->_parser, $data, $eof)) {
         return $this->raiseError(sprintf("%s at line %d position %d\n", xml_error_string(xml_get_error_code($this->_parser)), xml_get_current_line_number($this->_parser), xml_get_current_column_number($this->_parser)));
     }
     if ($eof == true) {
         xml_parser_free($this->_parser);
         unset($this->_parser);
     }
 }

 /**
  * Parses xml text using Expat
  * @param Object A reference to the DOM document that the xml is to be parsed into
  * @param string The text to be parsed
  * @param boolean True if CDATA Section nodes are not to be converted into Text nodes
  * @return boolean True if the parsing is successful
  */
 function parse(&$myXMLDoc, $xmlText, $preserveCDATA = true)
 {
     $this->xmlDoc =& $myXMLDoc;
     $this->lastChild =& $this->xmlDoc;
     $this->preserveCDATA = $preserveCDATA;
     //create instance of expat parser (should be included in php distro)
     if (version_compare(phpversion(), '5.0', '<=')) {
         if ($this->xmlDoc->isNamespaceAware) {
             $parser = xml_parser_create_ns('');
         } else {
             $parser = xml_parser_create('');
         }
     } else {
         if ($this->xmlDoc->isNamespaceAware) {
             $parser = xml_parser_create_ns();
         } else {
             $parser = xml_parser_create();
         }
     }
     //set handlers for SAX events
     xml_set_object($parser, $this);
     xml_set_character_data_handler($parser, 'dataElement');
     xml_set_default_handler($parser, 'defaultDataElement');
     xml_set_notation_decl_handler($parser, 'notationElement');
     xml_set_processing_instruction_handler($parser, 'processingInstructionElement');
     xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
     xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1);
     if ($this->xmlDoc->isNamespaceAware) {
         xml_set_start_namespace_decl_handler($parser, 'startNamespaceDeclaration');
         xml_set_end_namespace_decl_handler($parser, 'endNamespaceDeclaration');
         xml_set_element_handler($parser, 'startElementNS', 'endElement');
         $this->namespaceURIMap[DOMIT_XML_NAMESPACE] = 'xml';
     } else {
         xml_set_element_handler($parser, 'startElement', 'endElement');
     }
     //parse out whitespace -  (XML_OPTION_SKIP_WHITE = 1 does not
     //seem to work consistently across versions of PHP and Expat
     $xmlText = eregi_replace('>' . "[[:space:]]+" . '<', '><', $xmlText);
     $success = xml_parse($parser, $xmlText);
     $this->xmlDoc->errorCode = xml_get_error_code($parser);
     $this->xmlDoc->errorString = xml_error_string($this->xmlDoc->errorCode);
     xml_parser_free($parser);
     return $success;
 }

function new_xml_parser($file)
{
    global $parser_file;
    $xml_parser = xml_parser_create();
    xml_parser_set_option($xml_parser, XML_OPTION_CASE_FOLDING, 1);
    xml_set_element_handler($xml_parser, "startElement", "endElement");
    xml_set_character_data_handler($xml_parser, "characterData");
    xml_set_processing_instruction_handler($xml_parser, "PIHandler");
    xml_set_default_handler($xml_parser, "defaultHandler");
    xml_set_external_entity_ref_handler($xml_parser, "externalEntityRefHandler");
    if (!($fp = @fopen($file, "r"))) {
        return false;
    }
    if (!is_array($parser_file)) {
        settype($parser_file, "array");
    }
    $parser_file[$xml_parser] = $file;
    return array($xml_parser, $fp);
}

 /**
  * Reads a string and parses the XML data.
  *
  * Parse the XML source and (upon success) store the information into an internal structure.
  * If a parent xpath is given this means that XML data is to be *appended* to that parent.
  *
  * ### If a function uses setLastError(), then say in the function header that getLastError() is useful.
  *
  * @param  $xmlString           (string) Name of the string to be read and parsed.
  * @param  $absoluteParentPath  (string) Node to append data too (see above)
  * @return                      (bool)   TRUE on success, FALSE on failure 
  *                                       (check getLastError())
  */
 function importFromString($xmlString, $absoluteParentPath = '')
 {
     $bDebugThisFunction = FALSE;
     if ($bDebugThisFunction) {
         $aStartTime = $this->_beginDebugFunction("importFromString");
         echo "Importing from string of length " . strlen($xmlString) . " to node '{$absoluteParentPath}'\n<br>";
         echo "Parser options:\n<br>";
         print_r($this->parseOptions);
     }
     $status = FALSE;
     $errStr = '';
     do {
         // try-block
         // If we already have content, then complain.
         if (!empty($this->nodeRoot) and empty($absoluteParentPath)) {
             $errStr = 'Called when this object already contains xml data. Use reset() or pass the parent Xpath as 2ed param to where tie data will append.';
             break;
             // try-block
         }
         // Check whether content has been read.
         if (empty($xmlString)) {
             // Nothing to do!!
             $status = TRUE;
             // If we were importing to root, build a blank root.
             if (empty($absoluteParentPath)) {
                 $this->_createSuperRoot();
             }
             $this->reindexNodeTree();
             //        $errStr = 'This xml document (string) was empty';
             break;
             // try-block
         } else {
             $xmlString = $this->_translateAmpersand($xmlString);
         }
         // Restart our node index with a root entry.
         $nodeStack = array();
         $this->parseStackIndex = 0;
         // If a parent xpath is given this means that XML data is to be *appended* to that parent.
         if (!empty($absoluteParentPath)) {
             // Check if parent exists
             if (!isset($nodeIndex[$absoluteParentPath])) {
                 $errStr = "You tried to append XML data to a parent '{$absoluteParentPath}' that does not exist.";
                 break;
                 // try-block
             }
             // Add it as the starting point in our array.
             $this->nodeStack[0] =& $nodeIndex[$absoluteParentPath];
         } else {
             // Build a 'super-root'
             $this->_createSuperRoot();
             // Put it in as the start of our node stack.
             $this->nodeStack[0] =& $this->nodeRoot;
         }
         // Point our text buffer reference at the next text part of the root
         $this->parsedTextLocation =& $this->nodeStack[0]['textParts'][];
         $this->parsInCData = 0;
         // We cache this now.
         $this->parseSkipWhiteCache = isset($this->parseOptions[XML_OPTION_SKIP_WHITE]) ? $this->parseOptions[XML_OPTION_SKIP_WHITE] : FALSE;
         // Create an XML parser.
         $parser = xml_parser_create();
         // Set default XML parser options.
         if (is_array($this->parseOptions)) {
             foreach ($this->parseOptions as $key => $val) {
                 xml_parser_set_option($parser, $key, $val);
             }
         }
         // Set the object and the element handlers for the XML parser.
         xml_set_object($parser, $this);
         xml_set_element_handler($parser, '_handleStartElement', '_handleEndElement');
         xml_set_character_data_handler($parser, '_handleCharacterData');
         xml_set_default_handler($parser, '_handleDefaultData');
         xml_set_processing_instruction_handler($parser, '_handlePI');
         if ($bDebugThisFunction) {
             $this->_profileFunction($aStartTime, "Setup for parse");
         }
         // Parse the XML source and on error generate an error message.
         if (!xml_parse($parser, $xmlString, TRUE)) {
             $source = empty($this->properties['xmlFile']) ? 'string' : 'file ' . basename($this->properties['xmlFile']) . "'";
             $errStr = "XML error in given {$source} on line " . xml_get_current_line_number($parser) . '  column ' . xml_get_current_column_number($parser) . '. Reason:' . xml_error_string(xml_get_error_code($parser));
             break;
             // try-block
         }
         // Free the parser.
         @xml_parser_free($parser);
         // And we don't need this any more.
         $this->nodeStack = array();
         if ($bDebugThisFunction) {
//.........这里部分代码省略.........