source: trunk/phpgwapi/inc/class.xml.inc.php @ 7655

<?php
                /*************************************************************************** 
                * Expresso Livre                                                           * 
                * http://www.expressolivre.org                                             * 
                * --------------------------------------------                             * 
                *  This program is free software; you can redistribute it and/or modify it * 
                *  under the terms of the GNU General Public License as published by the   * 
                *  Free Software Foundation; either version 2 of the License, or (at your  * 
                *  option) any later version.                                              * 
                \**************************************************************************/ 
                
//
// +----------------------------------------------------------------------+
// | <phpXML/> version 1.0                                                |
// | Copyright (c) 2001 Michael P. Mehl. All rights reserved.             |
// +----------------------------------------------------------------------+
// | Latest releases are available at http://phpxml.org/. For feedback or |
// | bug reports, please contact the author at mpm@phpxml.org. Thanks!    |
// +----------------------------------------------------------------------+
// | The contents of this file are subject to the Mozilla Public License  |
// | Version 1.1 (the "License"); you may not use this file except in     |
// | compliance with the License. You may obtain a copy of the License at |
// | http://www.mozilla.org/MPL/                                          |
// |                                                                      |
// | Software distributed under the License is distributed on an "AS IS"  |
// | basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See  |
// | the License for the specific language governing rights and           |
// | limitations under the License.                                       |
// |                                                                      |
// | The Original Code is <phpXML/>.                                      |
// |                                                                      |
// | The Initial Developer of the Original Code is Michael P. Mehl.       |
// | Portions created by Michael P. Mehl are Copyright (C) 2001 Michael   |
// | P. Mehl. All Rights Reserved.                                        |
// +----------------------------------------------------------------------+
// | Authors:                                                             |
// |   Michael P. Mehl <mpm@phpxml.org>                                   |
// +----------------------------------------------------------------------+
//

/**
* Class for accessing XML data through the XPath language.
*
* This class offers methods for accessing the nodes of a XML document using 
* the XPath language. You can add or remove nodes, set or modify their 
* content and their attributes. No additional PHP extensions like DOM XML 
* or something similar are required to use these features.
*
* @link      http://www.phpxml.org/ Latest release of this class
* @link      http://www.w3.org/TR/xpath W3C XPath Recommendation
* @copyright Copyright (c) 2001 Michael P. Mehl. All rights reserved.
* @author    Michael P. Mehl <mpm@phpxml.org>
* @version   1.0 (2001-03-08)
* @access    public
*/

class XML
{
    /**
    * List of all document nodes.
    *
    * This array contains a list of all document nodes saved as an
    * associative array.
    *
    * @access private
    * @var    array
    */
    var $nodes = array();
    
    /**
    * List of document node IDs.
    *
    * This array contains a list of all IDs of all document nodes that
    * are used for counting when adding a new node.
    *
    * @access private
    * @var    array
    */
    var $ids = array();
    
    /**
    * Current document path.
    *
    * This variable saves the current path while parsing a XML file and adding
    * the nodes being read from the file.
    *
    * @access private
    * @var    string
    */
    var $path = "";
    
    /**
    * Current document position.
    *
    * This variable counts the current document position while parsing a XML
    * file and adding the nodes being read from the file.
    *
    * @access private
    * @var    int
    */
    var $position = 0;
    
    /**
    * Path of the document root.
    *
    * This string contains the full path to the node that acts as the root
    * node of the whole document.
    *
    * @access private
    * @var    string
    */
    var $root = "";
    
    /**
    * Current XPath expression.
    *
    * This string contains the full XPath expression being parsed currently.
    *
    * @access private
    * @var    string
    */
    var $xpath    = "";
                                                                                
    /**
    * List of entities to be converted.
    *
    * This array contains a list of entities to be converted when an XPath
    * expression is evaluated.
    *
    * @access private
    * @var    array
    */
    var $entities = array ( "&" => "&amp;", "<" => "&lt;", ">" => "&gt;",
        "'" => "&apos", '"' => "&quot;" );
    
    /**
    * List of supported XPath axes.
    *
    * This array contains a list of all valid axes that can be evaluated in an
    * XPath expression.
    *
    * @access private
    * @var    array
    */
    var $axes = array ( "child", "descendant", "parent", "ancestor",
        "following-sibling", "preceding-sibling", "following", "preceding",
        "attribute", "namespace", "self", "descendant-or-self",
        "ancestor-or-self" );
    
    /**
    * List of supported XPath functions.
    *
    * This array contains a list of all valid functions that can be evaluated
    * in an XPath expression.
    *
    * @access private
    * @var    array
    */
    var $functions = array ( "last", "position", "count", "id", "name",
        "string", "concat", "starts-with", "contains", "substring-before",
        "substring-after", "substring", "string-length", "translate",
        "boolean", "not", "true", "false", "lang", "number", "sum", "floor",
        "ceiling", "round", "text" );
    
    /**
    * List of supported XPath operators.
    *
    * This array contains a list of all valid operators that can be evaluated
    * in a predicate of an XPath expression. The list is ordered by the
    * precedence of the operators (lowest precedence first).
    *
    * @access private
    * @var    array
    */
    var $operators = array( " or ", " and ", "=", "!=", "<=", "<", ">=", ">",
        "+", "-", "*", " div ", " mod " );

    /**
    * Constructor of the class.
    *
    * This constructor initializes the class and, when a filename is given,
    * tries to read and parse the given file.
    *
    * @access    public
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $file Path and name of the file to read and parsed.
    * @see       load_file()
    */
    function XML ( $file = "" )
    {
        // Check whether a file was given.
        if ( !empty($file) )
        {
            // Load the XML file.
            $this->load_file($file);
        }
    }

    /**
    * Reads a file and parses the XML data.
    *
    * This method reads the content of a XML file, tries to parse its
    * content and upon success stores the information retrieved from
    * the file into an array.
    *
    * @access    public
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $file Path and name of the file to be read and parsed.
    * @see       handle_start_element(), handle_end_element(),
    *            handle_character_data()
    */
    function load_file ( $file )
    {
        // Check whether the file exists and is readable.
        if ( file_exists($file) && is_readable($file) )
        {
            // Read the content of the file.
            $content = implode("", file($file));
            
            // Check whether content has been read.
            if ( !empty($content) )
            {
                // Create an XML parser.
                $parser = xml_parser_create();
                
                // Set the options for parsing the XML data.
                xml_parser_set_option($parser, XML_OPTION_SKIP_WHITE, 1); 
                xml_parser_set_option($parser, XML_OPTION_CASE_FOLDING, 0);
                
                // Set the object for the parser.
                xml_set_object($parser, &$this);
                
                // Set the element handlers for the parser.
                xml_set_element_handler($parser, "handle_start_element",
                    "handle_end_element");
                xml_set_character_data_handler($parser,
                    "handle_character_data");
                
                // Parse the XML file.
                if ( !xml_parse($parser, $content, true) )
                {
                    // Display an error message.
                    $this->display_error("XML error in file %s, line %d: %s",
                        $file, xml_get_current_line_number($parser),
                        xml_error_string(xml_get_error_code($parser)));
                }
                
                // Free the parser.
                xml_parser_free($parser);
            }
        }
        else
        {
            // Display an error message.
            $this->display_error("File %s could not be found or read.", $file);
        }
    }
    
    /**
    * Generates a XML file with the content of the current document.
    *
    * This method creates a string containing the XML data being read
    * and modified by this class before. This string can be used to save
    * a modified document back to a file or doing other nice things with
    * it.
    *
    * @access    public
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $highlight Array containing a list of full document
    *            paths of nodes to be highlighted by <font>...</font> tags
    *            in the generated XML string.
    * @param     string $root While doing a recursion with this method, this
    *            parameter is used for internal purpose.
    * @param     int $level While doing a recursion with this method, this
    *            parameter is used for internal purpose.
    * @return    string The returned string contains well-formed XML data
    *            representing the content of this document.
    * @see       load_file(), evaluate(), get_content()
    */
    function get_file ( $highlight = array(), $root = "", $level = 0 )
    {
        // Create a string to save the generated XML data.
        $xml = "";
        
        // Create two strings containing the tags for highlighting a node.
        $highlight_start = "<font color=\"#FF0000\"><b>";
        $highlight_end   = "</b></font>";
        
        // Generate a string to be displayed before the tags.
        $before = "";
        
        // Calculate the amount of whitespaces to display.
        for ( $i = 0; $i < ( $level * 2 ); ++$i )
        {
            // Add a whitespaces to the string.
            $before .= " ";
        }
        
        // Check whether a root node is given.
        if ( empty($root) )
        {
            // Set it to the document root.
            $root = $this->root;
        }
        
        // Check whether the node is selected.
        $selected = in_array($root, $highlight);
        
        // Now add the whitespaces to the XML data.
        $xml .= $before;
        
        // Check whether the node is selected.
        if ( $selected )
        {
            // Add the highlight code to the XML data.
            $xml .= $highlight_start;
        }
        
        // Now open the tag.
        $xml .= "&lt;".$this->nodes[$root]["name"];
        
        // Check whether there are attributes for this node.
        if ( count($this->nodes[$root]["attributes"]) > 0 )
        {
            // Run through all attributes.
            foreach ( $this->nodes[$root]["attributes"] as $key => $value )
            {
                // Check whether this attribute is highlighted.
                if ( in_array($root."/attribute::".$key, $highlight) )
                {
                    // Add the highlight code to the XML data.
                    $xml .= $highlight_start;
                }
                
                // Add the attribute to the XML data.
                $xml .= " ".$key."=\"".trim(stripslashes($value))."\"";
                
                // Check whether this attribute is highlighted.
                if ( in_array($root."/attribute::".$key, $highlight) )
                {
                    // Add the highlight code to the XML data.
                    $xml .= $highlight_end;
                }
            }
        }
        
        // Check whether the node contains character data or has children.
        if ( empty($this->nodes[$root]["text"]) &&
            !isset($this->nodes[$root]["children"]) )
        {
            // Add the end to the tag.
            $xml .= "/";
        }
        
        // Close the tag.
        $xml .= "&gt;\n";
        
        // Check whether the node is selected.
        if ( $selected )
        {
            // Add the highlight code to the XML data.
            $xml .= $highlight_end;
        }
        
        // Check whether the node contains character data.
        if ( !empty($this->nodes[$root]["text"]) )
        {
            // Add the character data to the XML data.
            $xml .= $before."  ".$this->nodes[$root]["text"]."\n";
        }
        
        // Check whether the node has children.
        if ( isset($this->nodes[$root]["children"]) )
        {
            // Run through all children with different names.
            foreach ( $this->nodes[$root]["children"] as $child => $pos )
            {
                // Run through all children with the same name.
                for ( $i = 1; $i <= $pos; ++$i )
                {
                    // Generate the full path of the child.
                    $fullchild = $root."/".$child."[".$i."]";
                    
                    // Add the child's XML data to the existing data.
                    $xml .= $this->get_file($highlight, $fullchild,
                        $level + 1);
                }
            }
        }
        
        // Check whether there are attributes for this node.
        if ( !empty($this->nodes[$root]["text"]) ||
            isset($this->nodes[$root]["children"]) )
        {
            // Add the whitespaces to the XML data.
            $xml .= $before;
            
            // Check whether the node is selected.
            if ( $selected )
            {
                // Add the highlight code to the XML data.
                $xml .= $highlight_start;
            }
            
            // Add the closing tag.
            $xml .= "&lt;/".$this->nodes[$root]["name"]."&gt;";
            
            // Check whether the node is selected.
            if ( $selected )
            {
                // Add the highlight code to the XML data.
                $xml .= $highlight_end;
            }
            
            // Add a linebreak.
            $xml .= "\n";
        }
        
        // Return the XML data.
        return $xml;
    }
    
    /**
    * Adds a new node to the XML document.
    *
    * This method adds a new node to the tree of nodes of the XML document
    * being handled by this class. The new node is created according to the
    * parameters passed to this method.
    *
    * @access    public
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $content Full path of the parent, to which the new
    *            node should be added as a child.
    * @param     string $name Name of the new node.
    * @return    string The string returned by this method will contain the
    *            full document path of the created node.
    * @see       remove_node(), evaluate()
    */
    function add_node ( $context, $name )
    {
        // Check whether a name for this element is already set.
        if ( empty($this->root) )
        {
            // Use this tag as the root element.
            $this->root = "/".$name."[1]";
        }
        
        // Calculate the full path for this element.
        $path = $context."/".$name;
        
        // Set the relative context and the position.
        $position = ++$this->ids[$path];
        $relative = $name."[".$position."]";
        
        // Calculate the full path.
        $fullpath = $context."/".$relative;
        
        // Calculate the context position, which is the position of this
        // element within elements of the same name in the parent node.
        $this->nodes[$fullpath]["context-position"] = $position;
        
        // Calculate the position for the following and preceding axis
        // detection.
        $this->nodes[$fullpath]["document-position"] =
            $this->nodes[$context]["document-position"] + 1;
        
        // Save the information about the node.
        $this->nodes[$fullpath]["name"]   = $name;
        $this->nodes[$fullpath]["text"]   = "";
        $this->nodes[$fullpath]["parent"] = $context;
        
        // Add this element to the element count array.
        if ( !$this->nodes[$context]["children"][$name] )
        {
            // Set the default name.
            $this->nodes[$context]["children"][$name] = 1;
        }
        else
        {
            // Calculate the name.
            $this->nodes[$context]["children"][$name] =
                $this->nodes[$context]["children"][$name] + 1;
        }
        
        // Return the path of the new node.
        return $fullpath;
    }

    /**
    * Removes a node from the XML document.
    *
    * This method removes a node from the tree of nodes of the XML document.
    * If the node is a document node, all children of the node and its
    * character data will be removed. If the node is an attribute node,
    * only this attribute will be removed, the node to which the attribute
    * belongs as well as its children will remain unmodified.
    *
    * @access    public
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node to be removed.
    * @see       add_node(), evaluate()
    */
    function remove_node ( $node )
    {
        // Check whether the node is an attribute node.
        if ( preg_match('/\/attribute::/', $node) )
        {
            // Get the path to the attribute node's parent.
            $parent = $this->prestr($node, "/attribute::");
            
            // Get the name of the attribute.
            $attribute = $this->afterstr($node, "/attribute::");
            
            // Check whether the attribute exists.
            if ( isset($this->nodes[$parent]["attributes"][$attribute]) )
            {
                // Create a new array.
                $new = array();
                
                // Run through the existing attributes.
                foreach ( $this->nodes[$parent]["attributes"]
                    as $key => $value )
                {
                    // Check whether it's the attribute to remove.
                    if ( $key != $attribute )
                    {
                        // Add it to the new array again.
                        $new[$key] = $value;
                    }
                }
                
                // Save the new attributes.
                $this->nodes[$parent]["attributes"] = $new;
            }
        }
        else
        {
            // Create an associative array, which contains information about
            // all nodes that required to be renamed.
            $rename = array();
            
            // Get the name, the parent and the siblings of current node.
            $name     = $this->nodes[$node]["name"];
            $parent   = $this->nodes[$node]["parent"];
            $siblings = $this->nodes[$parent]["children"][$name];
            
            // Decrease the number of children.
            $this->nodes[$parent]["children"][$name]--;
            
            // Create a counter for renumbering the siblings.
            $counter = 1;
            
            // Now run through the siblings.
            for ( $i = 1; $i <= $siblings; ++$i )
            {
                // Create the name of the sibling.
                $sibling = $parent."/".$name."[".$i."]";
                
                // Check whether it's the name of the current node.
                if ( $sibling != $node )
                {
                    // Create the new name for the sibling.
                    $new = $parent."/".$name."[".$counter."]";
                    
                    // Increase the counter.
                    ++$counter;
                    
                    // Add the old and the new name to the list of nodes
                    // to be renamed.
                    $rename[$sibling] = $new;
                }
            }
            
            // Create an array for saving the new node-list.
            $nodes = array();
            
            // Now run through through the existing nodes.
            foreach ( $this->nodes as $name => $values )
            {
                // Check the position of the path of the node to be deleted
                // in the path of the current node.
                $position = strpos($name, $node);

                // Check whether it's not the node to be deleted.
                if ( $position === false )
                {
                    // Run through the array of nodes to be renamed.
                    foreach ( $rename as $old => $new )
                    {
                        // Check whether this node and it's parent requires to
                        // be renamed.
                        $name             = str_replace($old, $new, $name);
                        $values["parent"] = str_replace($old, $new,
                            $values["parent"]);
                    }
                    
                    // Add the node to the list of nodes.
                    $nodes[$name] = $values;
                }
            }
            
            // Save the new array of nodes.
            $this->nodes = $nodes;
        }
    }

    /**
    * Add content to a node.
    *
    * This method adds content to a node. If it's an attribute node, then
    * the value of the attribute will be set, otherwise the character data of
    * the node will be set. The content is appended to existing content,
    * so nothing will be overwritten.
    *
    * @access    public
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $path Full document path of the node.
    * @param     string $value String containing the content to be added.
    * @see       get_content(), evaluate()
    */
    function add_content ( $path, $value )
    {
        // Check whether it's an attribute node.
        if ( preg_match('/\/attribute::/', $path) )
        {
            // Get the path to the attribute node's parent.
            $parent = $this->prestr($path, "/attribute::");
            
            // Get the parent node.
            $parent = $this->nodes[$parent];
            
            // Get the name of the attribute.
            $attribute = $this->afterstr($path, "/attribute::");
            
            // Set the attribute.
            $parent["attributes"][$attribute] .= $value;
        }
        else
        {
            // Set the character data of the node.
            $this->nodes[$path]["text"] .= $value;
        }
    }
    
    /**
    * Set the content of a node.
    *
    * This method sets the content of a node. If it's an attribute node, then
    * the value of the attribute will be set, otherwise the character data of
    * the node will be set. Existing content will be overwritten.
    *
    * @access    public
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $path Full document path of the node.
    * @param     string $value String containing the content to be set.
    * @see       get_content(), evaluate()
    */
    function set_content ( $path, $value )
    {
        // Check whether it's an attribute node.
        if ( preg_match('/\/attribute::/', $path) )
        {
            // Get the path to the attribute node's parent.
            $parent = $this->prestr($path, "/attribute::");
            
            // Get the parent node.
            $parent = $this->nodes[$parent];
            
            // Get the name of the attribute.
            $attribute = $this->afterstr($path, "/attribute::");
            
            // Set the attribute.
            $parent["attributes"][$attribute] = $value;
        }
        else
        {
            // Set the character data of the node.
            $this->nodes[$path]["text"] = $value;
        }
    }
    
    /**
    * Retrieves the content of a node.
    *
    * This method retrieves the content of a node. If it's an attribute
    * node, then the value of the attribute will be retrieved, otherwise
    * it'll be the character data of the node.
    *
    * @access    public
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $path Full document path of the node, from which the
    *            content should be retrieved.
    * @return    string The returned string contains either the value or the
    *            character data of the node.
    * @see       set_content(), evaluate()
    */
    function get_content ( $path )
    {
        // Check whether it's an attribute node.
        if ( preg_match('/\/attribute::/', $path) )
        {
            // Get the path to the attribute node's parent.
            $parent = $this->prestr($path, "/attribute::");
            
            // Get the parent node.
            $parent = $this->nodes[$parent];
            
            // Get the name of the attribute.
            $attribute = $this->afterstr($path, "/attribute::");
            
            // Get the attribute.
            $attribute = $parent["attributes"][$attribute];
            
            // Return the value of the attribute.
            return $attribute;
        }
        else
        {
            // Return the cdata of the node.
            return stripslashes($this->nodes[$path]["text"]);
        }
    }
    
    /**
    * Add attributes to a node.
    *
    * This method adds attributes to a node. Existing attributes will not be
    * overwritten.
    *
    * @access    public
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $path Full document path of the node, the attributes
    *            should be added to.
    * @param     array $attributes Associative array containing the new
    *            attributes for the node.
    * @see       set_content(), get_content()
    */
    function add_attributes ( $path, $attributes )
    {
        // Add the attributes to the node.
        $this->nodes[$path]["attributes"] = array_merge($attributes,
            $this->nodes[$path]["attributes"]);
    }
    
    /**
    * Sets the attributes of a node.
    *
    * This method sets the attributes of a node and overwrites all existing
    * attributes by doing this.
    *
    * @access    public
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $path Full document path of the node, the attributes
    *            of which should be set.
    * @param     array $attributes Associative array containing the new
    *            attributes for the node.
    * @see       set_content(), get_content()
    */
    function set_attributes ( $path, $attributes )
    {
        // Set the attributes of the node.
        $this->nodes[$path]["attributes"] = $attributes;
    }
    
    /**
    * Retrieves a list of all attributes of a node.
    *
    * This method retrieves a list of all attributes of the node specified in
    * the argument.
    *
    * @access    public
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $path Full document path of the node, from which the
    *            list of attributes should be retrieved.
    * @return    array The returned associative array contains the all
    *            attributes of the specified node.
    * @see       get_content(), $nodes, $ids
    */
    function get_attributes ( $path )
    {
        // Return the attributes of the node.
        return $this->nodes[$path]["attributes"];
    }
    
    /**
    * Retrieves the name of a document node.
    *
    * This method retrieves the name of document node specified in the
    * argument.
    *
    * @access    public
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $path Full document path of the node, from which the
    *            name should be retrieved.
    * @return    string The returned array contains the name of the specified
    *            node.
    * @see       get_content(), $nodes, $ids
    */
    function get_name ( $path )
    {
        // Return the name of the node.
        return $this->nodes[$path]["name"];
    }
    
    /**
    * Evaluates an XPath expression.
    *
    * This method tries to evaluate an XPath expression by parsing it. A
    * XML document has to be read before this method is able to work.
    *
    * @access    public
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $path XPath expression to be evaluated.
    * @param     string $context Full path of a document node, starting
    *            from which the XPath expression should be evaluated.
    * @return    array The returned array contains a list of the full
    *            document paths of all nodes that match the evaluated
    *            XPath expression.
    * @see       $nodes, $ids
    */
    function evaluate ( $path, $context = "" )
    {
        // Remove slashes and quote signs.
        $path = stripslashes($path);
        $path = str_replace("\"", "", $path);
        $path = str_replace("'", "", $path);
        
        // Split the paths into different paths.
        $paths = $this->split_paths($path);
        
        // Create an empty set to save the result.
        $result = array();
        
        // Run through all paths.
        foreach ( $paths as $path )
        {
            // Trim the path.
            $path = trim($path);
            
            // Save the current path.
            $this->xpath = $path;
        
            // Convert all entities.
            $path = strtr($path, array_flip($this->entities));
        
            // Split the path at every slash.
            $steps = $this->split_steps($path);
        
            // Check whether the first element is empty.
            if ( empty($steps[0]) )
            {
                // Remove the first and empty element.
                array_shift($steps);
            }
        
            // Start to evaluate the steps.
            $nodes = $this->evaluate_step($context, $steps);
        
            // Remove duplicated nodes.
            $nodes = array_unique($nodes);
            
            // Add the nodes to the result set.
            $result = array_merge($result, $nodes);
        }
        
        // Return the result.
        return $result;
    }
    
    /**
    * Handles opening XML tags while parsing.
    *
    * While parsing a XML document for each opening tag this method is
    * called. It'll add the tag found to the tree of document nodes.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     int $parser Handler for accessing the current XML parser.
    * @param     string $name Name of the opening tag found in the document.
    * @param     array $attributes Associative array containing a list of
    *            all attributes of the tag found in the document.
    * @see       handle_end_element(), handle_character_data(), $nodes, $ids
    */
    function handle_start_element ( $parser, $name, $attributes )
    {
        // Add a node.
        $this->path = $this->add_node($this->path, $name);
        
        // Set the attributes.
        $this->set_attributes($this->path, $attributes);
    }
    
    /**
    * Handles closing XML tags while parsing.
    *
    * While parsing a XML document for each closing tag this method is
    * called.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     int $parser Handler for accessing the current XML parser.
    * @param     string $name Name of the closing tag found in the document.
    * @see       handle_start_element(), handle_character_data(), $nodes, $ids
    */
    function handle_end_element ( $parser, $name )
    {
        // Jump back to the parent element.
        $this->path = substr($this->path, 0, strrpos($this->path, "/"));
    }
    
    /**
    * Handles character data while parsing.
    *
    * While parsing a XML document for each character data this method
    * is called. It'll add the character data to the document tree.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     int $parser Handler for accessing the current XML parser.
    * @param     string $text Character data found in the document.
    * @see       handle_start_element(), handle_end_element(), $nodes, $ids
    */
    function handle_character_data ( $parser, $text )
    {
        // Replace entities.
        $text = strtr($text, $this->entities);
        
        // Save the text.
        $this->add_content($this->path, addslashes(trim($text)));
    }
    
    /**
    * Splits an XPath expression into its different expressions.
    *
    * This method splits an XPath expression. Each expression can consists of
    * list of expression being separated from each other by a | character.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $expression The complete expression to be splitted
    *            into its different expressions.
    * @return    array The array returned from this method contains a list
    *            of all expressions found in the expression passed to this
    *            method as a parameter.
    * @see       evalute()
    */
    function split_paths ( $expression )
    {
        // Create an empty array.
        $paths = array();
        
        // Save the position of the slash.
        $position = -1;
        
        // Run through the expression.
        do
        {
            // Search for a slash.
            $position = $this->search_string($expression, "|");
            
            // Check whether a | was found.
            if ( $position >= 0 )
            {
                // Get the left part of the expression.
                $left  = substr($expression, 0, $position);
                $right = substr($expression, $position + 1);
                
                // Add the left value to the steps.
                $paths[] = $left;
                
                // Reduce the expression to the right part.
                $expression = $right;
            }
        }
        while ( $position > -1 );
        
        // Add the remaing expression to the list of steps.
        $paths[] = $expression;
        
        // Return the steps.
        return $paths;
    }
    
    /**
    * Splits an XPath expression into its different steps.
    *
    * This method splits an XPath expression. Each expression can consists of
    * list of steps being separated from each other by a / character.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $expression The complete expression to be splitted
    *            into its different steps.
    * @return    array The array returned from this method contains a list
    *            of all steps found in the expression passed to this
    *            method as a parameter.
    * @see       evalute()
    */
    function split_steps ( $expression )
    {
        // Create an empty array.
        $steps = array();
        
        // Replace a double slashes, because they'll cause problems otherwise.
        $expression = str_replace("//@", "/descendant::*/@", $expression);
        $expression = str_replace("//", "/descendant::", $expression);
        
        // Save the position of the slash.
        $position = -1;
        
        // Run through the expression.
        do
        {
            // Search for a slash.
            $position = $this->search_string($expression, "/");
            
            // Check whether a slash was found.
            if ( $position >= 0 )
            {
                // Get the left part of the expression.
                $left  = substr($expression, 0, $position);
                $right = substr($expression, $position + 1);
                
                // Add the left value to the steps.
                $steps[] = $left;
                
                // Reduce the expression to the right part.
                $expression = $right;
            }
        }
        while ( $position > -1 );
        
        // Add the remaing expression to the list of steps.
        $steps[] = $expression;
        
        // Return the steps.
        return $steps;
    }
    
    /**
    * Retrieves axis information from an XPath expression step.
    *
    * This method tries to extract the name of the axis and its node-test
    * from a given step of an XPath expression at a given node.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $step String containing a step of an XPath expression.
    * @param     string $node Full document path of the node on which the
    *            step is executed.
    * @return    array This method returns an array containing information
    *            about the axis found in the step.
    * @see       evaluate_step()
    */
    function get_axis ( $step, $node )
    {
        // Create an array to save the axis information.
        $axis = array(
            "axis"      => "",
            "node-test" => "",
            "predicate" => array()
        );
        
        // Check whether there are predicates.
        if ( preg_match('/\[/', $step) )
        {
            // Get the predicates.
            $predicates = substr($step, strpos($step, "["));
            
            // Reduce the step.
            $step = $this->prestr($step, "[");
            
            // Try to split the predicates.
            $predicates = str_replace("][", "]|[", $predicates);
            $predicates = explode("|", $predicates);
            
            // Run through all predicates.
            foreach ( $predicates as $predicate )
            {
                // Remove the brackets.
                $predicate = substr($predicate, 1, strlen($predicate) - 2);
                
                // Add the predicate to the list of predicates.
                $axis["predicate"][] = $predicate;
            }
        }
        
        // Check whether the axis is given in plain text.
        if ( $this->search_string($step, "::") > -1 )
        {
            // Split the step to extract axis and node-test.
            $axis["axis"]      = $this->prestr($step, "::");
            $axis["node-test"] = $this->afterstr($step, "::");
        }
        else
        {
            // Check whether the step is empty.
            if ( empty($step) )
            {
                // Set it to the default value.
                $step = ".";
            }
            
            // Check whether is an abbreviated syntax.
            if ( $step == "*" )
            {
                // Use the child axis and select all children.
                $axis["axis"]      = "child";
                $axis["node-test"] = "*";
            }
            elseif ( preg_match('/\(/', $step) )
            {
                // Check whether it's a function.
                if ( $this->is_function($this->prestr($step, "(")) )
                {
                    // Get the position of the first bracket.
                    $start = strpos($step, "(");
                    $end   = strpos($step, ")", $start);
                    
                    // Get everything before, between and after the brackets.
                    $before  = substr($step, 0, $start);
                    $between = substr($step, $start + 1, $end - $start - 1);
                    $after   = substr($step, $end + 1);
                    
                    // Trim each string.
                    $before  = trim($before);
                    $between = trim($between);
                    $after   = trim($after);
                    
                    // Save the evaluated function.
                    $axis["axis"]      = "function";
                    $axis["node-test"] = $this->evaluate_function($before,
                        $between, $node);
                }
                else
                {
                    // Use the child axis and a function.
                    $axis["axis"]      = "child";
                    $axis["node-test"] = $step;
                }
            }
            elseif ( preg_match('/^@/i', $step) )
            {
                // Use the attribute axis and select the attribute.
                $axis["axis"]      = "attribute";
                $axis["node-test"] = substr($step, 1);
            }
            elseif ( preg_match('/\]$/i', $step) )
            {
                // Use the child axis and select a position.
                $axis["axis"]      = "child";
                $axis["node-test"] = substr($step, strpos($step, "["));
            }
            elseif ( $step == "." )
            {
                // Select the self axis.
                $axis["axis"]      = "self";
                $axis["node-test"] = "*";
            }
            elseif ( $step == ".." )
            {
                // Select the parent axis.
                $axis["axis"]      = "parent";
                $axis["node-test"] = "*";
            }
            elseif ( preg_match('/^[a-zA-Z0-9\-_]+$/', $step) )
            {
                // Select the child axis and the child.
                $axis["axis"]      = "child";
                $axis["node-test"] = $step;
            }
            else
            {
                // Use the child axis and a name.
                $axis["axis"]      = "child";
                $axis["node-test"] = $step;
            }
        }

        // Check whether it's a valid axis.
        if ( !in_array($axis["axis"], array_merge($this->axes,
            array("function"))) )
        {
            // Display an error message.
            $this->display_error("While parsing an XPath expression, in ".
                "the step \"%s\" the invalid axis \"%s\" was found.",
                str_replace($step, "<b>".$step."</b>", $this->xpath),#
                $axis["axis"]);  
        }
        
        // Return the axis information.
        return $axis;
    }
    
    /**
    * Looks for a string within another string.
    *
    * This method looks for a string within another string. Brackets in the
    * string the method is looking through will be respected, which means that
    * only if the string the method is looking for is located outside of
    * brackets, the search will be successful.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $term String in which the search shall take place.
    * @param     string $expression String that should be searched.
    * @return    int This method returns -1 if no string was found, otherwise
    *            the offset at which the string was found.
    * @see       evaluate_step()
    */
    function search_string ( $term, $expression )
    {
        // Create a new counter for the brackets.
        $brackets = 0;
        
        // Run through the string.
        for ( $i = 0; $i < strlen($term); ++$i )
        {
            // Get the character at the position of the string.
            $character = substr($term, $i, 1);
            
            // Check whether it's a breacket.
            if ( ( $character == "(" ) || ( $character == "[" ) )
            {
                // Increase the number of brackets.
                ++$brackets;
            }
            elseif ( ( $character == ")" ) || ( $character == "]" ) )
            {
                // Decrease the number of brackets.
                $brackets--;
            }
            elseif ( $brackets == 0 )
            {
                // Check whether we can find the expression at this index.
                if ( substr($term, $i, strlen($expression)) == $expression )
                {
                    // Return the current index.
                    return $i;
                }
            }
        }
        
        // Check whether we had a valid number of brackets.
        if ( $brackets != 0 )
        {
            // Display an error message.
            $this->display_error("While parsing an XPath expression, in the ".
                "predicate \"%s\", there was an invalid number of brackets.",
                str_replace($term, "<b>".$term."</b>", $this->xpath));
        }

        // Nothing was found.
        return (-1);
    }
    
    /**
    * Checks for a valid function name.
    *
    * This method check whether an expression contains a valid name of an
    * XPath function.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $expression Name of the function to be checked.
    * @return    boolean This method returns true if the given name is a valid
    *            XPath function name, otherwise false.
    * @see       evaluate()
    */
    function is_function ( $expression )
    {
        // Check whether it's in the list of supported functions.
        if ( in_array($expression, $this->functions) )
        {
            // It's a function.
            return true;
        }
        else
        {
            // It's not a function.
            return false;
        }
    }
    
    /**
    * Evaluates a step of an XPath expression.
    *
    * This method tries to evaluate a step from an XPath expression at a
    * specific context.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $context Full document path of the context from
    *            which starting the step should be evaluated.
    * @param     array $steps Array containing the remaining steps of the
    *            current XPath expression.
    * @return    array This method returns an array containing all nodes
    *            that are the result of evaluating the given XPath step.
    * @see       evaluate()
    */
    function evaluate_step ( $context, $steps )
    {
        // Create an empty array for saving the nodes found.
        $nodes = array();

        // Check whether the context is an array of contexts.
        if ( is_array($context) )
        {
            // Run through the array.
            foreach ( $context as $path )
            {
                // Call this method for this single path.
                $nodes = array_merge($nodes,
                    $this->evaluate_step($path, $steps));
            }
        }
        else
        {
            // Get this step.
            $step = array_shift($steps);
            
            // Create an array to save the new contexts.
            $contexts = array();
            
            // Get the axis of the current step.
            $axis = $this->get_axis($step, $context);
            
            // Check whether it's a function.
            if ( $axis["axis"] == "function" )
            {
                // Check whether an array was return by the function.
                if ( is_array($axis["node-test"]) )
                {
                    // Add the results to the list of contexts.
                    $contexts = array_merge($contexts, $axis["node-test"]);
                }
                else
                {
                    // Add the result to the list of contexts.
                    $contexts[] = $axis["node-test"];
                }
            }
            else
            {
                // Create the name of the method.
                $method = "handle_axis_".str_replace("-", "_", $axis["axis"]);
            
                // Check whether the axis handler is defined.
                if ( !method_exists(&$this, $method) )
                {
                    // Display an error message.
                    $this->display_error("While parsing an XPath expression, ".
                        "the axis \"%s\" could not be handled, because this ".
                        "version does not support this axis.", $axis["axis"]);
                }
            
                // Perform an axis action.
                $contexts = call_user_method($method, &$this, $axis, $context);
            
                // Check whether there are predicates.
                if ( count($axis["predicate"]) > 0 )
                {
                    // Check whether each node fits the predicates.
                    $contexts = $this->check_predicates($contexts,
                        $axis["predicate"]);
                }
            }
            
            // Check whether there are more steps left.
            if ( count($steps) > 0 )
            {
                // Continue the evaluation of the next steps.
                $nodes = $this->evaluate_step($contexts, $steps);
            }
            else
            {
                // Save the found contexts.
                $nodes = $contexts;
            }
        }
        
        // Return the nodes found.
        return $nodes;
    }
    
    /**
    * Evaluates an XPath function
    *
    * This method evaluates a given XPath function with its arguments on a
    * specific node of the document.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $function Name of the function to be evaluated.
    * @param     string $arguments String containing the arguments being
    *            passed to the function.
    * @param     string $node Full path to the document node on which the
    *            function should be evaluated.
    * @return    mixed This method returns the result of the evaluation of
    *            the function. Depending on the function the type of the 
    *            return value can be different.
    * @see       evaluate()
    */
    function evaluate_function ( $function, $arguments, $node )
    {
        // Remove whitespaces.
        $function  = trim($function);
        $arguments = trim($arguments);

        // Create the name of the function handling function.
        $method = "handle_function_".str_replace("-", "_", $function);
        
        // Check whether the function handling function is available.
        if ( !method_exists(&$this, $method) )
        {
            // Display an error message.
            $this->display_error("While parsing an XPath expression, ".
                "the function \"%s\" could not be handled, because this ".
                "version does not support this function.", $function);
        }
        
        // Return the result of the function.
        return call_user_method($method, &$this, $node, $arguments);
    }
    
    /**
    * Evaluates a predicate on a node.
    *
    * This method tries to evaluate a predicate on a given node.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the predicate
    *            should be evaluated.
    * @param     string $predicate String containing the predicate expression
    *            to be evaluated.
    * @return    mixed This method is called recursively. The first call should
    *            return a boolean value, whether the node matches the predicate
    *            or not. Any call to the method being made during the recursion
    *            may also return other types for further processing.
    * @see       evaluate()
    */
    function evaluate_predicate ( $node, $predicate )
    {
        // Set the default position and the type of the operator.
        $position = 0;
        $operator = "";
        
        // Run through all operators and try to find them.
        foreach ( $this->operators as $expression )
        {
            // Check whether a position was already found.
            if ( $position <= 0 )
            {
                // Try to find the operator.
                $position = $this->search_string($predicate, $expression);
            
                // Check whether a operator was found.
                if ( $position > 0 )
                {
                    // Save the operator.
                    $operator = $expression;
                    
                    // Check whether it's the equal operator.
                    if ( $operator == "=" )
                    {
                        // Also look for other operators containing the
                        // equal sign.
                        if ( $this->search_string($predicate, "!=") ==
                            ( $position - 1 ) )
                        {
                            // Get the new position.
                            $position = $this->search_string($predicate, "!=");
                            
                            // Save the new operator.
                            $operator = "!=";
                        }
                        if ( $this->search_string($predicate, "<=") ==
                            ( $position - 1 ) )
                        {
                            // Get the new position.
                            $position = $this->search_string($predicate, "<=");
                            
                            // Save the new operator.
                            $operator = "<=";
                        }
                        if ( $this->search_string($predicate, ">=") ==
                            ( $position - 1 ) )
                        {
                            // Get the new position.
                            $position = $this->search_string($predicate, ">=");
                            
                            // Save the new operator.
                            $operator = ">=";
                        }
                    }
                }
            }
        }
        
        // Check whether the operator is a - sign.
        if ( $operator == "-" )
        {
            // Check whether it's not a function containing a - in its name.
            foreach ( $this->functions as $function )
            {
                // Check whether there's a - sign in the function name.
                if ( preg_match('/-/', $function) )
                {
                    // Get the position of the - in the function name.
                    $sign = strpos($function, "-");
                    
                    // Extract a substring from the predicate.
                    $sub = substr($predicate, $position - $sign,
                        strlen($function));
                        
                    // Check whether it's the function.
                    if ( $sub == $function )
                    {
                        // Don't use the operator.
                        $operator = "";
                        $position = -1;
                    }
                }
            }
        }
        elseif ( $operator == "*" )
        {
            // Get some substrings.
            $character = substr($predicate, $position - 1, 1);
            $attribute = substr($predicate, $position - 11, 11);
            
            // Check whether it's an attribute selection.
            if ( ( $character == "@" ) || ( $attribute == "attribute::" ) )
            {
                // Don't use the operator.
                $operator = "";
                $position = -1;
            }
        }
        
        // Check whether an operator was found.        
        if ( $position > 0 )
        {
            // Get the left and the right part of the expression.
            $left  = substr($predicate, 0, $position);
            $right = substr($predicate, $position + strlen($operator));
            
            // Remove whitespaces.
            $left  = trim($left);
            $right = trim($right);
            
            // Evaluate the left and the right part.
            $left  = $this->evaluate_predicate($node, $left);
            $right = $this->evaluate_predicate($node, $right);
            
            // Check the kind of operator.
            switch ( $operator )
            {
                case " or ":
                    // Return the two results connected by an "or".
                    return ( $left or $right );
                
                case " and ":
                    // Return the two results connected by an "and".
                    return ( $left and $right );
                
                case "=":
                    // Compare the two results.
                    return ( $left == $right );
                    
                case "!=":
                    // Check whether the two results are not equal.
                    return ( $left != $right );
                    
                case "<=":
                    // Compare the two results.
                    return ( $left <= $right );
                    
                case "<":
                    // Compare the two results.
                    return ( $left < $right );
                
                case ">=":
                    // Compare the two results.
                    return ( $left >= $right );
                    
                case ">":
                    // Compare the two results.
                    return ( $left > $right );
                    
                case "+":
                    // Return the result by adding one result to the other.
                    return ( $left + $right );
                
                case "-":
                    // Return the result by decrease one result by the other.
                    return ( $left - $right );
                
                case "*":
                    // Return a multiplication of the two results.
                    return ( $left * $right );
                    
                case " div ":
                    // Return a division of the two results.
                    if ( $right == 0 )
                    {
                        // Display an error message.
                        $this->display_error("While parsing an XPath ".
                            "predicate, a error due a division by zero ".
                            "occured.");
                    }
                    else
                    {
                        // Return the result of the division.
                        return ( $left / $right );
                    }
                    break;
                
                case " mod ":
                    // Return a modulo of the two results.
                    return ( $left % $right );
            }
        }
        
        // Check whether the predicate is a function.
        if ( preg_match('/\(/', $predicate) )
        {
            // Get the position of the first bracket.
            $start = strpos($predicate, "(");
            $end   = strpos($predicate, ")", $start);
            
            // Get everything before, between and after the brackets.
            $before  = substr($predicate, 0, $start);
            $between = substr($predicate, $start + 1, $end - $start - 1);
            $after   = substr($predicate, $end + 1);
            
            // Trim each string.
            $before  = trim($before);
            $between = trim($between);
            $after   = trim($after);
            
            // Check whether there's something after the bracket.
            if ( !empty($after) )
            {
                // Display an error message.
                $this->display_error("While parsing an XPath expression ".
                    "there was found an error in the predicate \"%s\", ".
                    "because after a closing bracket there was found ".
                    "something unknown.", str_replace($predicate,
                    "<b>".$predicate."</b>", $this->xpath));
            }
            
            // Check whether it's a function.
            if ( empty($before) && empty($after) )
            {
                // Evaluate the content of the brackets.
                return $this->evaluate_predicate($node, $between);
            }
            elseif ( $this->is_function($before) )
            {
                // Return the evaluated function.
                return $this->evaluate_function($before, $between, $node);
            }
            else
            {
                // Display an error message.
                $this->display_error("While parsing a predicate in an XPath ".
                    "expression, a function \"%s\" was found, which is not ".
                    "yet supported by the parser.", str_replace($before,
                    "<b>".$before."</b>", $this->xpath));
            }
        }
        
        // Check whether the predicate is just a digit.
        if ( preg_match('/^[0-9]+(\.[0-9]+)?$/', $predicate) ||
            preg_match('/^\.[0-9]+$/', $predicate) )
        {
            // Return the value of the digit.
            return doubleval($predicate);
        }
        
        // Check whether it's an XPath expression.
        $result = $this->evaluate($predicate, $node);
        if ( count($result) > 0 )
        {
            // Convert the array.
            $result = explode("|", implode("|", $result));
            
            // Get the value of the first result.
            $value = $this->get_content($result[0]);
            
            // Return the value.
            return $value;
        }
        
        // Return the predicate as a string.
        return $predicate;
    }
    
    /**
    * Checks whether a node matches predicates.
    *
    * This method checks whether a list of nodes passed to this method match
    * a given list of predicates. 
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $nodes Array of full paths of all nodes to be tested.
    * @param     array $predicates Array of predicates to use.
    * @return    array The array returned by this method contains a list of
    *            all nodes matching the given predicates.
    * @see       evaluate_step()
    */
    function check_predicates ( $nodes, $predicates )
    {
        // Create an empty set of nodes.
        $result = array();
        
        // Run through all nodes.
        foreach ( $nodes as $node )
        {
            // Create a variable whether to add this node to the node-set.
            $add = true;
            
            // Run through all predicates.
            foreach ( $predicates as $predicate )
            {
                // Check whether the predicate is just an number.
                if ( preg_match('/^[0-9]+$/', $predicate) )
                {
                    // Enhance the predicate.
                    $predicate .= "=position()";
                }
                
                // Do the predicate check.
                $check = $this->evaluate_predicate($node, $predicate);
                
                // Check whether it's a string.
                if ( is_string($check) && ( ( $check == "" ) ||
                    ( $check == $predicate ) ) )
                {
                    // Set the result to false.
                    $check = false;
                }
                
                // Check whether it's an integer.
                if ( is_int($check) )
                {
                    // Check whether it's the current position.
                    if ( $check == $this->handle_function_position($node, "") )
                    {
                        // Set it to true.
                        $check = true;
                    }
                    else
                    {
                        // Set it to false.
                        $check = false;
                    }
                }
                
                // Check whether the predicate is OK for this node.
                $add = $add && $check;
            }
            
            // Check whether to add this node to the node-set.
            if ( $add )
            {
                // Add the node to the node-set.
                $result[] = $node;
            }            
        }
        
        // Return the array of nodes.
        return $result;
    }
    
    /**
    * Checks whether a node matches a node-test.
    *
    * This method checks whether a node in the document matches a given
    * node-test.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $context Full path of the node, which should be tested
    *            for matching the node-test.
    * @param     string $node_test String containing the node-test for the
    *            node.
    * @return    boolean This method returns true if the node matches the
    *            node-test, otherwise false.
    * @see       evaluate()
    */
    function check_node_test ( $context, $node_test )
    {
        // Check whether it's a function.
        if ( preg_match('/\(/', $node_test) )
        {
            // Get the type of function to use.
            $function = $this->prestr($node_test, "(");
            
            // Check whether the node fits the method.
            switch ( $function )
            {
                case "node":
                    // Add this node to the list of nodes.
                    return true;
                    
                case "text":
                    // Check whether the node has some text.
                    if ( !empty($this->nodes[$context]["text"]) )
                    {
                        // Add this node to the list of nodes.
                        return true;
                    }
                    break;
                    
                case "comment":
                    // Check whether the node has some comment.
                    if ( !empty($this->nodes[$context]["comment"]) )
                    {
                        // Add this node to the list of nodes.
                        return true;
                    }
                    break;
                
                case "processing-instruction":
                    // Get the literal argument.
                    $literal = $this->afterstr($axis["node-test"], "(");
                    
                    // Cut the literal.
                    $literal = substr($literal, 0, strlen($literal) - 1);
                    
                    // Check whether a literal was given.
                    if ( !empty($literal) )
                    {
                        // Check whether the node's processing instructions
                        // are matching the literals given.
                        if ( $this->nodes[$context]
                            ["processing-instructions"] == $literal )
                        {
                            // Add this node to the node-set.
                            return true;
                        }
                    }
                    else
                    {
                        // Check whether the node has processing
                        // instructions.
                        if ( !empty($this->nodes[$context]
                            ["processing-instructions"]) )
                        {
                            // Add this node to the node-set.
                            return true;
                        }
                    }
                    break;
                    
                default:
                    // Display an error message.
                    $this->display_error("While parsing an XPath ".
                        "expression there was found an undefined ".
                        "function called \"%s\".",
                        str_replace($function, "<b>".$function."</b>",
                        $this->xpath));
            }
        }
        elseif ( $node_test == "*" )
        {
            // Add this node to the node-set.
            return true;
        }
        elseif ( preg_match('/^[a-zA-Z0-9\-_]+/', $node_test) )
        {
            // Check whether the node-test can be fulfilled.
            if ( $this->nodes[$context]["name"] == $node_test )
            {
                // Add this node to the node-set.
                return true;
            }
        }
        else
        {
            // Display an error message.
            $this->display_error("While parsing the XPath expression \"%s\" ".
                "an empty and therefore invalid node-test has been found.",
                $this->xpath);
        }
        
        // Don't add this context.
        return false;
    }
    
    /**
    * Handles the XPath child axis.
    *
    * This method handles the XPath child axis.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $axis Array containing information about the axis.
    * @param     string $context Node from which starting the axis should
    *            be processed.
    * @return    array This method returns an array containing all nodes 
    *            that were found during the evaluation of the given axis.
    * @see       evaluate()
    */
    function handle_axis_child ( $axis, $context )
    {
        // Create an empty node-set.
        $nodes = array();
        
        // Get a list of all children.
        $children = $this->nodes[$context]["children"];
        
        // Check whether there are children.
        if ( !empty($children) )
        {
            // Run through all children.
            foreach ( $children as $child_name => $child_position )
            {
                // Run through all childs with this name.
                for ( $i = 1; $i <= $child_position; ++$i )
                {
                    // Create the path of the child.
                    $child = $context."/".$child_name."[".$i."]";
                    
                    // Check whether 
                    if ( $this->check_node_test($child, $axis["node-test"]) )
                    {
                        // Add the child to the node-set.
                        $nodes[] = $child;
                    }
                }
            }
        }
        
        // Return the nodeset.
        return $nodes;
    }
    
    /**
    * Handles the XPath parent axis.
    *
    * This method handles the XPath parent axis.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $axis Array containing information about the axis.
    * @param     string $context Node from which starting the axis should
    *            be processed.
    * @return    array This method returns an array containing all nodes 
    *            that were found during the evaluation of the given axis.
    * @see       evaluate()
    */
    function handle_axis_parent ( $axis, $context )
    {
        // Create an empty node-set.
        $nodes = array();
        
        // Check whether the parent matches the node-test.
        if ( $this->check_node_test($this->nodes[$context]["parent"],
            $axis["node-test"]) )
        {
            // Add this node to the list of nodes.
            $nodes[] = $this->nodes[$context]["parent"];
        }
        
        // Return the nodeset.
        return $nodes;
    }
    
    /**
    * Handles the XPath attribute axis.
    *
    * This method handles the XPath attribute axis.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $axis Array containing information about the axis.
    * @param     string $context Node from which starting the axis should
    *            be processed.
    * @return    array This method returns an array containing all nodes 
    *            that were found during the evaluation of the given axis.
    * @see       evaluate()
    */
    function handle_axis_attribute ( $axis, $context )
    {
        // Create an empty node-set.
        $nodes = array();
        
        // Check whether all nodes should be selected.
        if ( $axis["node-test"] == "*" )
        {
            // Check whether there are attributes.
            if ( count($this->nodes[$context]["attributes"]) > 0 )
            {
                // Run through the attributes.
                foreach ( $this->nodes[$context]["attributes"] as
                    $key => $value )
                {
                    // Add this node to the node-set.
                    $nodes[] = $context."/attribute::".$key;
                }
            }
        }
        elseif ( !empty($this->nodes[$context]["attributes"]
            [$axis["node-test"]]) )
        {
            // Add this node to the node-set.
            $nodes[] = $context."/attribute::".$axis["node-test"];
        }
            
        // Return the nodeset.
        return $nodes;
    }

    /**
    * Handles the XPath self axis.
    *
    * This method handles the XPath self axis.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $axis Array containing information about the axis.
    * @param     string $context Node from which starting the axis should
    *            be processed.
    * @return    array This method returns an array containing all nodes 
    *            that were found during the evaluation of the given axis.
    * @see       evaluate()
    */
    function handle_axis_self ( $axis, $context )
    {
        // Create an empty node-set.
        $nodes = array();
        
        // Check whether the context match the node-test.
        if ( $this->check_node_test($context, $axis["node-test"]) )
        {
            // Add this node to the node-set.
            $nodes[] = $context;
        }

        // Return the nodeset.
        return $nodes;
    }

    /**
    * Handles the XPath descendant axis.
    *
    * This method handles the XPath descendant axis.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $axis Array containing information about the axis.
    * @param     string $context Node from which starting the axis should
    *            be processed.
    * @return    array This method returns an array containing all nodes 
    *            that were found during the evaluation of the given axis.
    * @see       evaluate()
    */
    function handle_axis_descendant ( $axis, $context )
    {
        // Create an empty node-set.
        $nodes = array();
        
        // Check whether the current node has children.
        if ( count($this->nodes[$context]["children"]) > 0 )
        {
            // Get a list of children.
            $children = $this->nodes[$context]["children"];
            
            // Run through all children.
            foreach ( $children as $child_name => $child_position )
            {
                // Run through all children of this name.
                for ( $i = 1; $i <= $child_position; ++$i )
                {
                    // Create the full path for the children.
                    $child = $context."/".$child_name."[".$i."]";
                    
                    // Check whether the child matches the node-test.
                    if ( $this->check_node_test($child, $axis["node-test"]) )
                    {
                        // Add the child to the list of nodes.
                        $nodes[] = $child;
                    }
                    
                    // Recurse to the next level.
                    $nodes = array_merge($nodes,
                        $this->handle_axis_descendant($axis, $child));
                }
            }
        }
        
        // Return the nodeset.
        return $nodes;
    }

    /**
    * Handles the XPath ancestor axis.
    *
    * This method handles the XPath ancestor axis.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $axis Array containing information about the axis.
    * @param     string $context Node from which starting the axis should
    *            be processed.
    * @return    array This method returns an array containing all nodes 
    *            that were found during the evaluation of the given axis.
    * @see       evaluate()
    */
    function handle_axis_ancestor ( $axis, $context )
    {
        // Create an empty node-set.
        $nodes = array();
        
        // Get the parent of the current node.
        $parent = $this->nodes[$context]["parent"];
        
        // Check whether the parent isn't empty.
        if ( !empty($parent) )
        {
            // Check whether the parent matches the node-test.
            if ( $this->check_node_test($parent, $axis["node-test"]) )
            {
                // Add the parent to the list of nodes.
                $nodes[] = $parent;
            }
            
            // Handle all other ancestors.
            $nodes = array_merge($nodes,
                $this->handle_axis_ancestor($axis, $parent));
        }
        
        // Return the nodeset.
        return $nodes;
    }

    /**
    * Handles the XPath namespace axis.
    *
    * This method handles the XPath namespace axis.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $axis Array containing information about the axis.
    * @param     string $context Node from which starting the axis should
    *            be processed.
    * @return    array This method returns an array containing all nodes 
    *            that were found during the evaluation of the given axis.
    * @see       evaluate()
    */
    function handle_axis_namespace ( $axis, $context )
    {
        // Create an empty node-set.
        $nodes = array();
        
        // Check whether all nodes should be selected.
        if ( !empty($this->nodes[$context]["namespace"]) )
        {
            // Add this node to the node-set.
            $nodes[] = $context;
        }
            
        // Return the nodeset.
        return $nodes;
    }
    
    /**
    * Handles the XPath following axis.
    *
    * This method handles the XPath following axis.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $axis Array containing information about the axis.
    * @param     string $context Node from which starting the axis should
    *            be processed.
    * @return    array This method returns an array containing all nodes 
    *            that were found during the evaluation of the given axis.
    * @see       evaluate()
    */
    function handle_axis_following ( $axis, $context )
    {
        // Create an empty node-set.
        $nodes = array();
        
        // Get the current document position.
        $position = $this->nodes[$context]["document-position"];
        
        // Create a flag, whether we already found the context node.
        $found = false;
        
        // Run through all nodes of the document.
        foreach ( $this->nodes as $node => $data )
        {
            // Check whether the context node has already been found.
            if ( $found )
            {
                // Check whether the position is correct.
                if ( $this->nodes[$node]["document-position"] == $position )
                {
                    // Check whether the node fits the node-test.
                    if ( $this->check_node_test($node, $axis["node-test"]) )
                    {
                        // Add the node to the list of nodes.
                        $nodes[] = $node;
                    }
                }
            }
            
            // Check whether this is the context node.
            if ( $node == $context )
            {
                // After this we'll look for more nodes.
                $found = true;
            }
        }
            
        // Return the nodeset.
        return $nodes;
    }
    
    /**
    * Handles the XPath preceding axis.
    *
    * This method handles the XPath preceding axis.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $axis Array containing information about the axis.
    * @param     string $context Node from which starting the axis should
    *            be processed.
    * @return    array This method returns an array containing all nodes 
    *            that were found during the evaluation of the given axis.
    * @see       evaluate()
    */
    function handle_axis_preceding ( $axis, $context )
    {
        // Create an empty node-set.
        $nodes = array();
        
        // Get the current document position.
        $position = $this->nodes[$context]["document-position"];
        
        // Create a flag, whether we already found the context node.
        $found = true;
        
        // Run through all nodes of the document.
        foreach ( $this->nodes as $node => $data )
        {
            // Check whether this is the context node.
            if ( $node == $context )
            {
                // After this we won't look for more nodes.
                $found = false;
            }
            
            // Check whether the context node has already been found.
            if ( $found )
            {
                // Check whether the position is correct.
                if ( $this->nodes[$node]["document-position"] == $position )
                {
                    // Check whether the node fits the node-test.
                    if ( $this->check_node_test($node, $axis["node-test"]) )
                    {
                        // Add the node to the list of nodes.
                        $nodes[] = $node;
                    }
                }
            }
        }
            
        // Return the nodeset.
        return $nodes;
    }
    
    /**
    * Handles the XPath following-sibling axis.
    *
    * This method handles the XPath following-sibling axis.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $axis Array containing information about the axis.
    * @param     string $context Node from which starting the axis should
    *            be processed.
    * @return    array This method returns an array containing all nodes 
    *            that were found during the evaluation of the given axis.
    * @see       evaluate()
    */
    function handle_axis_following_sibling ( $axis, $context )
    {
        // Create an empty node-set.
        $nodes = array();
        
        // Get all children from the parent.
        $siblings = $this->handle_axis_child($axis,
            $this->nodes[$context]["parent"]);
        
        // Create a flag whether the context node was already found.
        $found = false;
        
        // Run through all siblings.
        foreach ( $siblings as $sibling )
        {
            // Check whether the context node was already found.
            if ( $found )
            {
                // Check whether the sibling is a real sibling.
                if ( $this->nodes[$sibling]["name"] ==
                    $this->nodes[$context]["name"] )
                {
                    // Check whether the sibling matches the node-test.
                    if ( $this->check_node_test($sibling, $axis["node-test"]) )
                    {
                        // Add the sibling to the list of nodes.
                        $nodes[] = $sibling;
                    }
                }
            }
            
            // Check whether this is the context node.
            if ( $sibling == $context )
            {
                // Continue looking for other siblings.
                $found = true;
            }
        }
            
        // Return the nodeset.
        return $nodes;
    }
    
    /**
    * Handles the XPath preceding-sibling axis.
    *
    * This method handles the XPath preceding-sibling axis.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $axis Array containing information about the axis.
    * @param     string $context Node from which starting the axis should
    *            be processed.
    * @return    array This method returns an array containing all nodes 
    *            that were found during the evaluation of the given axis.
    * @see       evaluate()
    */
    function handle_axis_preceding_sibling ( $axis, $context )
    {
        // Create an empty node-set.
        $nodes = array();
        
        // Get all children from the parent.
        $siblings = $this->handle_axis_child($axis,
            $this->nodes[$context]["parent"]);
        
        // Create a flag whether the context node was already found.
        $found = true;
        
        // Run through all siblings.
        foreach ( $siblings as $sibling )
        {
            // Check whether this is the context node.
            if ( $sibling == $context )
            {
                // Don't continue looking for other siblings.
                $found = false;
            }
            
            // Check whether the context node was already found.
            if ( $found )
            {
                // Check whether the sibling is a real sibling.
                if ( $this->nodes[$sibling]["name"] ==
                    $this->nodes[$context]["name"] )
                {
                    // Check whether the sibling matches the node-test.
                    if ( $this->check_node_test($sibling, $axis["node-test"]) )
                    {
                        // Add the sibling to the list of nodes.
                        $nodes[] = $sibling;
                    }
                }
            }
        }
            
        // Return the nodeset.
        return $nodes;
    }
    
    /**
    * Handles the XPath descendant-or-self axis.
    *
    * This method handles the XPath descendant-or-self axis.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $axis Array containing information about the axis.
    * @param     string $context Node from which starting the axis should
    *            be processed.
    * @return    array This method returns an array containing all nodes 
    *            that were found during the evaluation of the given axis.
    * @see       evaluate()
    */
    function handle_axis_descendant_or_self ( $axis, $context )
    {
        // Create an empty node-set.
        $nodes = array();
        
        // Read the nodes.
        $nodes = array_merge(
            $this->handle_axis_descendant($axis, $context),
            $this->handle_axis_self($axis, $context));
        
        // Return the nodeset.
        return $nodes;
    }
    
    /**
    * Handles the XPath ancestor-or-self axis.
    *
    * This method handles the XPath ancestor-or-self axis.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     array $axis Array containing information about the axis.
    * @param     string $context Node from which starting the axis should
    *            be processed.
    * @return    array This method returns an array containing all nodes 
    *            that were found during the evaluation of the given axis.
    * @see       evaluate()
    */
    function handle_axis_ancestor_or_self ( $axis, $context )
    {
        // Create an empty node-set.
        $nodes = array();
        
        // Read the nodes.
        $nodes = array_merge(
            $this->handle_axis_ancestor($axis, $context),
            $this->handle_axis_self($axis, $context));
        
        // Return the nodeset.
        return $nodes;
    }
    
    /**
    * Handles the XPath function last.
    *
    * This method handles the XPath function last.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_last ( $node, $arguments )
    {
        // Calculate the size of the context.
        $parent   = $this->nodes[$node]["parent"];
        $children = $this->nodes[$parent]["children"];
        $context  = $children[$this->nodes[$node]["name"]];

        // Return the size.
        return $context;
    }

    /**
    * Handles the XPath function position.
    *
    * This method handles the XPath function position.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_position ( $node, $arguments )
    {
        // return the context-position.
        return $this->nodes[$node]["context-position"];
    }
    
    /**
    * Handles the XPath function count.
    *
    * This method handles the XPath function count.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_count ( $node, $arguments )
    {
        // Evaluate the argument of the method as an XPath and return
        // the number of results.
        return count($this->evaluate($arguments, $node));
    }
    
    /**
    * Handles the XPath function id.
    *
    * This method handles the XPath function id.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_id ( $node, $arguments )
    {
        // Trim the arguments.
        $arguments = trim($arguments);
        
        // Now split the arguments.
        $arguments = explode(" ", $arguments);
        
        // Check whether 
        
        // Create a list of nodes.
        $nodes = array();
        
        // Run through all document node.
        foreach ( $this->nodes as $node => $position )
        {
            // Check whether the node has the ID we're looking for.
            if ( in_array($this->nodes[$node]["attributes"]["id"],
                $arguments) )
            {
                // Add this node to the list of nodes.
                $nodes[] = $node;
            }
        }
        
        // Return the list of nodes.
        return $nodes;
    }
    
    /**
    * Handles the XPath function name.
    *
    * This method handles the XPath function name.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_name ( $node, $arguments )
    {
        // Return the name of the node.
        return $this->nodes[$node]["name"];
    }
    
    /**
    * Handles the XPath function string.
    *
    * This method handles the XPath function string.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_string ( $node, $arguments )
    {
        // Check what type of parameter is given
        if ( preg_match('/^[0-9]+(\.[0-9]+)?$/', $arguments) ||
            preg_match('/^\.[0-9]+$/', $arguments) )
        {
            // Convert the digits to a number.
            $number = doubleval($arguments);
                
            // Return the number.
            return strval($number);
        }
        elseif ( is_bool($arguments) )
        {
            // Check whether it's true.
            if ( $arguments == true )
            {
                // Return true as a string.
                return "true";
            }
            else
            {
                // Return false as a string.
                return "false";
            }
        }
        elseif ( !empty($arguments) )
        {
            // Use the argument as an XPath.
            $result = $this->evaluate($arguments, $node);
                
            // Get the first argument.
            $result = explode("|", implode("|", $result));
                
            // Return the first result as a string.
            return $result[0];
        }
        elseif ( empty($arguments) )
        {
            // Return the current node.
            return $node;
        }
        else
        {
            // Return an empty string.
            return "";
        }
    }
    
    /**
    * Handles the XPath function concat.
    *
    * This method handles the XPath function concat.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_concat ( $node, $arguments )
    {
        // Split the arguments.
        $arguments = explode(",", $arguments);
            
        // Run through each argument and evaluate it.
        for ( $i = 0; $i < sizeof($arguments); ++$i )
        {
            // Trim each argument.
            $arguments[$i] = trim($arguments[$i]);
                
            // Evaluate it.
            $arguments[$i] = $this->evaluate_predicate($node, $arguments[$i]);
        }
            
        // Put the string together.
        $arguments = implode("", $arguments);
            
        // Return the string.
        return $arguments;
    }
    
    /**
    * Handles the XPath function starts-with.
    *
    * This method handles the XPath function starts-with.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_starts_with ( $node, $arguments )
    {
        // Get the arguments.
        $first  = trim($this->prestr($arguments, ","));
        $second = trim($this->afterstr($arguments, ","));
            
        // Evaluate each argument.
        $first  = $this->evaluate_predicate($node, $first);
        $second = $this->evaluate_predicate($node, $second);
            
        // Check whether the first string starts with the second one.
        if ( preg_match('/^/'.$second, $first) )
        {
            // Return true.
            return true;
        }
        else
        {
            // Return false.
            return false;
        }
    }
    
    /**
    * Handles the XPath function contains.
    *
    * This method handles the XPath function contains.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_contains ( $node, $arguments )
    {
        // Get the arguments.
        $first  = trim($this->prestr($arguments, ","));
        $second = trim($this->afterstr($arguments, ","));
            
        // Evaluate each argument.
        $first  = $this->evaluate_predicate($node, $first);
        $second = $this->evaluate_predicate($node, $second);
            
        // Check whether the first string starts with the second one.
        if ( preg_match("/$second/", $first) )
        {
            // Return true.
            return true;
        }
        else
        {
            // Return false.
            return false;
        }
    }
    
    /**
    * Handles the XPath function substring-before.
    *
    * This method handles the XPath function substring-before.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_substring_before ( $node, $arguments )
    {
        // Get the arguments.
        $first  = trim($this->prestr($arguments, ","));
        $second = trim($this->afterstr($arguments, ","));
          
        // Evaluate each argument.
        $first  = $this->evaluate_predicate($node, $first);
        $second = $this->evaluate_predicate($node, $second);
            
        // Return the substring.
        return $this->prestr(strval($first), strval($second));
    }
    
    /**
    * Handles the XPath function substring-after.
    *
    * This method handles the XPath function substring-after.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_substring_after ( $node, $arguments )
    {
        // Get the arguments.
        $first  = trim($this->prestr($arguments, ","));
        $second = trim($this->afterstr($arguments, ","));
            
        // Evaluate each argument.
        $first  = $this->evaluate_predicate($node, $first);
        $second = $this->evaluate_predicate($node, $second);
            
        // Return the substring.
        return $this->afterstr(strval($first), strval($second));
    }
    
    /**
    * Handles the XPath function substring.
    *
    * This method handles the XPath function substring.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_substring ( $node, $arguments )
    {
        // Split the arguments.
        $arguments = explode(",", $arguments);
            
        // Run through all arguments.
        for ( $i = 0; $i < sizeof($arguments); ++$i )
        {
            // Trim the string.
            $arguments[$i] = trim($arguments[$i]);
                
            // Evaluate each argument.
            $arguments[$i] = $this->evaluate_predicate($node, $arguments[$i]);
        }
            
        // Check whether a third argument was given.
        if ( !empty($arguments[2]) )
        {
            // Return the substring.
            return substr(strval($arguments[0]), $arguments[1] - 1,
                $arguments[2]);
        }
        else
        {
            // Return the substring.
            return substr(strval($arguments[0]), $arguments[1] - 1);
        }
    }
    
    /**
    * Handles the XPath function string-length.
    *
    * This method handles the XPath function string-length.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_string_length ( $node, $arguments )
    {
        // Trim the argument.
        $arguments = trim($arguments);
            
        // Evaluate the argument.
        $arguments = $this->evaluate_predicate($node, $arguments);
            
        // Return the length of the string.
        return strlen(strval($arguments));
    }
    
    /**
    * Handles the XPath function translate.
    *
    * This method handles the XPath function translate.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_translate ( $node, $arguments )         
    {
        // Split the arguments.
        $arguments = explode(",", $arguments);
        
        // Run through all arguments.
        for ( $i = 0; $i < sizeof($arguments); ++$i )
        {
            // Trim the argument.
            $arguments[$i] = trim($arguments[$i]);
            
            // Evaluate the argument.
            $arguments[$i] = $this->evaluate_predicate($node, $arguments[$i]);
        }
            
        // Return the translated string.
        return strtr($arguments[0], $arguments[1], $arguments[2]);
    }
    
    /**
    * Handles the XPath function boolean.
    *
    * This method handles the XPath function boolean.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_boolean ( $node, $arguments )
    {
        // Trim the arguments.
        $arguments = trim($arguments);
        
        // Check what type of parameter is given
        if ( preg_match('/^[0-9]+(\.[0-9]+)?$/', $arguments) ||
            preg_match('/^\.[0-9]+$/', $arguments) )
        {
            // Convert the digits to a number.
            $number = doubleval($arguments);
            
            // Check whether the number zero.
            if ( $number == 0 )
            {
                // Return false.
                return false;
            }
            else
            {
                // Return true.
                return true;
            }
        }
        elseif ( empty($arguments) )
        {
            // Sorry, there were no arguments.
            return false;
        }
        else
        {
            // Try to evaluate the argument as an XPath.
            $result = $this->evaluate($arguments, $node);
            
            // Check whether we found something.
            if ( count($result) > 0 )
            {
                // Return true.
                return true;
            }
            else
            {
                // Return false.
                return false;
            }
        }
    }
    
    /**
    * Handles the XPath function not.
    *
    * This method handles the XPath function not.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_not ( $node, $arguments )
    {
        // Trim the arguments.
        $arguments = trim($arguments);
        
        // Return the negative value of the content of the brackets.
        return !$this->evaluate_predicate($node, $arguments);
    }
    
    /**
    * Handles the XPath function true.
    *
    * This method handles the XPath function true.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_true ( $node, $arguments )
    {
        // Return true.
        return true;
    }
    
    /**
    * Handles the XPath function false.
    *
    * This method handles the XPath function false.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_false ( $node, $arguments )
    {
        // Return false.
        return false;
    }
    
    /**
    * Handles the XPath function lang.
    *
    * This method handles the XPath function lang.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_lang ( $node, $arguments )
    {
        // Trim the arguments.
        $arguments = trim($arguments);
        
        // Check whether the node has an language attribute.
        if ( empty($this->nodes[$node]["attributes"]["xml:lang"]) )
        {
            // Run through the ancestors.
            while ( !empty($node) )
            {
                // Select the parent node.
                $node = $this->nodes[$node]["parent"];
                
                // Check whether there's a language definition.
                if ( !empty($this->nodes[$node]["attributes"]["xml:lang"]) )
                {
                    // Check whether it's the language, the user asks for.
                    if ( preg_match("/^$arguments/i", $this->nodes[$node]
                        ["attributes"]["xml:lang"]) )
                    {
                        // Return true.
                        return true;
                    }
                    else
                    {
                        // Return false.
                        return false;
                    }
                }
            }
            
            // Return false.
            return false;
        }
        else
        {
            // Check whether it's the language, the user asks for.
            if ( preg_match("/^$arguments/i", $this->nodes[$node]["attributes"]
                ["xml:lang"]) )
            {
                // Return true.
                return true;
            }
            else
            {
                // Return false.
                return false;
            }
        }
    }
    
    /**
    * Handles the XPath function number.
    *
    * This method handles the XPath function number.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_number ( $node, $arguments )
    {
        // Check the type of argument.
        if ( preg_match('/^[0-9]+(\.[0-9]+)?$/', $arguments) ||
            preg_match('/^\.[0-9]+$/', $arguments) )
        {
            // Return the argument as a number.
            return doubleval($arguments);
        }
        elseif ( is_bool($arguments) )
        {
            // Check whether it's true.
            if ( $arguments == true )
            {
                // Return 1.
                return 1;
            }
            else
            {
                // Return 0.
                return 0;
            }
        }
    }
    
    /**
    * Handles the XPath function sum.
    *
    * This method handles the XPath function sum.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_sum ( $node, $arguments )
    {
        // Trim the arguments.
        $arguments = trim($arguments);
        
        // Evaluate the arguments as an XPath expression.
        $results = $this->evaluate($arguments, $node);
        
        // Create a variable to save the sum.
        $sum = 0;
        
        // Run through all results.
        foreach ( $results as $result )
        {
            // Get the value of the node.
            $result = $this->get_content($result);
            
            // Add it to the sum.
            $sum += doubleval($result);
        }
        
        // Return the sum.
        return $sum;
    }
    
    /**
    * Handles the XPath function floor.
    *
    * This method handles the XPath function floor.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_floor ( $node, $arguments )
    {
        // Trim the arguments.
        $arguments = trim($arguments);
        
        // Convert the arguments to a number.
        $arguments = doubleval($arguments);
        
        // Return the result
        return floor($arguments);
    }
    
    /**
    * Handles the XPath function ceiling.
    *
    * This method handles the XPath function ceiling.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_ceiling ( $node, $arguments )
    {
        // Trim the arguments.
        $arguments = trim($arguments);
        
        // Convert the arguments to a number.
        $arguments = doubleval($arguments);
        
        // Return the result
        return ceil($arguments);
    }
    
    /**
    * Handles the XPath function round.
    *
    * This method handles the XPath function round.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_round ( $node, $arguments )
    {
        // Trim the arguments.
        $arguments = trim($arguments);
        
        // Convert the arguments to a number.
        $arguments = doubleval($arguments);
        
        // Return the result
        return round($arguments);
    }
    
    /**
    * Handles the XPath function text.
    *
    * This method handles the XPath function text.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $node Full path of the node on which the function
    *            should be processed.
    * @param     string $arguments String containing the arguments that were
    *            passed to the function.
    * @return    mixed Depending on the type of function being processed this 
    *            method returns different types.
    * @see       evaluate()
    */
    function handle_function_text ( $node, $arguments )
    {
        // Return the character data of the node.
        return $this->nodes[$node]["text"];
    }
    
    /**
    * Retrieves a substring before a delimiter.
    *
    * This method retrieves everything from a string before a given delimiter,
    * not including the delimiter.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $string String, from which the substring should be
    *            extracted.
    * @param     string $delimiter String containing the delimiter to use.
    * @return    string Substring from the original string before the
    *            delimiter.
    * @see       afterstr()
    */
    function prestr ( $string, $delimiter )
    {
        // Return the substring.
                return substr($string, 0, strlen($string) - strlen(strstr($string,
            "$delimiter")));
        }
    
    /**
    * Retrieves a substring after a delimiter.
    *
    * This method retrieves everything from a string after a given delimiter,
    * not including the delimiter.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $string String, from which the substring should be
    *            extracted.
    * @param     string $delimiter String containing the delimiter to use.
    * @return    string Substring from the original string after the
    *            delimiter.
    * @see       prestr()
    */
    function afterstr ( $string, $delimiter )
    {
        // Return the substring.
                return substr($string,
            strpos($string, $delimiter) + strlen($delimiter));
        }
    
    /**
    * Displays an error message.
    *
    * This method displays an error messages and stops the execution of the
    * script. This method is called exactly in the same way as the printf
    * function. The first argument contains the message and additional
    * arguments of various types may be passed to this method to be inserted
    * into the message.
    *
    * @access    private
    * @author    Michael P. Mehl <mpm@phpxml.org>
    * @param     string $message Error message to be displayed.
    */
    function display_error ( $message )
    {
                // Check whether more than one argument was given.
                if ( func_num_args() > 1 )
                {
                        // Read all arguments.
                        $arguments = func_get_args();
                        
                        // Create a new string for the inserting command.
                        $command = "\$message = sprintf(\$message, ";
                        
                        // Run through the array of arguments.
                        for ( $i = 1; $i < sizeof($arguments); ++$i )
                        {
                                // Add the number of the argument to the command.
                                $command .= "\$arguments[".$i."], ";
                        }
                        
                        // Replace the last separator.
                        $command = preg_replace('/, $/i', ');', $command);
                        
                        // Execute the command.
                        eval($command);
                }
                
        // Display the error message.
        echo "<b>phpXML error:</b> ".$message;
        
        // End the execution of this script.
        exit;
    }
}

?>