Source for file PH5P.php

Documentation is available at PH5P.php

  1. <?php
  2.  
  3. /**
  4.  * Experimental HTML5-based parser using Jeroen van der Meer's PH5P library.
  5.  * Occupies space in the HTML5 pseudo-namespace, which may cause conflicts.
  6.  * 
  7.  * @note
  8.  *     Recent changes to PHP's DOM extension have resulted in some fatal
  9.  *     error conditions with the original version of PH5P. Pending changes,
  10.  *     this lexer will punt to DirectLex if DOM throughs an exception.
  11.  */
  12.  
  13. class HTMLPurifier_Lexer_PH5P extends HTMLPurifier_Lexer_DOMLex {
  14.     
  15.     public function tokenizeHTML($html, $config, $context) {
  16.         $new_html = $this->normalize($html, $config, $context);
  17.         $new_html = $this->wrapHTML($new_html, $config, $context);
  18.         try {
  19.             $parser = new HTML5($new_html);
  20.             $doc = $parser->save();
  21.         } catch (DOMException $e) {
  22.             // Uh oh, it failed. Punt to DirectLex.
  23.             $lexer = new HTMLPurifier_Lexer_DirectLex();
  24.             $context->register('PH5PError', $e); // save the error, so we can detect it
  25.             return $lexer->tokenizeHTML($html, $config, $context); // use original HTML
  26.         }
  27.         $tokens = array();
  28.         $this->tokenizeDOM(
  29.             $doc->getElementsByTagName('html')->item(0)-> // <html>
  30.                   getElementsByTagName('body')->item(0)-> //   <body>
  31.                   getElementsByTagName('div')->item(0)    //     <div>
  32.             , $tokens);
  33.         return $tokens;
  34.     }
  35.     
  36. }
  37.  
  38. /*
  39.  
  40. Copyright 2007 Jeroen van der Meer <http://jero.net/> 
  41.  
  42. Permission is hereby granted, free of charge, to any person obtaining a 
  43. copy of this software and associated documentation files (the 
  44. "Software"), to deal in the Software without restriction, including 
  45. without limitation the rights to use, copy, modify, merge, publish, 
  46. distribute, sublicense, and/or sell copies of the Software, and to 
  47. permit persons to whom the Software is furnished to do so, subject to 
  48. the following conditions: 
  49.  
  50. The above copyright notice and this permission notice shall be included 
  51. in all copies or substantial portions of the Software. 
  52.  
  53. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
  54. OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
  55. MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
  56. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
  57. CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
  58. TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
  59. SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
  60.  
  61. */
  62.  
  63. class HTML5 {
  64.     private $data;
  65.     private $char;
  66.     private $EOF;
  67.     private $state;
  68.     private $tree;
  69.     private $token;
  70.     private $content_model;
  71.     private $escape = false;
  72.     private $entities = array('AElig;','AElig','AMP;','AMP','Aacute;','Aacute',
  73.     'Acirc;','Acirc','Agrave;','Agrave','Alpha;','Aring;','Aring','Atilde;',
  74.     'Atilde','Auml;','Auml','Beta;','COPY;','COPY','Ccedil;','Ccedil','Chi;',
  75.     'Dagger;','Delta;','ETH;','ETH','Eacute;','Eacute','Ecirc;','Ecirc','Egrave;',
  76.     'Egrave','Epsilon;','Eta;','Euml;','Euml','GT;','GT','Gamma;','Iacute;',
  77.     'Iacute','Icirc;','Icirc','Igrave;','Igrave','Iota;','Iuml;','Iuml','Kappa;',
  78.     'LT;','LT','Lambda;','Mu;','Ntilde;','Ntilde','Nu;','OElig;','Oacute;',
  79.     'Oacute','Ocirc;','Ocirc','Ograve;','Ograve','Omega;','Omicron;','Oslash;',
  80.     'Oslash','Otilde;','Otilde','Ouml;','Ouml','Phi;','Pi;','Prime;','Psi;',
  81.     'QUOT;','QUOT','REG;','REG','Rho;','Scaron;','Sigma;','THORN;','THORN',
  82.     'TRADE;','Tau;','Theta;','Uacute;','Uacute','Ucirc;','Ucirc','Ugrave;',
  83.     'Ugrave','Upsilon;','Uuml;','Uuml','Xi;','Yacute;','Yacute','Yuml;','Zeta;',
  84.     'aacute;','aacute','acirc;','acirc','acute;','acute','aelig;','aelig',
  85.     'agrave;','agrave','alefsym;','alpha;','amp;','amp','and;','ang;','apos;',
  86.     'aring;','aring','asymp;','atilde;','atilde','auml;','auml','bdquo;','beta;',
  87.     'brvbar;','brvbar','bull;','cap;','ccedil;','ccedil','cedil;','cedil',
  88.     'cent;','cent','chi;','circ;','clubs;','cong;','copy;','copy','crarr;',
  89.     'cup;','curren;','curren','dArr;','dagger;','darr;','deg;','deg','delta;',
  90.     'diams;','divide;','divide','eacute;','eacute','ecirc;','ecirc','egrave;',
  91.     'egrave','empty;','emsp;','ensp;','epsilon;','equiv;','eta;','eth;','eth',
  92.     'euml;','euml','euro;','exist;','fnof;','forall;','frac12;','frac12',
  93.     'frac14;','frac14','frac34;','frac34','frasl;','gamma;','ge;','gt;','gt',
  94.     'hArr;','harr;','hearts;','hellip;','iacute;','iacute','icirc;','icirc',
  95.     'iexcl;','iexcl','igrave;','igrave','image;','infin;','int;','iota;',
  96.     'iquest;','iquest','isin;','iuml;','iuml','kappa;','lArr;','lambda;','lang;',
  97.     'laquo;','laquo','larr;','lceil;','ldquo;','le;','lfloor;','lowast;','loz;',
  98.     'lrm;','lsaquo;','lsquo;','lt;','lt','macr;','macr','mdash;','micro;','micro',
  99.     'middot;','middot','minus;','mu;','nabla;','nbsp;','nbsp','ndash;','ne;',
  100.     'ni;','not;','not','notin;','nsub;','ntilde;','ntilde','nu;','oacute;',
  101.     'oacute','ocirc;','ocirc','oelig;','ograve;','ograve','oline;','omega;',
  102.     'omicron;','oplus;','or;','ordf;','ordf','ordm;','ordm','oslash;','oslash',
  103.     'otilde;','otilde','otimes;','ouml;','ouml','para;','para','part;','permil;',
  104.     'perp;','phi;','pi;','piv;','plusmn;','plusmn','pound;','pound','prime;',
  105.     'prod;','prop;','psi;','quot;','quot','rArr;','radic;','rang;','raquo;',
  106.     'raquo','rarr;','rceil;','rdquo;','real;','reg;','reg','rfloor;','rho;',
  107.     'rlm;','rsaquo;','rsquo;','sbquo;','scaron;','sdot;','sect;','sect','shy;',
  108.     'shy','sigma;','sigmaf;','sim;','spades;','sub;','sube;','sum;','sup1;',
  109.     'sup1','sup2;','sup2','sup3;','sup3','sup;','supe;','szlig;','szlig','tau;',
  110.     'there4;','theta;','thetasym;','thinsp;','thorn;','thorn','tilde;','times;',
  111.     'times','trade;','uArr;','uacute;','uacute','uarr;','ucirc;','ucirc',
  112.     'ugrave;','ugrave','uml;','uml','upsih;','upsilon;','uuml;','uuml','weierp;',
  113.     'xi;','yacute;','yacute','yen;','yen','yuml;','yuml','zeta;','zwj;','zwnj;');
  114.  
  115.     const PCDATA    = 0;
  116.     const RCDATA    = 1;
  117.     const CDATA     = 2;
  118.     const PLAINTEXT = 3;
  119.  
  120.     const DOCTYPE  = 0;
  121.     const STARTTAG = 1;
  122.     const ENDTAG   = 2;
  123.     const COMMENT  = 3;
  124.     const CHARACTR = 4;
  125.     const EOF      = 5;
  126.  
  127.     public function __construct($data) {
  128.         $data = str_replace("\r\n", "\n", $data);
  129.         $data = str_replace("\r", null, $data);
  130.  
  131.         $this->data = $data;
  132.         $this->char = -1;
  133.         $this->EOF  = strlen($data);
  134.         $this->tree = new HTML5TreeConstructer;
  135.         $this->content_model = self::PCDATA;
  136.  
  137.         $this->state = 'data';
  138.  
  139.         while($this->state !== null) {
  140.             $this->{$this->state.'State'}();
  141.         }
  142.     }
  143.  
  144.     public function save() {
  145.         return $this->tree->save();
  146.     }
  147.  
  148.     private function char() {
  149.         return ($this->char < $this->EOF)
  150.             ? $this->data[$this->char]
  151.             : false;
  152.     }
  153.  
  154.     private function character($s, $l = 0) {
  155.         if($s + $l < $this->EOF) {
  156.             if($l === 0) {
  157.                 return $this->data[$s];
  158.             } else {
  159.                 return substr($this->data, $s, $l);
  160.             }
  161.         }
  162.     }
  163.  
  164.     private function characters($char_class, $start) {
  165.         return preg_replace('#^(['.$char_class.']+).*#s', '\\1', substr($this->data, $start));
  166.     }
  167.  
  168.     private function dataState() {
  169.         // Consume the next input character
  170.         $this->char++;
  171.         $char = $this->char();
  172.  
  173.         if($char === '&' && ($this->content_model === self::PCDATA || $this->content_model === self::RCDATA)) {
  174.             /* U+0026 AMPERSAND (&)
  175.             When the content model flag is set to one of the PCDATA or RCDATA
  176.             states: switch to the entity data state. Otherwise: treat it as per
  177.             the "anything else"    entry below. */
  178.             $this->state = 'entityData';
  179.  
  180.         } elseif($char === '-') {
  181.             /* If the content model flag is set to either the RCDATA state or
  182.             the CDATA state, and the escape flag is false, and there are at
  183.             least three characters before this one in the input stream, and the
  184.             last four characters in the input stream, including this one, are
  185.             U+003C LESS-THAN SIGN, U+0021 EXCLAMATION MARK, U+002D HYPHEN-MINUS,
  186.             and U+002D HYPHEN-MINUS ("<!--"), then set the escape flag to true. */
  187.             if(($this->content_model === self::RCDATA || $this->content_model ===
  188.             self::CDATA) && $this->escape === false &&
  189.             $this->char >= 3 && $this->character($this->char - 4, 4) === '<!--') {
  190.                 $this->escape = true;
  191.             }
  192.  
  193.             /* In any case, emit the input character as a character token. Stay
  194.             in the data state. */
  195.             $this->emitToken(array(
  196.                 'type' => self::CHARACTR,
  197.                 'data' => $char
  198.             ));
  199.  
  200.         /* U+003C LESS-THAN SIGN (<) */
  201.         } elseif($char === '<' && ($this->content_model === self::PCDATA ||
  202.         (($this->content_model === self::RCDATA ||
  203.         $this->content_model === self::CDATA) && $this->escape === false))) {
  204.             /* When the content model flag is set to the PCDATA state: switch
  205.             to the tag open state.
  206.  
  207.             When the content model flag is set to either the RCDATA state or
  208.             the CDATA state and the escape flag is false: switch to the tag
  209.             open state.
  210.  
  211.             Otherwise: treat it as per the "anything else" entry below. */
  212.             $this->state = 'tagOpen';
  213.  
  214.         /* U+003E GREATER-THAN SIGN (>) */
  215.         } elseif($char === '>') {
  216.             /* If the content model flag is set to either the RCDATA state or
  217.             the CDATA state, and the escape flag is true, and the last three
  218.             characters in the input stream including this one are U+002D
  219.             HYPHEN-MINUS, U+002D HYPHEN-MINUS, U+003E GREATER-THAN SIGN ("-->"),
  220.             set the escape flag to false. */
  221.             if(($this->content_model === self::RCDATA ||
  222.             $this->content_model === self::CDATA) && $this->escape === true &&
  223.             $this->character($this->char, 3) === '-->') {
  224.                 $this->escape = false;
  225.             }
  226.  
  227.             /* In any case, emit the input character as a character token.
  228.             Stay in the data state. */
  229.             $this->emitToken(array(
  230.                 'type' => self::CHARACTR,
  231.                 'data' => $char
  232.             ));
  233.  
  234.         } elseif($this->char === $this->EOF) {
  235.             /* EOF
  236.             Emit an end-of-file token. */
  237.             $this->EOF();
  238.  
  239.         } elseif($this->content_model === self::PLAINTEXT) {
  240.             /* When the content model flag is set to the PLAINTEXT state
  241.             THIS DIFFERS GREATLY FROM THE SPEC: Get the remaining characters of
  242.             the text and emit it as a character token. */
  243.             $this->emitToken(array(
  244.                 'type' => self::CHARACTR,
  245.                 'data' => substr($this->data, $this->char)
  246.             ));
  247.  
  248.             $this->EOF();
  249.  
  250.         } else {
  251.             /* Anything else
  252.             THIS DIFFERS GREATLY FROM THE SPEC: Get as many character that
  253.             otherwise would also be treated as a character token and emit it
  254.             as a single character token. Stay in the data state. */
  255.             $len  = strcspn($this->data, '<&', $this->char);
  256.             $char = substr($this->data, $this->char, $len);
  257.             $this->char += $len - 1;
  258.  
  259.             $this->emitToken(array(
  260.                 'type' => self::CHARACTR,
  261.                 'data' => $char
  262.             ));
  263.  
  264.             $this->state = 'data';
  265.         }
  266.     }
  267.  
  268.     private function entityDataState() {
  269.         // Attempt to consume an entity.
  270.         $entity = $this->entity();
  271.  
  272.         // If nothing is returned, emit a U+0026 AMPERSAND character token.
  273.         // Otherwise, emit the character token that was returned.
  274.         $char = (!$entity) ? '&' : $entity;
  275.         $this->emitToken(array(
  276.             'type' => self::CHARACTR,
  277.             'data' => $char
  278.         ));
  279.  
  280.         // Finally, switch to the data state.
  281.         $this->state = 'data';
  282.     }
  283.  
  284.     private function tagOpenState() {
  285.         switch($this->content_model) {
  286.             case self::RCDATA:
  287.             case self::CDATA:
  288.                 /* If the next input character is a U+002F SOLIDUS (/) character,
  289.                 consume it and switch to the close tag open state. If the next
  290.                 input character is not a U+002F SOLIDUS (/) character, emit a
  291.                 U+003C LESS-THAN SIGN character token and switch to the data
  292.                 state to process the next input character. */
  293.                 if($this->character($this->char + 1) === '/') {
  294.                     $this->char++;
  295.                     $this->state = 'closeTagOpen';
  296.  
  297.                 } else {
  298.                     $this->emitToken(array(
  299.                         'type' => self::CHARACTR,
  300.                         'data' => '<'
  301.                     ));
  302.  
  303.                     $this->state = 'data';
  304.                 }
  305.             break;
  306.  
  307.             case self::PCDATA:
  308.                 // If the content model flag is set to the PCDATA state
  309.                 // Consume the next input character:
  310.                 $this->char++;
  311.                 $char = $this->char();
  312.  
  313.                 if($char === '!') {
  314.                     /* U+0021 EXCLAMATION MARK (!)
  315.                     Switch to the markup declaration open state. */
  316.                     $this->state = 'markupDeclarationOpen';
  317.  
  318.                 } elseif($char === '/') {
  319.                     /* U+002F SOLIDUS (/)
  320.                     Switch to the close tag open state. */
  321.                     $this->state = 'closeTagOpen';
  322.  
  323.                 } elseif(preg_match('/^[A-Za-z]$/', $char)) {
  324.                     /* U+0041 LATIN LETTER A through to U+005A LATIN LETTER Z
  325.                     Create a new start tag token, set its tag name to the lowercase
  326.                     version of the input character (add 0x0020 to the character's code
  327.                     point), then switch to the tag name state. (Don't emit the token
  328.                     yet; further details will be filled in before it is emitted.) */
  329.                     $this->token = array(
  330.                         'name'  => strtolower($char),
  331.                         'type'  => self::STARTTAG,
  332.                         'attr'  => array()
  333.                     );
  334.  
  335.                     $this->state = 'tagName';
  336.  
  337.                 } elseif($char === '>') {
  338.                     /* U+003E GREATER-THAN SIGN (>)
  339.                     Parse error. Emit a U+003C LESS-THAN SIGN character token and a
  340.                     U+003E GREATER-THAN SIGN character token. Switch to the data state. */
  341.                     $this->emitToken(array(
  342.                         'type' => self::CHARACTR,
  343.                         'data' => '<>'
  344.                     ));
  345.  
  346.                     $this->state = 'data';
  347.  
  348.                 } elseif($char === '?') {
  349.                     /* U+003F QUESTION MARK (?)
  350.                     Parse error. Switch to the bogus comment state. */
  351.                     $this->state = 'bogusComment';
  352.  
  353.                 } else {
  354.                     /* Anything else
  355.                     Parse error. Emit a U+003C LESS-THAN SIGN character token and
  356.                     reconsume the current input character in the data state. */
  357.                     $this->emitToken(array(
  358.                         'type' => self::CHARACTR,
  359.                         'data' => '<'
  360.                     ));
  361.  
  362.                     $this->char--;
  363.                     $this->state = 'data';
  364.                 }
  365.             break;
  366.         }
  367.     }
  368.  
  369.     private function closeTagOpenState() {
  370.         $next_node = strtolower($this->characters('A-Za-z', $this->char + 1));
  371.         $the_same = count($this->tree->stack) > 0 && $next_node === end($this->tree->stack)->nodeName;
  372.  
  373.         if(($this->content_model === self::RCDATA || $this->content_model === self::CDATA) &&
  374.         (!$the_same || ($the_same && (!preg_match('/[\t\n\x0b\x0c >\/]/',
  375.         $this->character($this->char + 1 + strlen($next_node))) || $this->EOF === $this->char)))) {
  376.             /* If the content model flag is set to the RCDATA or CDATA states then
  377.             examine the next few characters. If they do not match the tag name of
  378.             the last start tag token emitted (case insensitively), or if they do but
  379.             they are not immediately followed by one of the following characters:
  380.                 * U+0009 CHARACTER TABULATION
  381.                 * U+000A LINE FEED (LF)
  382.                 * U+000B LINE TABULATION
  383.                 * U+000C FORM FEED (FF)
  384.                 * U+0020 SPACE
  385.                 * U+003E GREATER-THAN SIGN (>)
  386.                 * U+002F SOLIDUS (/)
  387.                 * EOF
  388.             ...then there is a parse error. Emit a U+003C LESS-THAN SIGN character
  389.             token, a U+002F SOLIDUS character token, and switch to the data state
  390.             to process the next input character. */
  391.             $this->emitToken(array(
  392.                 'type' => self::CHARACTR,
  393.                 'data' => '</'
  394.             ));
  395.  
  396.             $this->state = 'data';
  397.  
  398.         } else {
  399.             /* Otherwise, if the content model flag is set to the PCDATA state,
  400.             or if the next few characters do match that tag name, consume the
  401.             next input character: */
  402.             $this->char++;
  403.             $char = $this->char();
  404.  
  405.             if(preg_match('/^[A-Za-z]$/', $char)) {
  406.                 /* U+0041 LATIN LETTER A through to U+005A LATIN LETTER Z
  407.                 Create a new end tag token, set its tag name to the lowercase version
  408.                 of the input character (add 0x0020 to the character's code point), then
  409.                 switch to the tag name state. (Don't emit the token yet; further details
  410.                 will be filled in before it is emitted.) */
  411.                 $this->token = array(
  412.                     'name'  => strtolower($char),
  413.                     'type'  => self::ENDTAG
  414.                 );
  415.  
  416.                 $this->state = 'tagName';
  417.  
  418.             } elseif($char === '>') {
  419.                 /* U+003E GREATER-THAN SIGN (>)
  420.                 Parse error. Switch to the data state. */
  421.                 $this->state = 'data';
  422.  
  423.             } elseif($this->char === $this->EOF) {
  424.                 /* EOF
  425.                 Parse error. Emit a U+003C LESS-THAN SIGN character token and a U+002F
  426.                 SOLIDUS character token. Reconsume the EOF character in the data state. */
  427.                 $this->emitToken(array(
  428.      &