1636 lines
37 KiB
PHP
Executable File
1636 lines
37 KiB
PHP
Executable File
<?php
|
|
/**
|
|
* Generic string parsing infrastructure
|
|
*
|
|
* These classes provide the means to parse any kind of string into a tree-like
|
|
* memory structure. It would e.g. be possible to create an HTML parser based
|
|
* upon this class.
|
|
*
|
|
* Version: 0.3.3
|
|
*
|
|
* @author Christian Seiler <spam@christian-seiler.de>
|
|
* @copyright Christian Seiler 2004-2008
|
|
* @package stringparser
|
|
*
|
|
* The MIT License
|
|
*
|
|
* Copyright (c) 2004-2009 Christian Seiler
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
|
|
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
/**
|
|
* String parser mode: Search for the next character
|
|
*
|
|
* @see StringParser::_parserMode
|
|
*/
|
|
define('STRINGPARSER_MODE_SEARCH', 1);
|
|
/**
|
|
* String parser mode: Look at each character of the string
|
|
*
|
|
* @see StringParser::_parserMode
|
|
*/
|
|
define('STRINGPARSER_MODE_LOOP', 2);
|
|
/**
|
|
* Filter type: Prefilter
|
|
*
|
|
* @see StringParser::addFilter, StringParser::_prefilters
|
|
*/
|
|
define('STRINGPARSER_FILTER_PRE', 1);
|
|
/**
|
|
* Filter type: Postfilter
|
|
*
|
|
* @see StringParser::addFilter, StringParser::_postfilters
|
|
*/
|
|
define('STRINGPARSER_FILTER_POST', 2);
|
|
|
|
/**
|
|
* Generic string parser class
|
|
*
|
|
* This is an abstract class for any type of string parser.
|
|
*
|
|
* @package stringparser
|
|
*/
|
|
class StringParser {
|
|
|
|
/**
|
|
* String parser mode
|
|
*
|
|
* There are two possible modes: searchmode and loop mode. In loop mode
|
|
* every single character is looked at in a loop and it is then decided
|
|
* what action to take. This is the most straight-forward approach to
|
|
* string parsing but due to the nature of PHP as a scripting language,
|
|
* it can also cost performance. In search mode the class posseses a
|
|
* list of relevant characters for parsing and uses the
|
|
* {@link PHP_MANUAL#strpos strpos} function to search for the next
|
|
* relevant character. The search mode will be faster than the loop mode
|
|
* in most circumstances but it is also more difficult to implement.
|
|
* The subclass that does the string parsing itself will define which
|
|
* mode it will implement.
|
|
*
|
|
* @access protected
|
|
* @var int
|
|
* @see STRINGPARSER_MODE_SEARCH, STRINGPARSER_MODE_LOOP
|
|
*/
|
|
var $_parserMode = STRINGPARSER_MODE_SEARCH;
|
|
|
|
/**
|
|
* Raw text
|
|
*
|
|
* @access protected
|
|
* @var string
|
|
*/
|
|
var $_text = '';
|
|
|
|
/**
|
|
* Parse stack
|
|
*
|
|
* @access protected
|
|
* @var array
|
|
*/
|
|
var $_stack = array();
|
|
|
|
/**
|
|
* Current position in raw text
|
|
*
|
|
* @access protected
|
|
* @var integer
|
|
*/
|
|
var $_cpos = -1;
|
|
|
|
/**
|
|
* Root node
|
|
*
|
|
* @access protected
|
|
* @var mixed
|
|
*/
|
|
var $_root = null;
|
|
|
|
/**
|
|
* Length of the text
|
|
*
|
|
* @access protected
|
|
* @var integer
|
|
*/
|
|
var $_length = -1;
|
|
|
|
/**
|
|
* Flag if this object is already parsing a text
|
|
*
|
|
* This flag is to prevent recursive calls to the parse() function that
|
|
* would cause very nasty things.
|
|
*
|
|
* @access protected
|
|
* @var boolean
|
|
*/
|
|
var $_parsing = false;
|
|
|
|
/**
|
|
* Strict mode
|
|
*
|
|
* Whether to stop parsing if a parse error occurs.
|
|
*
|
|
* @access public
|
|
* @var boolean
|
|
*/
|
|
var $strict = false;
|
|
|
|
/**
|
|
* Characters or strings to look for
|
|
*
|
|
* @access protected
|
|
* @var array
|
|
*/
|
|
var $_charactersSearch = array();
|
|
|
|
/**
|
|
* Characters currently allowed
|
|
*
|
|
* Note that this will only be evaluated in loop mode; in search mode
|
|
* this would ruin every performance increase. Note that only single
|
|
* characters are permitted here, no strings. Please also note that in
|
|
* loop mode, {@link StringParser::_charactersSearch _charactersSearch}
|
|
* is evaluated before this variable.
|
|
*
|
|
* If in strict mode, parsing is stopped if a character that is not
|
|
* allowed is encountered. If not in strict mode, the character is
|
|
* simply ignored.
|
|
*
|
|
* @access protected
|
|
* @var array
|
|
*/
|
|
var $_charactersAllowed = array();
|
|
|
|
/**
|
|
* Current parser status
|
|
*
|
|
* @access protected
|
|
* @var int
|
|
*/
|
|
var $_status = 0;
|
|
|
|
/**
|
|
* Prefilters
|
|
*
|
|
* @access protected
|
|
* @var array
|
|
*/
|
|
var $_prefilters = array();
|
|
|
|
/**
|
|
* Postfilters
|
|
*
|
|
* @access protected
|
|
* @var array
|
|
*/
|
|
var $_postfilters = array();
|
|
|
|
/**
|
|
* Recently reparsed?
|
|
*
|
|
* @access protected
|
|
* @var bool
|
|
*/
|
|
var $_recentlyReparsed = false;
|
|
|
|
var $_output;
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* @access public
|
|
*/
|
|
function __construct() {
|
|
}
|
|
|
|
function StringParser() {
|
|
}
|
|
|
|
/**
|
|
* Add a filter
|
|
*
|
|
* @access public
|
|
* @param int $type
|
|
* The type of the filter
|
|
* @param mixed $callback
|
|
* The callback to call
|
|
* @return bool
|
|
* @see STRINGPARSER_FILTER_PRE, STRINGPARSER_FILTER_POST
|
|
*/
|
|
function addFilter($type, $callback) {
|
|
// make sure the function is callable
|
|
if (!is_callable($callback)) {
|
|
return false;
|
|
}
|
|
|
|
switch ($type) {
|
|
case STRINGPARSER_FILTER_PRE:
|
|
$this->_prefilters [] = $callback;
|
|
break;
|
|
case STRINGPARSER_FILTER_POST:
|
|
$this->_postfilters [] = $callback;
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Remove all filters
|
|
*
|
|
* @access public
|
|
* @param int $type
|
|
* The type of the filter or 0 for all
|
|
* @return bool
|
|
* @see STRINGPARSER_FILTER_PRE, STRINGPARSER_FILTER_POST
|
|
*/
|
|
function clearFilters($type = 0) {
|
|
switch ($type) {
|
|
case 0:
|
|
$this->_prefilters = array();
|
|
$this->_postfilters = array();
|
|
break;
|
|
case STRINGPARSER_FILTER_PRE:
|
|
$this->_prefilters = array();
|
|
break;
|
|
case STRINGPARSER_FILTER_POST:
|
|
$this->_postfilters = array();
|
|
break;
|
|
default:
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* This function parses the text
|
|
*
|
|
* @access public
|
|
* @param string $text
|
|
* The text to parse
|
|
* @return mixed Either the root object of the tree if no output method
|
|
* is defined, the tree reoutput to e.g. a string or false
|
|
* if an internal error occured, such as a parse error if
|
|
* in strict mode or the object is already parsing a text.
|
|
*/
|
|
function parse($text) {
|
|
if ($this->_parsing) {
|
|
return false;
|
|
}
|
|
$this->_parsing = true;
|
|
$this->_text = $this->_applyPrefilters($text);
|
|
$this->_output = null;
|
|
$this->_length = strlen($this->_text);
|
|
$this->_cpos = 0;
|
|
unset($this->_stack);
|
|
$this->_stack = array();
|
|
if (is_object($this->_root)) {
|
|
StringParser_Node::destroyNode($this->_root);
|
|
}
|
|
unset($this->_root);
|
|
$this->_root = new StringParser_Node_Root();
|
|
$this->_stack [0] = $this->_root;
|
|
|
|
$this->_parserInit();
|
|
|
|
$finished = false;
|
|
|
|
while (!$finished) {
|
|
switch ($this->_parserMode) {
|
|
case STRINGPARSER_MODE_SEARCH:
|
|
$res = $this->_searchLoop();
|
|
if (!$res) {
|
|
$this->_parsing = false;
|
|
return false;
|
|
}
|
|
break;
|
|
case STRINGPARSER_MODE_LOOP:
|
|
$res = $this->_loop();
|
|
if (!$res) {
|
|
$this->_parsing = false;
|
|
return false;
|
|
}
|
|
break;
|
|
default:
|
|
$this->_parsing = false;
|
|
return false;
|
|
}
|
|
|
|
$res = $this->_closeRemainingBlocks();
|
|
if (!$res) {
|
|
if ($this->strict) {
|
|
$this->_parsing = false;
|
|
return false;
|
|
} else {
|
|
$res = $this->_reparseAfterCurrentBlock();
|
|
if (!$res) {
|
|
$this->_parsing = false;
|
|
return false;
|
|
}
|
|
continue;
|
|
}
|
|
}
|
|
$finished = true;
|
|
}
|
|
|
|
$res = $this->_modifyTree();
|
|
|
|
if (!$res) {
|
|
$this->_parsing = false;
|
|
return false;
|
|
}
|
|
|
|
$res = $this->_outputTree();
|
|
|
|
if (!$res) {
|
|
$this->_parsing = false;
|
|
return false;
|
|
}
|
|
|
|
if (is_null($this->_output)) {
|
|
$root = $this->_root;
|
|
unset($this->_root);
|
|
$this->_root = null;
|
|
while (count($this->_stack)) {
|
|
unset($this->_stack [count($this->_stack) - 1]);
|
|
}
|
|
$this->_stack = array();
|
|
$this->_parsing = false;
|
|
return $root;
|
|
}
|
|
|
|
$res = StringParser_Node::destroyNode($this->_root);
|
|
if (!$res) {
|
|
$this->_parsing = false;
|
|
return false;
|
|
}
|
|
unset($this->_root);
|
|
$this->_root = null;
|
|
while (count($this->_stack)) {
|
|
unset($this->_stack [count($this->_stack) - 1]);
|
|
}
|
|
$this->_stack = array();
|
|
|
|
$this->_parsing = false;
|
|
return $this->_output;
|
|
}
|
|
|
|
/**
|
|
* Apply prefilters
|
|
*
|
|
* It is possible to specify prefilters for the parser to do some
|
|
* manipulating of the string beforehand.
|
|
*/
|
|
function _applyPrefilters($text) {
|
|
foreach ($this->_prefilters as $filter) {
|
|
if (is_callable($filter)) {
|
|
$ntext = call_user_func($filter, $text);
|
|
if (is_string($ntext)) {
|
|
$text = $ntext;
|
|
}
|
|
}
|
|
}
|
|
return $text;
|
|
}
|
|
|
|
/**
|
|
* Apply postfilters
|
|
*
|
|
* It is possible to specify postfilters for the parser to do some
|
|
* manipulating of the string afterwards.
|
|
*/
|
|
function _applyPostfilters($text) {
|
|
foreach ($this->_postfilters as $filter) {
|
|
if (is_callable($filter)) {
|
|
$ntext = call_user_func($filter, $text);
|
|
if (is_string($ntext)) {
|
|
$text = $ntext;
|
|
}
|
|
}
|
|
}
|
|
return $text;
|
|
}
|
|
|
|
/**
|
|
* Abstract method: Manipulate the tree
|
|
*
|
|
* @access protected
|
|
* @return bool
|
|
*/
|
|
function _modifyTree() {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Abstract method: Output tree
|
|
*
|
|
* @access protected
|
|
* @return bool
|
|
*/
|
|
function _outputTree() {
|
|
// this could e.g. call _applyPostfilters
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Restart parsing after current block
|
|
*
|
|
* To achieve this the current top stack object is removed from the
|
|
* tree. Then the current item
|
|
*
|
|
* @access protected
|
|
* @return bool
|
|
*/
|
|
function _reparseAfterCurrentBlock() {
|
|
// this should definitely not happen!
|
|
if (($stack_count = count($this->_stack)) < 2) {
|
|
return false;
|
|
}
|
|
$topelem = $this->_stack [$stack_count - 1];
|
|
|
|
$node_parent = $topelem->_parent;
|
|
// remove the child from the tree
|
|
$res = $node_parent->removeChild($topelem, false);
|
|
if (!$res) {
|
|
return false;
|
|
}
|
|
$res = $this->_popNode();
|
|
if (!$res) {
|
|
return false;
|
|
}
|
|
|
|
// now try to get the position of the object
|
|
if ($topelem->occurredAt < 0) {
|
|
return false;
|
|
}
|
|
// HACK: could it be necessary to set a different status
|
|
// if yes, how should this be achieved? Another member of
|
|
// StringParser_Node?
|
|
$this->_setStatus(0);
|
|
$res = $this->_appendText($this->_text [$topelem->occurredAt]);
|
|
if (!$res) {
|
|
return false;
|
|
}
|
|
|
|
$this->_cpos = $topelem->occurredAt + 1;
|
|
$this->_recentlyReparsed = true;
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Abstract method: Close remaining blocks
|
|
*
|
|
* @access protected
|
|
*/
|
|
function _closeRemainingBlocks() {
|
|
// everything closed
|
|
if (count($this->_stack) == 1) {
|
|
return true;
|
|
}
|
|
// not everything closed
|
|
if ($this->strict) {
|
|
return false;
|
|
}
|
|
while (count($this->_stack) > 1) {
|
|
$res = $this->_popNode();
|
|
if (!$res) {
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Abstract method: Initialize the parser
|
|
*
|
|
* @access protected
|
|
*/
|
|
function _parserInit() {
|
|
$this->_setStatus(0);
|
|
}
|
|
|
|
/**
|
|
* Abstract method: Set a specific status
|
|
*
|
|
* @access protected
|
|
*/
|
|
function _setStatus($status) {
|
|
if ($status != 0) {
|
|
return false;
|
|
}
|
|
$this->_charactersSearch = array();
|
|
$this->_charactersAllowed = array();
|
|
$this->_status = $status;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Abstract method: Handle status
|
|
*
|
|
* @access protected
|
|
* @param int $status
|
|
* The current status
|
|
* @param string $needle
|
|
* The needle that was found
|
|
* @return bool
|
|
*/
|
|
function _handleStatus($status, $needle) {
|
|
$this->_appendText($needle);
|
|
$this->_cpos += strlen($needle);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Search mode loop
|
|
*
|
|
* @access protected
|
|
* @return bool
|
|
*/
|
|
function _searchLoop() {
|
|
$i = 0;
|
|
while (1) {
|
|
// make sure this is false!
|
|
$this->_recentlyReparsed = false;
|
|
|
|
list ($needle, $offset) = $this->_strpos($this->_charactersSearch, $this->_cpos);
|
|
// parser ends here
|
|
if ($needle === false) {
|
|
// original status 0 => no problem
|
|
if (!$this->_status) {
|
|
break;
|
|
}
|
|
// not in original status? strict mode?
|
|
if ($this->strict) {
|
|
return false;
|
|
}
|
|
// break up parsing operation of current node
|
|
$res = $this->_reparseAfterCurrentBlock();
|
|
if (!$res) {
|
|
return false;
|
|
}
|
|
continue;
|
|
}
|
|
// get subtext
|
|
$subtext = substr($this->_text, $this->_cpos, $offset - $this->_cpos);
|
|
$res = $this->_appendText($subtext);
|
|
if (!$res) {
|
|
return false;
|
|
}
|
|
$this->_cpos = $offset;
|
|
$res = $this->_handleStatus($this->_status, $needle);
|
|
if (!$res && $this->strict) {
|
|
return false;
|
|
}
|
|
if (!$res) {
|
|
$res = $this->_appendText($this->_text [$this->_cpos]);
|
|
if (!$res) {
|
|
return false;
|
|
}
|
|
$this->_cpos++;
|
|
continue;
|
|
}
|
|
if ($this->_recentlyReparsed) {
|
|
$this->_recentlyReparsed = false;
|
|
continue;
|
|
}
|
|
$this->_cpos += strlen($needle);
|
|
}
|
|
|
|
// get subtext
|
|
if ($this->_cpos < strlen($this->_text)) {
|
|
$subtext = substr($this->_text, $this->_cpos);
|
|
$res = $this->_appendText($subtext);
|
|
if (!$res) {
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Loop mode loop
|
|
*
|
|
* @access protected
|
|
* @return bool
|
|
*/
|
|
function _loop() {
|
|
// HACK: This method ist not yet implemented correctly, the code below
|
|
// DOES NOT WORK! Do not use!
|
|
return false;
|
|
/*
|
|
* while ($this->_cpos < $this->_length) {
|
|
* $needle = $this->_strDetect ($this->_charactersSearch, $this->_cpos);
|
|
*
|
|
* if ($needle === false) {
|
|
* // not found => see if character is allowed
|
|
* if (!in_array ($this->_text{$this->_cpos}, $this->_charactersAllowed)) {
|
|
* if ($strict) {
|
|
* return false;
|
|
* }
|
|
* // ignore
|
|
* continue;
|
|
* }
|
|
* // lot's of FIXMES
|
|
* $res = $this->_appendText ($this->_text{$this->_cpos});
|
|
* if (!$res) {
|
|
* return false;
|
|
* }
|
|
* }
|
|
*
|
|
* // get subtext
|
|
* $subtext = substr ($this->_text, $offset, $offset - $this->_cpos);
|
|
* $res = $this->_appendText ($subtext);
|
|
* if (!$res) {
|
|
* return false;
|
|
* }
|
|
* $this->_cpos = $subtext;
|
|
* $res = $this->_handleStatus ($this->_status, $needle);
|
|
* if (!$res && $strict) {
|
|
* return false;
|
|
* }
|
|
* }
|
|
* // original status 0 => no problem
|
|
* if (!$this->_status) {
|
|
* return true;
|
|
* }
|
|
* // not in original status? strict mode?
|
|
* if ($this->strict) {
|
|
* return false;
|
|
* }
|
|
* // break up parsing operation of current node
|
|
* $res = $this->_reparseAfterCurrentBlock ();
|
|
* if (!$res) {
|
|
* return false;
|
|
* }
|
|
* // this will not cause an infinite loop because
|
|
* // _reparseAfterCurrentBlock will increase _cpos by one!
|
|
* return $this->_loop ();
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* Abstract method Append text depending on current status
|
|
*
|
|
* @access protected
|
|
* @param string $text
|
|
* The text to append
|
|
* @return bool On success, the function returns true, else false
|
|
*/
|
|
function _appendText($text) {
|
|
if (!strlen($text)) {
|
|
return true;
|
|
}
|
|
// default: call _appendToLastTextChild
|
|
return $this->_appendToLastTextChild($text);
|
|
}
|
|
|
|
/**
|
|
* Append text to last text child of current top parser stack node
|
|
*
|
|
* @access protected
|
|
* @param string $text
|
|
* The text to append
|
|
* @return bool On success, the function returns true, else false
|
|
*/
|
|
function _appendToLastTextChild($text) {
|
|
$scount = count($this->_stack);
|
|
if ($scount == 0) {
|
|
return false;
|
|
}
|
|
return $this->_stack [$scount - 1]->appendToLastTextChild($text);
|
|
}
|
|
|
|
/**
|
|
* Searches {@link StringParser::_text _text} for every needle that is
|
|
* specified by using the {@link PHP_MANUAL#strpos strpos} function.
|
|
* It
|
|
* returns an associative array with the key <code>'needle'</code>
|
|
* pointing at the string that was found first and the key
|
|
* <code>'offset'</code> pointing at the offset at which the string was
|
|
* found first. If no needle was found, the <code>'needle'</code>
|
|
* element is <code>false</code> and the <code>'offset'</code> element
|
|
* is <code>-1</code>.
|
|
*
|
|
* @access protected
|
|
* @param array $needles
|
|
* @param int $offset
|
|
* @return array
|
|
* @see StringParser::_text
|
|
*/
|
|
function _strpos($needles, $offset) {
|
|
$cur_needle = false;
|
|
$cur_offset = -1;
|
|
|
|
if ($offset < strlen($this->_text)) {
|
|
foreach ($needles as $needle) {
|
|
$n_offset = strpos($this->_text, $needle, $offset);
|
|
if ($n_offset !== false && ($n_offset < $cur_offset || $cur_offset < 0)) {
|
|
$cur_needle = $needle;
|
|
$cur_offset = $n_offset;
|
|
}
|
|
}
|
|
}
|
|
|
|
return array(
|
|
$cur_needle,
|
|
$cur_offset,
|
|
'needle' => $cur_needle,
|
|
'offset' => $cur_offset
|
|
);
|
|
}
|
|
|
|
/**
|
|
* Detects a string at the current position
|
|
*
|
|
* @access protected
|
|
* @param array $needles
|
|
* The strings that are to be detected
|
|
* @param int $offset
|
|
* The current offset
|
|
* @return mixed The string that was detected or the needle
|
|
*/
|
|
function _strDetect($needles, $offset) {
|
|
foreach ($needles as $needle) {
|
|
$l = strlen($needle);
|
|
if (substr($this->_text, $offset, $l) == $needle) {
|
|
return $needle;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Adds a node to the current parse stack
|
|
*
|
|
* @access protected
|
|
* @param object $node
|
|
* The node that is to be added
|
|
* @return bool True on success, else false.
|
|
* @see StringParser_Node, StringParser::_stack
|
|
*/
|
|
function _pushNode(&$node) {
|
|
$stack_count = count($this->_stack);
|
|
$max_node = $this->_stack [$stack_count - 1];
|
|
if (!$max_node->appendChild($node)) {
|
|
return false;
|
|
}
|
|
$this->_stack [$stack_count] = $node;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Removes a node from the current parse stack
|
|
*
|
|
* @access protected
|
|
* @return bool True on success, else false.
|
|
* @see StringParser_Node, StringParser::_stack
|
|
*/
|
|
function _popNode() {
|
|
$stack_count = count($this->_stack);
|
|
unset($this->_stack [$stack_count - 1]);
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Execute a method on the top element
|
|
*
|
|
* @access protected
|
|
* @return mixed
|
|
*/
|
|
function _topNode() {
|
|
$args = func_get_args();
|
|
if (!count($args)) {
|
|
return; // oops?
|
|
}
|
|
$method = array_shift($args);
|
|
$stack_count = count($this->_stack);
|
|
$method = array(
|
|
&$this->_stack [$stack_count - 1],
|
|
$method
|
|
);
|
|
if (!is_callable($method)) {
|
|
return; // oops?
|
|
}
|
|
return call_user_func_array($method, $args);
|
|
}
|
|
|
|
/**
|
|
* Get a variable of the top element
|
|
*
|
|
* @access protected
|
|
* @return mixed
|
|
*/
|
|
function _topNodeVar($var) {
|
|
$stack_count = count($this->_stack);
|
|
return $this->_stack [$stack_count - 1]->$var;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* Node type: Unknown node
|
|
*
|
|
* @see StringParser_Node::_type
|
|
*/
|
|
define('STRINGPARSER_NODE_UNKNOWN', 0);
|
|
|
|
/**
|
|
* Node type: Root node
|
|
*
|
|
* @see StringParser_Node::_type
|
|
*/
|
|
define('STRINGPARSER_NODE_ROOT', 1);
|
|
|
|
/**
|
|
* Node type: Text node
|
|
*
|
|
* @see StringParser_Node::_type
|
|
*/
|
|
define('STRINGPARSER_NODE_TEXT', 2);
|
|
|
|
/**
|
|
* Global value that is a counter of string parser node ids.
|
|
* Compare it to a
|
|
* sequence in databases.
|
|
*
|
|
* @var int
|
|
*/
|
|
$GLOBALS ['__STRINGPARSER_NODE_ID'] = 0;
|
|
|
|
/**
|
|
* Generic string parser node class
|
|
*
|
|
* This is an abstract class for any type of node that is used within the
|
|
* string parser. General warning: This class contains code regarding references
|
|
* that is very tricky. Please do not touch this code unless you exactly know
|
|
* what you are doing. Incorrect handling of references may cause PHP to crash
|
|
* with a segmentation fault! You have been warned.
|
|
*
|
|
* @package stringparser
|
|
*/
|
|
class StringParser_Node {
|
|
|
|
/**
|
|
* The type of this node.
|
|
*
|
|
* There are three standard node types: root node, text node and unknown
|
|
* node. All node types are integer constants. Any node type of a
|
|
* subclass must be at least 32 to allow future developements.
|
|
*
|
|
* @access protected
|
|
* @var int
|
|
* @see STRINGPARSER_NODE_ROOT, STRINGPARSER_NODE_TEXT
|
|
* @see STRINGPARSER_NODE_UNKNOWN
|
|
*/
|
|
var $_type = STRINGPARSER_NODE_UNKNOWN;
|
|
|
|
/**
|
|
* The node ID
|
|
*
|
|
* This ID uniquely identifies this node. This is needed when searching
|
|
* for a specific node in the children array. Please note that this is
|
|
* only an internal variable and should never be used - not even in
|
|
* subclasses and especially not in external data structures. This ID
|
|
* has nothing to do with any type of ID in HTML oder XML.
|
|
*
|
|
* @access protected
|
|
* @var int
|
|
* @see StringParser_Node::_children
|
|
*/
|
|
var $_id = -1;
|
|
|
|
/**
|
|
* The parent of this node.
|
|
*
|
|
* It is either null (root node) or a reference to the parent object.
|
|
*
|
|
* @access protected
|
|
* @var mixed
|
|
* @see StringParser_Node::_children
|
|
*/
|
|
var $_parent = null;
|
|
|
|
/**
|
|
* The children of this node.
|
|
*
|
|
* It contains an array of references to all the children nodes of this
|
|
* node.
|
|
*
|
|
* @access protected
|
|
* @var array
|
|
* @see StringParser_Node::_parent
|
|
*/
|
|
var $_children = array();
|
|
|
|
/**
|
|
* Occured at
|
|
*
|
|
* This defines the position in the parsed text where this node occurred
|
|
* at. If -1, this value was not possible to be determined.
|
|
*
|
|
* @access public
|
|
* @var int
|
|
*/
|
|
var $occurredAt = -1;
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* Currently, the constructor only allocates a new ID for the node and
|
|
* assigns it.
|
|
*
|
|
* @access public
|
|
* @param int $occurredAt
|
|
* The position in the text where this node
|
|
* occurred at. If not determinable, it is -1.
|
|
* @global __STRINGPARSER_NODE_ID
|
|
*/
|
|
function __construct($occurredAt = -1) {
|
|
$this->_id = $GLOBALS ['__STRINGPARSER_NODE_ID']++;
|
|
$this->occurredAt = $occurredAt;
|
|
}
|
|
|
|
/**
|
|
* Type of the node
|
|
*
|
|
* This function returns the type of the node
|
|
*
|
|
* @access public
|
|
* @return int
|
|
*/
|
|
function type() {
|
|
return $this->_type;
|
|
}
|
|
|
|
/**
|
|
* Prepend a node
|
|
*
|
|
* @access public
|
|
* @param object $node
|
|
* The node to be prepended.
|
|
* @return bool On success, the function returns true, else false.
|
|
*/
|
|
function prependChild(&$node) {
|
|
if (!is_object($node)) {
|
|
return false;
|
|
}
|
|
|
|
// root nodes may not be children of other nodes!
|
|
if ($node->_type == STRINGPARSER_NODE_ROOT) {
|
|
return false;
|
|
}
|
|
|
|
// if node already has a parent
|
|
if ($node->_parent !== false) {
|
|
// remove node from there
|
|
$parent = $node->_parent;
|
|
if (!$parent->removeChild($node, false)) {
|
|
return false;
|
|
}
|
|
unset($parent);
|
|
}
|
|
|
|
$index = count($this->_children) - 1;
|
|
// move all nodes to a new index
|
|
while ($index >= 0) {
|
|
// save object
|
|
$object = $this->_children [$index];
|
|
// we have to unset it because else it will be
|
|
// overridden in in the loop
|
|
unset($this->_children [$index]);
|
|
// put object to new position
|
|
$this->_children [$index + 1] = $object;
|
|
$index--;
|
|
}
|
|
$this->_children [0] = $node;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Append text to last text child
|
|
*
|
|
* @access public
|
|
* @param string $text
|
|
* The text to append
|
|
* @return bool On success, the function returns true, else false
|
|
*/
|
|
function appendToLastTextChild($text) {
|
|
$ccount = count($this->_children);
|
|
if ($ccount == 0 || $this->_children [$ccount - 1]->_type != STRINGPARSER_NODE_TEXT) {
|
|
$ntextnode = new StringParser_Node_Text($text);
|
|
return $this->appendChild($ntextnode);
|
|
} else {
|
|
$this->_children [$ccount - 1]->appendText($text);
|
|
return true;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Append a node to the children
|
|
*
|
|
* This function appends a node to the children array(). It
|
|
* automatically sets the {@link StrinParser_Node::_parent _parent}
|
|
* property of the node that is to be appended.
|
|
*
|
|
* @access public
|
|
* @param object $node
|
|
* The node that is to be appended.
|
|
* @return bool On success, the function returns true, else false.
|
|
*/
|
|
function appendChild(&$node) {
|
|
if (!is_object($node)) {
|
|
return false;
|
|
}
|
|
|
|
// root nodes may not be children of other nodes!
|
|
if ($node->_type == STRINGPARSER_NODE_ROOT) {
|
|
return false;
|
|
}
|
|
|
|
// if node already has a parent
|
|
if ($node->_parent !== null) {
|
|
// remove node from there
|
|
$parent = $node->_parent;
|
|
if (!$parent->removeChild($node, false)) {
|
|
return false;
|
|
}
|
|
unset($parent);
|
|
}
|
|
|
|
// append it to current node
|
|
$new_index = count($this->_children);
|
|
$this->_children [$new_index] = $node;
|
|
$node->_parent = $this;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Insert a node before another node
|
|
*
|
|
* @access public
|
|
* @param object $node
|
|
* The node to be inserted.
|
|
* @param object $reference
|
|
* The reference node where the new node is
|
|
* to be inserted before.
|
|
* @return bool On success, the function returns true, else false.
|
|
*/
|
|
function insertChildBefore(&$node, &$reference) {
|
|
if (!is_object($node)) {
|
|
return false;
|
|
}
|
|
|
|
// root nodes may not be children of other nodes!
|
|
if ($node->_type == STRINGPARSER_NODE_ROOT) {
|
|
return false;
|
|
}
|
|
|
|
// is the reference node a child?
|
|
$child = $this->_findChild($reference);
|
|
|
|
if ($child === false) {
|
|
return false;
|
|
}
|
|
|
|
// if node already has a parent
|
|
if ($node->_parent !== null) {
|
|
// remove node from there
|
|
$parent = $node->_parent;
|
|
if (!$parent->removeChild($node, false)) {
|
|
return false;
|
|
}
|
|
unset($parent);
|
|
}
|
|
|
|
$index = count($this->_children) - 1;
|
|
// move all nodes to a new index
|
|
while ($index >= $child) {
|
|
// save object
|
|
$object = $this->_children [$index];
|
|
// we have to unset it because else it will be
|
|
// overridden in in the loop
|
|
unset($this->_children [$index]);
|
|
// put object to new position
|
|
$this->_children [$index + 1] = $object;
|
|
$index--;
|
|
}
|
|
$this->_children [$child] = $node;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Insert a node after another node
|
|
*
|
|
* @access public
|
|
* @param object $node
|
|
* The node to be inserted.
|
|
* @param object $reference
|
|
* The reference node where the new node is
|
|
* to be inserted after.
|
|
* @return bool On success, the function returns true, else false.
|
|
*/
|
|
function insertChildAfter(&$node, &$reference) {
|
|
if (!is_object($node)) {
|
|
return false;
|
|
}
|
|
|
|
// root nodes may not be children of other nodes!
|
|
if ($node->_type == STRINGPARSER_NODE_ROOT) {
|
|
return false;
|
|
}
|
|
|
|
// is the reference node a child?
|
|
$child = $this->_findChild($reference);
|
|
|
|
if ($child === false) {
|
|
return false;
|
|
}
|
|
|
|
// if node already has a parent
|
|
if ($node->_parent !== false) {
|
|
// remove node from there
|
|
$parent = $node->_parent;
|
|
if (!$parent->removeChild($node, false)) {
|
|
return false;
|
|
}
|
|
unset($parent);
|
|
}
|
|
|
|
$index = count($this->_children) - 1;
|
|
// move all nodes to a new index
|
|
while ($index >= $child + 1) {
|
|
// save object
|
|
$object = $this->_children [$index];
|
|
// we have to unset it because else it will be
|
|
// overridden in in the loop
|
|
unset($this->_children [$index]);
|
|
// put object to new position
|
|
$this->_children [$index + 1] = $object;
|
|
$index--;
|
|
}
|
|
$this->_children [$child + 1] = $node;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Remove a child node
|
|
*
|
|
* This function removes a child from the children array. A parameter
|
|
* tells the function whether to destroy the child afterwards or not.
|
|
* If the specified node is not a child of this node, the function will
|
|
* return false.
|
|
*
|
|
* @access public
|
|
* @param mixed $child
|
|
* The child to destroy; either an integer
|
|
* specifying the index of the child or a reference
|
|
* to the child itself.
|
|
* @param bool $destroy
|
|
* Destroy the child afterwards.
|
|
* @return bool On success, the function returns true, else false.
|
|
*/
|
|
function removeChild(&$child, $destroy = false) {
|
|
if (is_object($child)) {
|
|
// if object: get index
|
|
$object = $child;
|
|
unset($child);
|
|
$child = $this->_findChild($object);
|
|
if ($child === false) {
|
|
return false;
|
|
}
|
|
} else {
|
|
// remove reference on $child
|
|
$save = $child;
|
|
unset($child);
|
|
$child = $save;
|
|
|
|
// else: get object
|
|
if (!isset($this->_children [$child])) {
|
|
return false;
|
|
}
|
|
$object = $this->_children [$child];
|
|
}
|
|
|
|
// store count for later use
|
|
$ccount = count($this->_children);
|
|
|
|
// index out of bounds
|
|
if (!is_int($child) || $child < 0 || $child >= $ccount) {
|
|
return false;
|
|
}
|
|
|
|
// inkonsistency
|
|
if ($this->_children [$child]->_parent === null || $this->_children [$child]->_parent->_id != $this->_id) {
|
|
return false;
|
|
}
|
|
|
|
// $object->_parent = null would equal to $this = null
|
|
// as $object->_parent is a reference to $this!
|
|
// because of this, we have to unset the variable to remove
|
|
// the reference and then redeclare the variable
|
|
unset($object->_parent);
|
|
$object->_parent = null;
|
|
|
|
// we have to unset it because else it will be overridden in
|
|
// in the loop
|
|
unset($this->_children [$child]);
|
|
|
|
// move all remaining objects one index higher
|
|
while ($child < $ccount - 1) {
|
|
// save object
|
|
$obj = $this->_children [$child + 1];
|
|
// we have to unset it because else it will be
|
|
// overridden in in the loop
|
|
unset($this->_children [$child + 1]);
|
|
// put object to new position
|
|
$this->_children [$child] = $obj;
|
|
// UNSET THE OBJECT!
|
|
unset($obj);
|
|
$child++;
|
|
}
|
|
|
|
if ($destroy) {
|
|
return StringParser_Node::destroyNode($object);
|
|
unset($object);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get the first child of this node
|
|
*
|
|
* @access public
|
|
* @return mixed
|
|
*/
|
|
function &firstChild() {
|
|
$ret = null;
|
|
if (!count($this->_children)) {
|
|
return $ret;
|
|
}
|
|
return $this->_children [0];
|
|
}
|
|
|
|
/**
|
|
* Get the last child of this node
|
|
*
|
|
* @access public
|
|
* @return mixed
|
|
*/
|
|
function &lastChild() {
|
|
$ret = null;
|
|
$c = count($this->_children);
|
|
if (!$c) {
|
|
return $ret;
|
|
}
|
|
return $this->_children [$c - 1];
|
|
}
|
|
|
|
/**
|
|
* Destroy a node
|
|
*
|
|
* @access public
|
|
* @static
|
|
* @param object $node
|
|
* The node to destroy
|
|
* @return bool True on success, else false.
|
|
*/
|
|
static function destroyNode(&$node) {
|
|
if ($node === null) {
|
|
return false;
|
|
}
|
|
// if parent exists: remove node from tree!
|
|
if ($node->_parent !== null) {
|
|
$parent = $node->_parent;
|
|
// directly return that result because the removeChild
|
|
// method will call destroyNode again
|
|
return $parent->removeChild($node, true);
|
|
}
|
|
|
|
// node has children
|
|
while (count($node->_children)) {
|
|
$child = 0;
|
|
// remove first child until no more children remain
|
|
if (!$node->removeChild($child, true)) {
|
|
return false;
|
|
}
|
|
unset($child);
|
|
}
|
|
|
|
// now call the nodes destructor
|
|
if (!$node->_destroy()) {
|
|
return false;
|
|
}
|
|
|
|
// now just unset it and prey that there are no more references
|
|
// to this node
|
|
unset($node);
|
|
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Destroy this node
|
|
*
|
|
*
|
|
* @access protected
|
|
* @return bool True on success, else false.
|
|
*/
|
|
function _destroy() {
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Find a child node
|
|
*
|
|
* This function searches for a node in the own children and returns
|
|
* the index of the node or false if the node is not a child of this
|
|
* node.
|
|
*
|
|
* @access protected
|
|
* @param mixed $child
|
|
* The node to look for.
|
|
* @return mixed The index of the child node on success, else false.
|
|
*/
|
|
function _findChild(&$child) {
|
|
if (!is_object($child)) {
|
|
return false;
|
|
}
|
|
|
|
$ccount = count($this->_children);
|
|
for($i = 0; $i < $ccount; $i++) {
|
|
if ($this->_children [$i]->_id == $child->_id) {
|
|
return $i;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Checks equality of this node and another node
|
|
*
|
|
* @access public
|
|
* @param mixed $node
|
|
* The node to be compared with
|
|
* @return bool True if the other node equals to this node, else false.
|
|
*/
|
|
function equals(&$node) {
|
|
return ($this->_id == $node->_id);
|
|
}
|
|
|
|
/**
|
|
* Determines whether a criterium matches this node
|
|
*
|
|
* @access public
|
|
* @param string $criterium
|
|
* The criterium that is to be checked
|
|
* @param mixed $value
|
|
* The value that is to be compared
|
|
* @return bool True if this node matches that criterium
|
|
*/
|
|
function matchesCriterium($criterium, $value) {
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Search for nodes with a certain criterium
|
|
*
|
|
* This may be used to implement getElementsByTagName etc.
|
|
*
|
|
* @access public
|
|
* @param string $criterium
|
|
* The criterium that is to be checked
|
|
* @param mixed $value
|
|
* The value that is to be compared
|
|
* @return array All subnodes that match this criterium
|
|
*/
|
|
function &getNodesByCriterium($criterium, $value) {
|
|
$nodes = array();
|
|
$node_ctr = 0;
|
|
for($i = 0; $i < count($this->_children); $i++) {
|
|
if ($this->_children [$i]->matchesCriterium($criterium, $value)) {
|
|
$nodes [$node_ctr++] = $this->_children [$i];
|
|
}
|
|
$subnodes = $this->_children [$i]->getNodesByCriterium($criterium, $value);
|
|
if (count($subnodes)) {
|
|
$subnodes_count = count($subnodes);
|
|
for($j = 0; $j < $subnodes_count; $j++) {
|
|
$nodes [$node_ctr++] = $subnodes [$j];
|
|
unset($subnodes [$j]);
|
|
}
|
|
}
|
|
unset($subnodes);
|
|
}
|
|
return $nodes;
|
|
}
|
|
|
|
/**
|
|
* Search for nodes with a certain criterium and return the count
|
|
*
|
|
* Similar to getNodesByCriterium
|
|
*
|
|
* @access public
|
|
* @param string $criterium
|
|
* The criterium that is to be checked
|
|
* @param mixed $value
|
|
* The value that is to be compared
|
|
* @return int The number of subnodes that match this criterium
|
|
*/
|
|
function getNodeCountByCriterium($criterium, $value) {
|
|
$node_ctr = 0;
|
|
for($i = 0; $i < count($this->_children); $i++) {
|
|
if ($this->_children [$i]->matchesCriterium($criterium, $value)) {
|
|
$node_ctr++;
|
|
}
|
|
$subnodes = $this->_children [$i]->getNodeCountByCriterium($criterium, $value);
|
|
$node_ctr += $subnodes;
|
|
}
|
|
return $node_ctr;
|
|
}
|
|
|
|
/**
|
|
* Dump nodes
|
|
*
|
|
* This dumps a tree of nodes
|
|
*
|
|
* @access public
|
|
* @param string $prefix
|
|
* The prefix that is to be used for indentation
|
|
* @param string $linesep
|
|
* The line separator
|
|
* @param int $level
|
|
* The initial level of indentation
|
|
* @return string
|
|
*/
|
|
function dump($prefix = " ", $linesep = "\n", $level = 0) {
|
|
$str = str_repeat($prefix, $level) . $this->_id . ": " . $this->_dumpToString() . $linesep;
|
|
for($i = 0; $i < count($this->_children); $i++) {
|
|
$str .= $this->_children [$i]->dump($prefix, $linesep, $level + 1);
|
|
}
|
|
return $str;
|
|
}
|
|
|
|
/**
|
|
* Dump this node to a string
|
|
*
|
|
* @access protected
|
|
* @return string
|
|
*/
|
|
function _dumpToString() {
|
|
if ($this->_type == STRINGPARSER_NODE_ROOT) {
|
|
return "root";
|
|
}
|
|
return (string) $this->_type;
|
|
}
|
|
|
|
}
|
|
|
|
/**
|
|
* String parser root node class
|
|
*
|
|
* @package stringparser
|
|
*/
|
|
class StringParser_Node_Root extends StringParser_Node {
|
|
|
|
/**
|
|
* The type of this node.
|
|
*
|
|
* This node is a root node.
|
|
*
|
|
* @access protected
|
|
* @var int
|
|
* @see STRINGPARSER_NODE_ROOT
|
|
*/
|
|
var $_type = STRINGPARSER_NODE_ROOT;
|
|
|
|
}
|
|
|
|
/**
|
|
* String parser text node class
|
|
*
|
|
* @package stringparser
|
|
*/
|
|
class StringParser_Node_Text extends StringParser_Node {
|
|
|
|
/**
|
|
* The type of this node.
|
|
*
|
|
* This node is a text node.
|
|
*
|
|
* @access protected
|
|
* @var int
|
|
* @see STRINGPARSER_NODE_TEXT
|
|
*/
|
|
var $_type = STRINGPARSER_NODE_TEXT;
|
|
|
|
/**
|
|
* Node flags
|
|
*
|
|
* @access protected
|
|
* @var array
|
|
*/
|
|
var $_flags = array();
|
|
|
|
/**
|
|
* The content of this node
|
|
*
|
|
* @access public
|
|
* @var string
|
|
*/
|
|
var $content = '';
|
|
|
|
/**
|
|
* Constructor
|
|
*
|
|
* @access public
|
|
* @param string $content
|
|
* The initial content of this element
|
|
* @param int $occurredAt
|
|
* The position in the text where this node
|
|
* occurred at. If not determinable, it is -1.
|
|
* @see StringParser_Node_Text::content
|
|
*/
|
|
function __construct($content, $occurredAt = -1) {
|
|
parent::__construct($occurredAt);
|
|
$this->content = $content;
|
|
}
|
|
|
|
/**
|
|
* Append text to content
|
|
*
|
|
* @access public
|
|
* @param string $text
|
|
* The text to append
|
|
* @see StringParser_Node_Text::content
|
|
*/
|
|
function appendText($text) {
|
|
$this->content .= $text;
|
|
}
|
|
|
|
/**
|
|
* Set a flag
|
|
*
|
|
* @access public
|
|
* @param string $name
|
|
* The name of the flag
|
|
* @param mixed $value
|
|
* The value of the flag
|
|
*/
|
|
function setFlag($name, $value) {
|
|
$this->_flags [$name] = $value;
|
|
return true;
|
|
}
|
|
|
|
/**
|
|
* Get Flag
|
|
*
|
|
* @access public
|
|
* @param string $flag
|
|
* The requested flag
|
|
* @param string $type
|
|
* The requested type of the return value
|
|
* @param mixed $default
|
|
* The default return value
|
|
*/
|
|
function getFlag($flag, $type = 'mixed', $default = null) {
|
|
if (!isset($this->_flags [$flag])) {
|
|
return $default;
|
|
}
|
|
$return = $this->_flags [$flag];
|
|
if ($type != 'mixed') {
|
|
settype($return, $type);
|
|
}
|
|
return $return;
|
|
}
|
|
|
|
/**
|
|
* Dump this node to a string
|
|
*/
|
|
function _dumpToString() {
|
|
return "text \"" . substr(preg_replace('/\s+/', ' ', $this->content), 0, 40) . "\" [f:" . preg_replace('/\s+/', ' ', join(':', array_keys($this->_flags))) . "]";
|
|
}
|
|
|
|
}
|
|
|
|
?>
|