mirror of
https://github.com/EGroupware/egroupware.git
synced 2024-11-18 14:03:28 +01:00
6f90c27214
native support !!!, it main feature is to support XPath queries without navite DOM XML support !. It will be the heart of the new setup app
3385 lines
116 KiB
PHP
3385 lines
116 KiB
PHP
<?php
|
|
|
|
//
|
|
// +----------------------------------------------------------------------+
|
|
// | <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 ( "&" => "&", "<" => "<", ">" => ">",
|
|
"'" => "&apos", '"' => """ );
|
|
|
|
/**
|
|
* 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 .= "<".$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 .= ">\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 .= "</".$this->nodes[$root]["name"].">";
|
|
|
|
// 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 ( ereg("/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 ( ereg("/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 ( ereg("/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 ( ereg("/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 ( ereg("\[", $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 ( ereg("\(", $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 ( eregi("^@", $step) )
|
|
{
|
|
// Use the attribute axis and select the attribute.
|
|
$axis["axis"] = "attribute";
|
|
$axis["node-test"] = substr($step, 1);
|
|
}
|
|
elseif ( eregi("\]$", $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 ( ereg("^[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 ( ereg("-", $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 ( ereg("\(", $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 ( ereg("^[0-9]+(\.[0-9]+)?$", $predicate) ||
|
|
ereg("^\.[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 ( ereg("^[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 ( ereg("\(", $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 ( ereg("^[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 ( ereg("^[0-9]+(\.[0-9]+)?$", $arguments) ||
|
|
ereg("^\.[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 ( ereg("^".$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 ( ereg($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 ( ereg("^[0-9]+(\.[0-9]+)?$", $arguments) ||
|
|
ereg("^\.[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 ( eregi("^".$arguments, $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 ( eregi("^".$arguments, $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 ( ereg("^[0-9]+(\.[0-9]+)?$", $arguments) ||
|
|
ereg("^\.[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 = eregi_replace(", $", ");", $command);
|
|
|
|
// Execute the command.
|
|
eval($command);
|
|
}
|
|
|
|
// Display the error message.
|
|
echo "<b>phpXML error:</b> ".$message;
|
|
|
|
// End the execution of this script.
|
|
exit;
|
|
}
|
|
}
|
|
|
|
?>
|