www/plugins-dist/safehtml/lib/safehtml/classes/HTMLSax3.php

   1 <?php
   2 /* vim: set expandtab tabstop=4 shiftwidth=4: */
   3 //
   4 // +----------------------------------------------------------------------+
   5 // | PHP Version 4                                                        |
   6 // +----------------------------------------------------------------------+
   7 // | Copyright (c) 1997-2002 The PHP Group                                |
   8 // +----------------------------------------------------------------------+
   9 // | This source file is subject toversion 3.0 of the PHP license,      |
  10 // | that is bundled with this package in the file LICENSE, and is        |
  11 // | available at through the world-wide-web at                           |
  12 // | http://www.php.net/license/3_0.txt.                                  |
  13 // | If you did not receive a copy of the PHP license and are unable to   |
  14 // | obtain it through the world-wide-web, please send a note to          |
  15 // | license@php.net so we can mail you a copy immediately.               |
  16 // +----------------------------------------------------------------------+
  17 // | Authors: Alexander Zhukov <alex@veresk.ru> Original port from Python |
  18 // | Authors: Harry Fuecks <hfuecks@phppatterns.com> Port to PEAR + more  |
  19 // | Authors: Many @ Sitepointforums Advanced PHP Forums                  |
  20 // +----------------------------------------------------------------------+
  21 //
  22 // $Id: HTMLSax3.php,v 1.2 2007/10/29 21:41:34 hfuecks Exp $
  23 //
  24 /**
  25  * Main parser components
  26  * @package XML_HTMLSax3
  27  * @version $Id: HTMLSax3.php,v 1.2 2007/10/29 21:41:34 hfuecks Exp $
  28  */
  29 /**
  30  * Required classes
  31  */
  32 if (!defined('XML_HTMLSAX3')) {
  33         define('XML_HTMLSAX3', 'XML/');
  34 }
  35 require_once(XML_HTMLSAX3 . 'HTMLSax3/States.php');
  36 require_once(XML_HTMLSAX3 . 'HTMLSax3/Decorators.php');
  37
  38 /**
  39  * Base State Parser
  40  * @package XML_HTMLSax3
  41  * @access protected
  42  * @abstract
  43  */
  44 class XML_HTMLSax3_StateParser {
  45         /**
  46          * Instance of user front end class to be passed to callbacks
  47          * @var XML_HTMLSax3
  48          * @access private
  49          */
  50         var $htmlsax;
  51         /**
  52          * User defined object for handling elements
  53          * @var object
  54          * @access private
  55          */
  56         var $handler_object_element;
  57         /**
  58          * User defined open tag handler method
  59          * @var string
  60          * @access private
  61          */
  62         var $handler_method_opening;
  63         /**
  64          * User defined close tag handler method
  65          * @var string
  66          * @access private
  67          */
  68         var $handler_method_closing;
  69         /**
  70          * User defined object for handling data in elements
  71          * @var object
  72          * @access private
  73          */
  74         var $handler_object_data;
  75         /**
  76          * User defined data handler method
  77          * @var string
  78          * @access private
  79          */
  80         var $handler_method_data;
  81         /**
  82          * User defined object for handling processing instructions
  83          * @var object
  84          * @access private
  85          */
  86         var $handler_object_pi;
  87         /**
  88          * User defined processing instruction handler method
  89          * @var string
  90          * @access private
  91          */
  92         var $handler_method_pi;
  93         /**
  94          * User defined object for handling JSP/ASP tags
  95          * @var object
  96          * @access private
  97          */
  98         var $handler_object_jasp;
  99         /**
 100          * User defined JSP/ASP handler method
 101          * @var string
 102          * @access private
 103          */
 104         var $handler_method_jasp;
 105         /**
 106          * User defined object for handling XML escapes
 107          * @var object
 108          * @access private
 109          */
 110         var $handler_object_escape;
 111         /**
 112          * User defined XML escape handler method
 113          * @var string
 114          * @access private
 115          */
 116         var $handler_method_escape;
 117         /**
 118          * User defined handler object or NullHandler
 119          * @var object
 120          * @access private
 121          */
 122         var $handler_default;
 123         /**
 124          * Parser options determining parsing behavior
 125          * @var array
 126          * @access private
 127          */
 128         var $parser_options = [];
 129         /**
 130          * XML document being parsed
 131          * @var string
 132          * @access private
 133          */
 134         var $rawtext;
 135         /**
 136          * Position in XML document relative to start (0)
 137          * @var int
 138          * @access private
 139          */
 140         var $position;
 141         /**
 142          * Length of the XML document in characters
 143          * @var int
 144          * @access private
 145          */
 146         var $length;
 147         /**
 148          * Array of state objects
 149          * @var array
 150          * @access private
 151          */
 152         var $State = [];
 153
 154         /**
 155          * Constructs XML_HTMLSax3_StateParser setting up states
 156          * @var XML_HTMLSax3 instance of user front end class
 157          * @access protected
 158          */
 159         function __construct (& $htmlsax) {
 160                 $this->htmlsax = & $htmlsax;
 161                 $this->State[XML_HTMLSAX3_STATE_START] = new XML_HTMLSax3_StartingState();
 162
 163                 $this->State[XML_HTMLSAX3_STATE_CLOSING_TAG] = new XML_HTMLSax3_ClosingTagState();
 164                 $this->State[XML_HTMLSAX3_STATE_TAG] = new XML_HTMLSax3_TagState();
 165                 $this->State[XML_HTMLSAX3_STATE_OPENING_TAG] = new XML_HTMLSax3_OpeningTagState();
 166
 167                 $this->State[XML_HTMLSAX3_STATE_PI] = new XML_HTMLSax3_PiState();
 168                 $this->State[XML_HTMLSAX3_STATE_JASP] = new XML_HTMLSax3_JaspState();
 169                 $this->State[XML_HTMLSAX3_STATE_ESCAPE] = new XML_HTMLSax3_EscapeState();
 170         }
 171
 172         /**
 173          * Moves the position back one character
 174          * @access protected
 175          * @return void
 176          */
 177         function unscanCharacter() {
 178                 $this->position -= 1;
 179         }
 180
 181         /**
 182          * Moves the position forward one character
 183          * @access protected
 184          * @return void
 185          */
 186         function ignoreCharacter() {
 187                 $this->position += 1;
 188         }
 189
 190         /**
 191          * Returns the next character from the XML document or void if at end
 192          * @access protected
 193          * @return mixed
 194          */
 195         function scanCharacter() {
 196                 if ($this->position < $this->length) {
 197                         return $this->rawtext[$this->position++];
 198                 }
 199         }
 200
 201         /**
 202          * Returns a string from the current position to the next occurance
 203          * of the supplied string
 204          * @param string string to search until
 205          * @access protected
 206          * @return string
 207          */
 208         function scanUntilString($string) {
 209                 $start = $this->position;
 210                 $this->position = strpos($this->rawtext, $string, $start);
 211                 if ($this->position === FALSE) {
 212                         $this->position = $this->length;
 213                 }
 214                 return substr($this->rawtext, $start, $this->position - $start);
 215         }
 216
 217         /**
 218          * Returns a string from the current position until the first instance of
 219          * one of the characters in the supplied string argument
 220          * @param string string to search until
 221          * @access protected
 222          * @return string
 223          * @abstract
 224          */
 225         function scanUntilCharacters($string) {}
 226
 227         /**
 228          * Moves the position forward past any whitespace characters
 229          * @access protected
 230          * @return void
 231          * @abstract
 232          */
 233         function ignoreWhitespace() {}
 234
 235         /**
 236          * Begins the parsing operation, setting up any decorators, depending on
 237          * parse options invoking _parse() to execute parsing
 238          * @param string XML document to parse
 239          * @access protected
 240          * @return void
 241          */
 242         function parse($data) {
 243                 if ($this->parser_options['XML_OPTION_TRIM_DATA_NODES']==1) {
 244                         $decorator = new XML_HTMLSax3_Trim(
 245                         $this->handler_object_data,
 246                         $this->handler_method_data);
 247                         $this->handler_object_data =& $decorator;
 248                         $this->handler_method_data = 'trimData';
 249                 }
 250                 if ($this->parser_options['XML_OPTION_CASE_FOLDING']==1) {
 251                         $open_decor = new XML_HTMLSax3_CaseFolding(
 252                         $this->handler_object_element,
 253                         $this->handler_method_opening,
 254                         $this->handler_method_closing);
 255                         $this->handler_object_element =& $open_decor;
 256                         $this->handler_method_opening ='foldOpen';
 257                         $this->handler_method_closing ='foldClose';
 258                 }
 259                 if ($this->parser_options['XML_OPTION_LINEFEED_BREAK']==1) {
 260                         $decorator = new XML_HTMLSax3_Linefeed(
 261                         $this->handler_object_data,
 262                         $this->handler_method_data);
 263                         $this->handler_object_data =& $decorator;
 264                         $this->handler_method_data = 'breakData';
 265                 }
 266                 if ($this->parser_options['XML_OPTION_TAB_BREAK']==1) {
 267                         $decorator = new XML_HTMLSax3_Tab(
 268                         $this->handler_object_data,
 269                         $this->handler_method_data);
 270                         $this->handler_object_data =& $decorator;
 271                         $this->handler_method_data = 'breakData';
 272                 }
 273                 if ($this->parser_options['XML_OPTION_ENTITIES_UNPARSED']==1) {
 274                         $decorator = new XML_HTMLSax3_Entities_Unparsed(
 275                         $this->handler_object_data,
 276                         $this->handler_method_data);
 277                         $this->handler_object_data =& $decorator;
 278                         $this->handler_method_data = 'breakData';
 279                 }
 280                 if ($this->parser_options['XML_OPTION_ENTITIES_PARSED']==1) {
 281                         $decorator = new XML_HTMLSax3_Entities_Parsed(
 282                         $this->handler_object_data,
 283                         $this->handler_method_data);
 284                         $this->handler_object_data =& $decorator;
 285                         $this->handler_method_data = 'breakData';
 286                 }
 287                 // Note switched on by default
 288                 if ($this->parser_options['XML_OPTION_STRIP_ESCAPES']==1) {
 289                         $decorator = new XML_HTMLSax3_Escape_Stripper(
 290                         $this->handler_object_escape,
 291                         $this->handler_method_escape);
 292                         $this->handler_object_escape =& $decorator;
 293                         $this->handler_method_escape = 'strip';
 294                 }
 295                 $this->rawtext = $data;
 296                 $this->length = strlen($data);
 297                 $this->position = 0;
 298                 $this->_parse();
 299         }
 300
 301         /**
 302          * Performs the parsing itself, delegating calls to a specific parser
 303          * state
 304          * @param constant state object to parse with
 305          * @access protected
 306          * @return void
 307          */
 308         function _parse($state = XML_HTMLSAX3_STATE_START) {
 309                 do {
 310                         $state = $this->State[$state]->parse($this);
 311                 } while ($state != XML_HTMLSAX3_STATE_STOP &&
 312                 $this->position < $this->length);
 313         }
 314 }
 315
 316 /**
 317  * Parser for PHP Versions equal to or greater than 4.3.0. Uses a faster
 318  * parsing mechanism than the equivalent PHP < 4.3.0 subclass of StateParser
 319  * @package XML_HTMLSax3
 320  * @access protected
 321  */
 322 class XML_HTMLSax3_StateParser_Gtet430 extends XML_HTMLSax3_StateParser {
 323         /**
 324          * Constructs XML_HTMLSax3_StateParser_Gtet430 defining available
 325          * parser options
 326          * @var XML_HTMLSax3 instance of user front end class
 327          * @access protected
 328          */
 329         function __construct(& $htmlsax) {
 330                 parent::__construct($htmlsax);
 331                 $this->parser_options['XML_OPTION_TRIM_DATA_NODES'] = 0;
 332                 $this->parser_options['XML_OPTION_CASE_FOLDING'] = 0;
 333                 $this->parser_options['XML_OPTION_LINEFEED_BREAK'] = 0;
 334                 $this->parser_options['XML_OPTION_TAB_BREAK'] = 0;
 335                 $this->parser_options['XML_OPTION_ENTITIES_PARSED'] = 0;
 336                 $this->parser_options['XML_OPTION_ENTITIES_UNPARSED'] = 0;
 337                 $this->parser_options['XML_OPTION_STRIP_ESCAPES'] = 0;
 338         }
 339         /**
 340          * Returns a string from the current position until the first instance of
 341          * one of the characters in the supplied string argument.
 342          * @param string string to search until
 343          * @access protected
 344          * @return string
 345          */
 346         function scanUntilCharacters($string) {
 347                 $startpos = $this->position;
 348                 $length = strcspn($this->rawtext, $string, $startpos);
 349                 $this->position += $length;
 350                 return substr($this->rawtext, $startpos, $length);
 351         }
 352
 353         /**
 354          * Moves the position forward past any whitespace characters
 355          * @access protected
 356          * @return void
 357          */
 358         function ignoreWhitespace() {
 359                 $this->position += strspn($this->rawtext, " \n\r\t", $this->position);
 360         }
 361
 362         /**
 363          * Begins the parsing operation, setting up the parsed and unparsed
 364          * XML entity decorators if necessary then delegating further work
 365          * to parent
 366          * @param string XML document to parse
 367          * @access protected
 368          * @return void
 369          */
 370         function parse($data) {
 371                 parent::parse($data);
 372         }
 373 }
 374
 375 /**
 376  * Default NullHandler for methods which were not set by user
 377  * @package XML_HTMLSax3
 378  * @access protected
 379  */
 380 class XML_HTMLSax3_NullHandler {
 381         /**
 382          * Generic handler method which does nothing
 383          * @access protected
 384          * @return void
 385          */
 386         function DoNothing() {
 387         }
 388 }
 389
 390 /**
 391  * User interface class. All user calls should only be made to this class
 392  * @package XML_HTMLSax3
 393  * @access public
 394  */
 395 class XML_HTMLSax3 {
 396         /**
 397          * Instance of concrete subclass of XML_HTMLSax3_StateParser
 398          * @var XML_HTMLSax3_StateParser
 399          * @access private
 400          */
 401         var $state_parser;
 402
 403         /**
 404          * Constructs XML_HTMLSax3 selecting concrete StateParser subclass
 405          * depending on PHP version being used as well as setting the default
 406          * NullHandler for all callbacks<br />
 407          * <b>Example:</b>
 408          * <pre>
 409          * $myHandler = new MyHandler();
 410          * $parser = new XML_HTMLSax3();
 411          * $parser->set_object($myHandler);
 412          * $parser->set_option('XML_OPTION_CASE_FOLDING');
 413          * $parser->set_element_handler('myOpenHandler','myCloseHandler');
 414          * $parser->set_data_handler('myDataHandler');
 415          * $parser->parser($xml);
 416          * </pre>
 417          * @access public
 418          */
 419         function __construct() {
 420                 $this->state_parser = new XML_HTMLSax3_StateParser_Gtet430($this);
 421                 $nullhandler = new XML_HTMLSax3_NullHandler();
 422                 $this->set_object($nullhandler);
 423                 $this->set_element_handler('DoNothing', 'DoNothing');
 424                 $this->set_data_handler('DoNothing');
 425                 $this->set_pi_handler('DoNothing');
 426                 $this->set_jasp_handler('DoNothing');
 427                 $this->set_escape_handler('DoNothing');
 428         }
 429
 430         /**
 431          * Sets the user defined handler object. Returns a PEAR Error
 432          * if supplied argument is not an object.
 433          * @param object handler object containing SAX callback methods
 434          * @access public
 435          * @return mixed
 436          */
 437         function set_object(&$object) {
 438                 if ( is_object($object) ) {
 439                         $this->state_parser->handler_default =& $object;
 440                         return true;
 441                 } else {
 442                         require_once('PEAR.php');
 443                         PEAR::raiseError('XML_HTMLSax3::set_object requires '.
 444                                 'an object instance');
 445                 }
 446         }
 447
 448         /**
 449          * Sets a parser option. By default all options are switched off.
 450          * Returns a PEAR Error if option is invalid<br />
 451          * <b>Available options:</b>
 452          * <ul>
 453          * <li>XML_OPTION_TRIM_DATA_NODES: trim whitespace off the beginning
 454          * and end of data passed to the data handler</li>
 455          * <li>XML_OPTION_LINEFEED_BREAK: linefeeds result in additional data
 456          * handler calls</li>
 457          * <li>XML_OPTION_TAB_BREAK: tabs result in additional data handler
 458          * calls</li>
 459          * <li>XML_OPTION_ENTITIES_UNPARSED: XML entities are returned as
 460          * seperate data handler calls in unparsed form</li>
 461          * <li>XML_OPTION_ENTITIES_PARSED: (PHP 4.3.0+ only) XML entities are
 462          * returned as seperate data handler calls and are parsed with
 463          * PHP's html_entity_decode() function</li>
 464          * <li>XML_OPTION_STRIP_ESCAPES: strips out the -- -- comment markers
 465          * or CDATA markup inside an XML escape, if found.</li>
 466          * </ul>
 467          * To get HTMLSax to behave in the same way as the native PHP SAX parser,
 468          * using it's default state, you need to switch on XML_OPTION_LINEFEED_BREAK,
 469          * XML_OPTION_ENTITIES_PARSED and XML_OPTION_CASE_FOLDING
 470          * @param string name of parser option
 471          * @param int (optional) 1 to switch on, 0 for off
 472          * @access public
 473          * @return boolean
 474          */
 475         function set_option($name, $value=1) {
 476                 if ( array_key_exists($name,$this->state_parser->parser_options) ) {
 477                         $this->state_parser->parser_options[$name] = $value;
 478                         return true;
 479                 } else {
 480                         require_once('PEAR.php');
 481                         PEAR::raiseError('XML_HTMLSax3::set_option('.$name.') illegal');
 482                 }
 483         }
 484
 485         /**
 486          * Sets the data handler method which deals with the contents of XML
 487          * elements.<br />
 488          * The handler method must accept two arguments, the first being an
 489          * instance of XML_HTMLSax3 and the second being the contents of an
 490          * XML element e.g.
 491          * <pre>
 492          * function myDataHander(& $parser,$data){}
 493          * </pre>
 494          * @param string name of method
 495          * @access public
 496          * @return void
 497          * @see set_object
 498          */
 499         function set_data_handler($data_method) {
 500                 $this->state_parser->handler_object_data =& $this->state_parser->handler_default;
 501                 $this->state_parser->handler_method_data = $data_method;
 502         }
 503
 504         /**
 505          * Sets the open and close tag handlers
 506          * <br />The open handler method must accept three arguments; the parser,
 507          * the tag name and an array of attributes e.g.
 508          * <pre>
 509          * function myOpenHander(& $parser,$tagname,$attrs=array()){}
 510          * </pre>
 511          * The close handler method must accept two arguments; the parser and
 512          * the tag name e.g.
 513          * <pre>
 514          * function myCloseHander(& $parser,$tagname){}
 515          * </pre>
 516          * @param string name of open method
 517          * @param string name of close method
 518          * @access public
 519          * @return void
 520          * @see set_object
 521          */
 522         function set_element_handler($opening_method, $closing_method) {
 523                 $this->state_parser->handler_object_element =& $this->state_parser->handler_default;
 524                 $this->state_parser->handler_method_opening = $opening_method;
 525                 $this->state_parser->handler_method_closing = $closing_method;
 526         }
 527
 528         /**
 529          * Sets the processing instruction handler method e.g. for PHP open
 530          * and close tags<br />
 531          * The handler method must accept three arguments; the parser, the
 532          * PI target and data inside the PI
 533          * <pre>
 534          * function myPIHander(& $parser,$target, $data){}
 535          * </pre>
 536          * @param string name of method
 537          * @access public
 538          * @return void
 539          * @see set_object
 540          */
 541         function set_pi_handler($pi_method) {
 542                 $this->state_parser->handler_object_pi =& $this->state_parser->handler_default;
 543                 $this->state_parser->handler_method_pi = $pi_method;
 544         }
 545
 546         /**
 547          * Sets the XML escape handler method e.g. for comments and doctype
 548          * declarations<br />
 549          * The handler method must accept two arguments; the parser and the
 550          * contents of the escaped section
 551          * <pre>
 552          * function myEscapeHander(& $parser, $data){}
 553          * </pre>
 554          * @param string name of method
 555          * @access public
 556          * @return void
 557          * @see set_object
 558          */
 559         function set_escape_handler($escape_method) {
 560                 $this->state_parser->handler_object_escape =& $this->state_parser->handler_default;
 561                 $this->state_parser->handler_method_escape = $escape_method;
 562         }
 563
 564         /**
 565          * Sets the JSP/ASP markup handler<br />
 566          * The handler method must accept two arguments; the parser and
 567          * body of the JASP tag
 568          * <pre>
 569          * function myJaspHander(& $parser, $data){}
 570          * </pre>
 571          * @param string name of method
 572          * @access public
 573          * @return void
 574          * @see set_object
 575          */
 576         function set_jasp_handler ($jasp_method) {
 577                 $this->state_parser->handler_object_jasp =& $this->state_parser->handler_default;
 578                 $this->state_parser->handler_method_jasp = $jasp_method;
 579         }
 580
 581         /**
 582          * Returns the current string position of the "cursor" inside the XML
 583          * document
 584          * <br />Intended for use from within a user defined handler called
 585          * via the $parser reference e.g.
 586          * <pre>
 587          * function myDataHandler(& $parser,$data) {
 588          *     echo( 'Current position: '.$parser->get_current_position() );
 589          * }
 590          * </pre>
 591          * @access public
 592          * @return int
 593          * @see get_length
 594          */
 595         function get_current_position() {
 596                 return $this->state_parser->position;
 597         }
 598
 599         /**
 600          * Returns the string length of the XML document being parsed
 601          * @access public
 602          * @return int
 603          */
 604         function get_length() {
 605                 return $this->state_parser->length;
 606         }
 607
 608         /**
 609          * Start parsing some XML
 610          * @param string XML document
 611          * @access public
 612          * @return void
 613          */
 614         function parse($data) {
 615                 $this->state_parser->parse($data);
 616         }
 617 }