PageRenderTime 64ms CodeModel.GetById 23ms RepoModel.GetById 1ms app.codeStats 0ms

/wp-content/plugins/html-purified/lib/HTMLPurifier/Lexer/PH5P.php

https://bitbucket.org/crypticrod/sr_wp_code
PHP | 3904 lines | 1977 code | 614 blank | 1313 comment | 305 complexity | fe014dc9d00bc84352578e9183917d24 MD5 | raw file
Possible License(s): AGPL-1.0, GPL-2.0, LGPL-2.1, GPL-3.0, LGPL-2.0, AGPL-3.0

Large files files are truncated, but you can click here to view the full file

    

  1. <?php
    2. 

  2. 

  3. /**
    4. 

  4.  * Experimental HTML5-based parser using Jeroen van der Meer's PH5P library.
    5. 

  5.  * Occupies space in the HTML5 pseudo-namespace, which may cause conflicts.
    6. 

  6.  * 
    7. 

  7.  * @note
    8. 

  8.  *    Recent changes to PHP's DOM extension have resulted in some fatal
    9. 

  9.  *    error conditions with the original version of PH5P. Pending changes,
    10. 

  10.  *    this lexer will punt to DirectLex if DOM throughs an exception.
    11. 

  11.  */
    12. 

  12. 

  13. class HTMLPurifier_Lexer_PH5P extends HTMLPurifier_Lexer_DOMLex {
    14. 

  14.     
    15. 

  15.     public function tokenizeHTML($html, $config, $context) {
    16. 

  16.         $new_html = $this->normalize($html, $config, $context);
    17. 

  17.         $new_html = $this->wrapHTML($new_html, $config, $context);
    18. 

  18.         try {
    19. 

  19.             $parser = new HTML5($new_html);
    20. 

  20.             $doc = $parser->save();
    21. 

  21.         } catch (DOMException $e) {
    22. 

  22.             // Uh oh, it failed. Punt to DirectLex.
    23. 

  23.             $lexer = new HTMLPurifier_Lexer_DirectLex();
    24. 

  24.             $context->register('PH5PError', $e); // save the error, so we can detect it
    25. 

  25.             return $lexer->tokenizeHTML($html, $config, $context); // use original HTML
    26. 

  26.         }
    27. 

  27.         $tokens = array();
    28. 

  28.         $this->tokenizeDOM(
    29. 

  29.             $doc->getElementsByTagName('html')->item(0)-> // <html>
    30. 

  30.                   getElementsByTagName('body')->item(0)-> //   <body>
    31. 

  31.                   getElementsByTagName('div')->item(0)    //     <div>
    32. 

  32.             , $tokens);
    33. 

  33.         return $tokens;
    34. 

  34.     }
    35. 

  35.     
    36. 

  36. }
    37. 

  37. 

  38. /*
    39. 

    40. 

  40. Copyright 2007 Jeroen van der Meer <http://jero.net/> 
    41. 

    42. 

  42. Permission is hereby granted, free of charge, to any person obtaining a 
    43. 

  43. copy of this software and associated documentation files (the 
    44. 

  44. "Software"), to deal in the Software without restriction, including 
    45. 

  45. without limitation the rights to use, copy, modify, merge, publish, 
    46. 

  46. distribute, sublicense, and/or sell copies of the Software, and to 
    47. 

  47. permit persons to whom the Software is furnished to do so, subject to 
    48. 

  48. the following conditions: 
    49. 

    50. 

  50. The above copyright notice and this permission notice shall be included 
    51. 

  51. in all copies or substantial portions of the Software. 
    52. 

    53. 

  53. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS 
    54. 

  54. OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF 
    55. 

  55. MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 
    56. 

  56. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 
    57. 

  57. CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, 
    58. 

  58. TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE 
    59. 

  59. SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. 
    60. 

    61. 

  61. */
    62. 

  62. 

  63. class HTML5 {
    64. 

  64.     private $data;
    65. 

  65.     private $char;
    66. 

  66.     private $EOF;
    67. 

  67.     private $state;
    68. 

  68.     private $tree;
    69. 

  69.     private $token;
    70. 

  70.     private $content_model;
    71. 

  71.     private $escape = false;
    72. 

  72.     private $entities = array('AElig;','AElig','AMP;','AMP','Aacute;','Aacute',
    73. 

  73.     'Acirc;','Acirc','Agrave;','Agrave','Alpha;','Aring;','Aring','Atilde;',
    74. 

  74.     'Atilde','Auml;','Auml','Beta;','COPY;','COPY','Ccedil;','Ccedil','Chi;',
    75. 

  75.     'Dagger;','Delta;','ETH;','ETH','Eacute;','Eacute','Ecirc;','Ecirc','Egrave;',
    76. 

  76.     'Egrave','Epsilon;','Eta;','Euml;','Euml','GT;','GT','Gamma;','Iacute;',
    77. 

  77.     'Iacute','Icirc;','Icirc','Igrave;','Igrave','Iota;','Iuml;','Iuml','Kappa;',
    78. 

  78.     'LT;','LT','Lambda;','Mu;','Ntilde;','Ntilde','Nu;','OElig;','Oacute;',
    79. 

  79.     'Oacute','Ocirc;','Ocirc','Ograve;','Ograve','Omega;','Omicron;','Oslash;',
    80. 

  80.     'Oslash','Otilde;','Otilde','Ouml;','Ouml','Phi;','Pi;','Prime;','Psi;',
    81. 

  81.     'QUOT;','QUOT','REG;','REG','Rho;','Scaron;','Sigma;','THORN;','THORN',
    82. 

  82.     'TRADE;','Tau;','Theta;','Uacute;','Uacute','Ucirc;','Ucirc','Ugrave;',
    83. 

  83.     'Ugrave','Upsilon;','Uuml;','Uuml','Xi;','Yacute;','Yacute','Yuml;','Zeta;',
    84. 

  84.     'aacute;','aacute','acirc;','acirc','acute;','acute','aelig;','aelig',
    85. 

  85.     'agrave;','agrave','alefsym;','alpha;','amp;','amp','and;','ang;','apos;',
    86. 

  86.     'aring;','aring','asymp;','atilde;','atilde','auml;','auml','bdquo;','beta;',
    87. 

  87.     'brvbar;','brvbar','bull;','cap;','ccedil;','ccedil','cedil;','cedil',
    88. 

  88.     'cent;','cent','chi;','circ;','clubs;','cong;','copy;','copy','crarr;',
    89. 

  89.     'cup;','curren;','curren','dArr;','dagger;','darr;','deg;','deg','delta;',
    90. 

  90.     'diams;','divide;','divide','eacute;','eacute','ecirc;','ecirc','egrave;',
    91. 

  91.     'egrave','empty;','emsp;','ensp;','epsilon;','equiv;','eta;','eth;','eth',
    92. 

  92.     'euml;','euml','euro;','exist;','fnof;','forall;','frac12;','frac12',
    93. 

  93.     'frac14;','frac14','frac34;','frac34','frasl;','gamma;','ge;','gt;','gt',
    94. 

  94.     'hArr;','harr;','hearts;','hellip;','iacute;','iacute','icirc;','icirc',
    95. 

  95.     'iexcl;','iexcl','igrave;','igrave','image;','infin;','int;','iota;',
    96. 

  96.     'iquest;','iquest','isin;','iuml;','iuml','kappa;','lArr;','lambda;','lang;',
    97. 

  97.     'laquo;','laquo','larr;','lceil;','ldquo;','le;','lfloor;','lowast;','loz;',
    98. 

  98.     'lrm;','lsaquo;','lsquo;','lt;','lt','macr;','macr','mdash;','micro;','micro',
    99. 

  99.     'middot;','middot','minus;','mu;','nabla;','nbsp;','nbsp','ndash;','ne;',
    100. 

  100.     'ni;','not;','not','notin;','nsub;','ntilde;','ntilde','nu;','oacute;',
    101. 

  101.     'oacute','ocirc;','ocirc','oelig;','ograve;','ograve','oline;','omega;',
    102. 

  102.     'omicron;','oplus;','or;','ordf;','ordf','ordm;','ordm','oslash;','oslash',
    103. 

  103.     'otilde;','otilde','otimes;','ouml;','ouml','para;','para','part;','permil;',
    104. 

  104.     'perp;','phi;','pi;','piv;','plusmn;','plusmn','pound;','pound','prime;',
    105. 

  105.     'prod;','prop;','psi;','quot;','quot','rArr;','radic;','rang;','raquo;',
    106. 

  106.     'raquo','rarr;','rceil;','rdquo;','real;','reg;','reg','rfloor;','rho;',
    107. 

  107.     'rlm;','rsaquo;','rsquo;','sbquo;','scaron;','sdot;','sect;','sect','shy;',
    108. 

  108.     'shy','sigma;','sigmaf;','sim;','spades;','sub;','sube;','sum;','sup1;',
    109. 

  109.     'sup1','sup2;','sup2','sup3;','sup3','sup;','supe;','szlig;','szlig','tau;',
    110. 

  110.     'there4;','theta;','thetasym;','thinsp;','thorn;','thorn','tilde;','times;',
    111. 

  111.     'times','trade;','uArr;','uacute;','uacute','uarr;','ucirc;','ucirc',
    112. 

  112.     'ugrave;','ugrave','uml;','uml','upsih;','upsilon;','uuml;','uuml','weierp;',
    113. 

  113.     'xi;','yacute;','yacute','yen;','yen','yuml;','yuml','zeta;','zwj;','zwnj;');
    114. 

  114. 

  115.     const PCDATA    = 0;
    116. 

  116.     const RCDATA    = 1;
    117. 

  117.     const CDATA     = 2;
    118. 

  118.     const PLAINTEXT = 3;
    119. 

  119. 

  120.     const DOCTYPE  = 0;
    121. 

  121.     const STARTTAG = 1;
    122. 

  122.     const ENDTAG   = 2;
    123. 

  123.     const COMMENT  = 3;
    124. 

  124.     const CHARACTR = 4;
    125. 

  125.     const EOF      = 5;
    126. 

  126. 

  127.     public function __construct($data) {
    128. 

  128. 

  129.         $this->data = $data;
    130. 

  130.         $this->char = -1;
    131. 

  131.         $this->EOF  = strlen($data);
    132. 

  132.         $this->tree = new HTML5TreeConstructer;
    133. 

  133.         $this->content_model = self::PCDATA;
    134. 

  134. 

  135.         $this->state = 'data';
    136. 

  136. 

  137.         while($this->state !== null) {
    138. 

  138.             $this->{$this->state.'State'}();
    139. 

  139.         }
    140. 

  140.     }
    141. 

  141. 

  142.     public function save() {
    143. 

  143.         return $this->tree->save();
    144. 

  144.     }
    145. 

  145. 

  146.     private function char() {
    147. 

  147.         return ($this->char < $this->EOF)
    148. 

  148.             ? $this->data[$this->char]
    149. 

  149.             : false;
    150. 

  150.     }
    151. 

  151. 

  152.     private function character($s, $l = 0) {
    153. 

  153.         if($s + $l < $this->EOF) {
    154. 

  154.             if($l === 0) {
    155. 

  155.                 return $this->data[$s];
    156. 

  156.             } else {
    157. 

  157.                 return substr($this->data, $s, $l);
    158. 

  158.             }
    159. 

  159.         }
    160. 

  160.     }
    161. 

  161. 

  162.     private function characters($char_class, $start) {
    163. 

  163.         return preg_replace('#^(['.$char_class.']+).*#s', '\\1', substr($this->data, $start));
    164. 

  164.     }
    165. 

  165. 

  166.     private function dataState() {
    167. 

  167.         // Consume the next input character
    168. 

  168.         $this->char++;
    169. 

  169.         $char = $this->char();
    170. 

  170. 

  171.         if($char === '&' && ($this->content_model === self::PCDATA || $this->content_model === self::RCDATA)) {
    172. 

  172.             /* U+0026 AMPERSAND (&)
    173. 

  173.             When the content model flag is set to one of the PCDATA or RCDATA
    174. 

  174.             states: switch to the entity data state. Otherwise: treat it as per
    175. 

  175.             the "anything else"    entry below. */
    176. 

  176.             $this->state = 'entityData';
    177. 

  177. 

  178.         } elseif($char === '-') {
    179. 

  179.             /* If the content model flag is set to either the RCDATA state or
    180. 

  180.             the CDATA state, and the escape flag is false, and there are at
    181. 

  181.             least three characters before this one in the input stream, and the
    182. 

  182.             last four characters in the input stream, including this one, are
    183. 

  183.             U+003C LESS-THAN SIGN, U+0021 EXCLAMATION MARK, U+002D HYPHEN-MINUS,
    184. 

  184.             and U+002D HYPHEN-MINUS ("<!--"), then set the escape flag to true. */
    185. 

  185.             if(($this->content_model === self::RCDATA || $this->content_model ===
    186. 

  186.             self::CDATA) && $this->escape === false &&
    187. 

  187.             $this->char >= 3 && $this->character($this->char - 4, 4) === '<!--') {
    188. 

  188.                 $this->escape = true;
    189. 

  189.             }
    190. 

  190. 

  191.             /* In any case, emit the input character as a character token. Stay
    192. 

  192.             in the data state. */
    193. 

  193.             $this->emitToken(array(
    194. 

  194.                 'type' => self::CHARACTR,
    195. 

  195.                 'data' => $char
    196. 

  196.             ));
    197. 

  197. 

  198.         /* U+003C LESS-THAN SIGN (<) */
    199. 

  199.         } elseif($char === '<' && ($this->content_model === self::PCDATA ||
    200. 

  200.         (($this->content_model === self::RCDATA ||
    201. 

  201.         $this->content_model === self::CDATA) && $this->escape === false))) {
    202. 

  202.             /* When the content model flag is set to the PCDATA state: switch
    203. 

  203.             to the tag open state.
    204. 

    205. 

  205.             When the content model flag is set to either the RCDATA state or
    206. 

  206.             the CDATA state and the escape flag is false: switch to the tag
    207. 

  207.             open state.
    208. 

    209. 

  209.             Otherwise: treat it as per the "anything else" entry below. */
    210. 

  210.             $this->state = 'tagOpen';
    211. 

  211. 

  212.         /* U+003E GREATER-THAN SIGN (>) */
    213. 

  213.         } elseif($char === '>') {
    214. 

  214.             /* If the content model flag is set to either the RCDATA state or
    215. 

  215.             the CDATA state, and the escape flag is true, and the last three
    216. 

  216.             characters in the input stream including this one are U+002D
    217. 

  217.             HYPHEN-MINUS, U+002D HYPHEN-MINUS, U+003E GREATER-THAN SIGN ("-->"),
    218. 

  218.             set the escape flag to false. */
    219. 

  219.             if(($this->content_model === self::RCDATA ||
    220. 

  220.             $this->content_model === self::CDATA) && $this->escape === true &&
    221. 

  221.             $this->character($this->char, 3) === '-->') {
    222. 

  222.                 $this->escape = false;
    223. 

  223.             }
    224. 

  224. 

  225.             /* In any case, emit the input character as a character token.
    226. 

  226.             Stay in the data state. */
    227. 

  227.             $this->emitToken(array(
    228. 

  228.                 'type' => self::CHARACTR,
    229. 

  229.                 'data' => $char
    230. 

  230.             ));
    231. 

  231. 

  232.         } elseif($this->char === $this->EOF) {
    233. 

  233.             /* EOF
    234. 

  234.             Emit an end-of-file token. */
    235. 

  235.             $this->EOF();
    236. 

  236. 

  237.         } elseif($this->content_model === self::PLAINTEXT) {
    238. 

  238.             /* When the content model flag is set to the PLAINTEXT state
    239. 

  239.             THIS DIFFERS GREATLY FROM THE SPEC: Get the remaining characters of
    240. 

  240.             the text and emit it as a character token. */
    241. 

  241.             $this->emitToken(array(
    242. 

  242.                 'type' => self::CHARACTR,
    243. 

  243.                 'data' => substr($this->data, $this->char)
    244. 

  244.             ));
    245. 

  245. 

  246.             $this->EOF();
    247. 

  247. 

  248.         } else {
    249. 

  249.             /* Anything else
    250. 

  250.             THIS DIFFERS GREATLY FROM THE SPEC: Get as many character that
    251. 

  251.             otherwise would also be treated as a character token and emit it
    252. 

  252.             as a single character token. Stay in the data state. */
    253. 

  253.             $len  = strcspn($this->data, '<&', $this->char);
    254. 

  254.             $char = substr($this->data, $this->char, $len);
    255. 

  255.             $this->char += $len - 1;
    256. 

  256. 

  257.             $this->emitToken(array(
    258. 

  258.                 'type' => self::CHARACTR,
    259. 

  259.                 'data' => $char
    260. 

  260.             ));
    261. 

  261. 

  262.             $this->state = 'data';
    263. 

  263.         }
    264. 

  264.     }
    265. 

  265. 

  266.     private function entityDataState() {
    267. 

  267.         // Attempt to consume an entity.
    268. 

  268.         $entity = $this->entity();
    269. 

  269. 

  270.         // If nothing is returned, emit a U+0026 AMPERSAND character token.
    271. 

  271.         // Otherwise, emit the character token that was returned.
    272. 

  272.         $char = (!$entity) ? '&' : $entity;
    273. 

  273.         $this->emitToken(array(
    274. 

  274.             'type' => self::CHARACTR,
    275. 

  275.             'data' => $char
    276. 

  276.         ));
    277. 

  277. 

  278.         // Finally, switch to the data state.
    279. 

  279.         $this->state = 'data';
    280. 

  280.     }
    281. 

  281. 

  282.     private function tagOpenState() {
    283. 

  283.         switch($this->content_model) {
    284. 

  284.             case self::RCDATA:
    285. 

  285.             case self::CDATA:
    286. 

  286.                 /* If the next input character is a U+002F SOLIDUS (/) character,
    287. 

  287.                 consume it and switch to the close tag open state. If the next
    288. 

  288.                 input character is not a U+002F SOLIDUS (/) character, emit a
    289. 

  289.                 U+003C LESS-THAN SIGN character token and switch to the data
    290. 

  290.                 state to process the next input character. */
    291. 

  291.                 if($this->character($this->char + 1) === '/') {
    292. 

  292.                     $this->char++;
    293. 

  293.                     $this->state = 'closeTagOpen';
    294. 

  294. 

  295.                 } else {
    296. 

  296.                     $this->emitToken(array(
    297. 

  297.                         'type' => self::CHARACTR,
    298. 

  298.                         'data' => '<'
    299. 

  299.                     ));
    300. 

  300. 

  301.                     $this->state = 'data';
    302. 

  302.                 }
    303. 

  303.             break;
    304. 

  304. 

  305.             case self::PCDATA:
    306. 

  306.                 // If the content model flag is set to the PCDATA state
    307. 

  307.                 // Consume the next input character:
    308. 

  308.                 $this->char++;
    309. 

  309.                 $char = $this->char();
    310. 

  310. 

  311.                 if($char === '!') {
    312. 

  312.                     /* U+0021 EXCLAMATION MARK (!)
    313. 

  313.                     Switch to the markup declaration open state. */
    314. 

  314.                     $this->state = 'markupDeclarationOpen';
    315. 

  315. 

  316.                 } elseif($char === '/') {
    317. 

  317.                     /* U+002F SOLIDUS (/)
    318. 

  318.                     Switch to the close tag open state. */
    319. 

  319.                     $this->state = 'closeTagOpen';
    320. 

  320. 

  321.                 } elseif(preg_match('/^[A-Za-z]$/', $char)) {
    322. 

  322.                     /* U+0041 LATIN LETTER A through to U+005A LATIN LETTER Z
    323. 

  323.                     Create a new start tag token, set its tag name to the lowercase
    324. 

  324.                     version of the input character (add 0x0020 to the character's code
    325. 

  325.                     point), then switch to the tag name state. (Don't emit the token
    326. 

  326.                     yet; further details will be filled in before it is emitted.) */
    327. 

  327.                     $this->token = array(
    328. 

  328.                         'name'  => strtolower($char),
    329. 

  329.                         'type'  => self::STARTTAG,
    330. 

  330.                         'attr'  => array()
    331. 

  331.                     );
    332. 

  332. 

  333.                     $this->state = 'tagName';
    334. 

  334. 

  335.                 } elseif($char === '>') {
    336. 

  336.                     /* U+003E GREATER-THAN SIGN (>)
    337. 

  337.                     Parse error. Emit a U+003C LESS-THAN SIGN character token and a
    338. 

  338.                     U+003E GREATER-THAN SIGN character token. Switch to the data state. */
    339. 

  339.                     $this->emitToken(array(
    340. 

  340.                         'type' => self::CHARACTR,
    341. 

  341.                         'data' => '<>'
    342. 

  342.                     ));
    343. 

  343. 

  344.                     $this->state = 'data';
    345. 

  345. 

  346.                 } elseif($char === '?') {
    347. 

  347.                     /* U+003F QUESTION MARK (?)
    348. 

  348.                     Parse error. Switch to the bogus comment state. */
    349. 

  349.                     $this->state = 'bogusComment';
    350. 

  350. 

  351.                 } else {
    352. 

  352.                     /* Anything else
    353. 

  353.                     Parse error. Emit a U+003C LESS-THAN SIGN character token and
    354. 

  354.                     reconsume the current input character in the data state. */
    355. 

  355.                     $this->emitToken(array(
    356. 

  356.                         'type' => self::CHARACTR,
    357. 

  357.                         'data' => '<'
    358. 

  358.                     ));
    359. 

  359. 

  360.                     $this->char--;
    361. 

  361.                     $this->state = 'data';
    362. 

  362.                 }
    363. 

  363.             break;
    364. 

  364.         }
    365. 

  365.     }
    366. 

  366. 

  367.     private function closeTagOpenState() {
    368. 

  368.         $next_node = strtolower($this->characters('A-Za-z', $this->char + 1));
    369. 

  369.         $the_same = count($this->tree->stack) > 0 && $next_node === end($this->tree->stack)->nodeName;
    370. 

  370. 

  371.         if(($this->content_model === self::RCDATA || $this->content_model === self::CDATA) &&
    372. 

  372.         (!$the_same || ($the_same && (!preg_match('/[\t\n\x0b\x0c >\/]/',
    373. 

  373.         $this->character($this->char + 1 + strlen($next_node))) || $this->EOF === $this->char)))) {
    374. 

  374.             /* If the content model flag is set to the RCDATA or CDATA states then
    375. 

  375.             examine the next few characters. If they do not match the tag name of
    376. 

  376.             the last start tag token emitted (case insensitively), or if they do but
    377. 

  377.             they are not immediately followed by one of the following characters:
    378. 

  378.                 * U+0009 CHARACTER TABULATION
    379. 

  379.                 * U+000A LINE FEED (LF)
    380. 

  380.                 * U+000B LINE TABULATION
    381. 

  381.                 * U+000C FORM FEED (FF)
    382. 

  382.                 * U+0020 SPACE
    383. 

  383.                 * U+003E GREATER-THAN SIGN (>)
    384. 

  384.                 * U+002F SOLIDUS (/)
    385. 

  385.                 * EOF
    386. 

  386.             ...then there is a parse error. Emit a U+003C LESS-THAN SIGN character
    387. 

  387.             token, a U+002F SOLIDUS character token, and switch to the data state
    388. 

  388.             to process the next input character. */
    389. 

  389.             $this->emitToken(array(
    390. 

  390.                 'type' => self::CHARACTR,
    391. 

  391.                 'data' => '</'
    392. 

  392.             ));
    393. 

  393. 

  394.             $this->state = 'data';
    395. 

  395. 

  396.         } else {
    397. 

  397.             /* Otherwise, if the content model flag is set to the PCDATA state,
    398. 

  398.             or if the next few characters do match that tag name, consume the
    399. 

  399.             next input character: */
    400. 

  400.             $this->char++;
    401. 

  401.             $char = $this->char();
    402. 

  402. 

  403.             if(preg_match('/^[A-Za-z]$/', $char)) {
    404. 

  404.                 /* U+0041 LATIN LETTER A through to U+005A LATIN LETTER Z
    405. 

  405.                 Create a new end tag token, set its tag name to the lowercase version
    406. 

  406.                 of the input character (add 0x0020 to the character's code point), then
    407. 

  407.                 switch to the tag name state. (Don't emit the token yet; further details
    408. 

  408.                 will be filled in before it is emitted.) */
    409. 

  409.                 $this->token = array(
    410. 

  410.                     'name'  => strtolower($char),
    411. 

  411.                     'type'  => self::ENDTAG
    412. 

  412.                 );
    413. 

  413. 

  414.                 $this->state = 'tagName';
    415. 

  415. 

  416.             } elseif($char === '>') {
    417. 

  417.                 /* U+003E GREATER-THAN SIGN (>)
    418. 

  418.                 Parse error. Switch to the data state. */
    419. 

  419.                 $this->state = 'data';
    420. 

  420. 

  421.             } elseif($this->char === $this->EOF) {
    422. 

  422.                 /* EOF
    423. 

  423.                 Parse error. Emit a U+003C LESS-THAN SIGN character token and a U+002F
    424. 

  424.                 SOLIDUS character token. Reconsume the EOF character in the data state. */
    425. 

  425.                 $this->emitToken(array(
    426. 

  426.                     'type' => self::CHARACTR,
    427. 

  427.                     'data' => '</'
    428. 

  428.                 ));
    429. 

  429. 

  430.                 $this->char--;
    431. 

  431.                 $this->state = 'data';
    432. 

  432. 

  433.             } else {
    434. 

  434.                 /* Parse error. Switch to the bogus comment state. */
    435. 

  435.                 $this->state = 'bogusComment';
    436. 

  436.             }
    437. 

  437.         }
    438. 

  438.     }
    439. 

  439. 

  440.     private function tagNameState() {
    441. 

  441.         // Consume the next input character:
    442. 

  442.         $this->char++;
    443. 

  443.         $char = $this->character($this->char);
    444. 

  444. 

  445.         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
    446. 

  446.             /* U+0009 CHARACTER TABULATION
    447. 

  447.             U+000A LINE FEED (LF)
    448. 

  448.             U+000B LINE TABULATION
    449. 

  449.             U+000C FORM FEED (FF)
    450. 

  450.             U+0020 SPACE
    451. 

  451.             Switch to the before attribute name state. */
    452. 

  452.             $this->state = 'beforeAttributeName';
    453. 

  453. 

  454.         } elseif($char === '>') {
    455. 

  455.             /* U+003E GREATER-THAN SIGN (>)
    456. 

  456.             Emit the current tag token. Switch to the data state. */
    457. 

  457.             $this->emitToken($this->token);
    458. 

  458.             $this->state = 'data';
    459. 

  459. 

  460.         } elseif($this->char === $this->EOF) {
    461. 

  461.             /* EOF
    462. 

  462.             Parse error. Emit the current tag token. Reconsume the EOF
    463. 

  463.             character in the data state. */
    464. 

  464.             $this->emitToken($this->token);
    465. 

  465. 

  466.             $this->char--;
    467. 

  467.             $this->state = 'data';
    468. 

  468. 

  469.         } elseif($char === '/') {
    470. 

  470.             /* U+002F SOLIDUS (/)
    471. 

  471.             Parse error unless this is a permitted slash. Switch to the before
    472. 

  472.             attribute name state. */
    473. 

  473.             $this->state = 'beforeAttributeName';
    474. 

  474. 

  475.         } else {
    476. 

  476.             /* Anything else
    477. 

  477.             Append the current input character to the current tag token's tag name.
    478. 

  478.             Stay in the tag name state. */
    479. 

  479.             $this->token['name'] .= strtolower($char);
    480. 

  480.             $this->state = 'tagName';
    481. 

  481.         }
    482. 

  482.     }
    483. 

  483. 

  484.     private function beforeAttributeNameState() {
    485. 

  485.         // Consume the next input character:
    486. 

  486.         $this->char++;
    487. 

  487.         $char = $this->character($this->char);
    488. 

  488. 

  489.         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
    490. 

  490.             /* U+0009 CHARACTER TABULATION
    491. 

  491.             U+000A LINE FEED (LF)
    492. 

  492.             U+000B LINE TABULATION
    493. 

  493.             U+000C FORM FEED (FF)
    494. 

  494.             U+0020 SPACE
    495. 

  495.             Stay in the before attribute name state. */
    496. 

  496.             $this->state = 'beforeAttributeName';
    497. 

  497. 

  498.         } elseif($char === '>') {
    499. 

  499.             /* U+003E GREATER-THAN SIGN (>)
    500. 

  500.             Emit the current tag token. Switch to the data state. */
    501. 

  501.             $this->emitToken($this->token);
    502. 

  502.             $this->state = 'data';
    503. 

  503. 

  504.         } elseif($char === '/') {
    505. 

  505.             /* U+002F SOLIDUS (/)
    506. 

  506.             Parse error unless this is a permitted slash. Stay in the before
    507. 

  507.             attribute name state. */
    508. 

  508.             $this->state = 'beforeAttributeName';
    509. 

  509. 

  510.         } elseif($this->char === $this->EOF) {
    511. 

  511.             /* EOF
    512. 

  512.             Parse error. Emit the current tag token. Reconsume the EOF
    513. 

  513.             character in the data state. */
    514. 

  514.             $this->emitToken($this->token);
    515. 

  515. 

  516.             $this->char--;
    517. 

  517.             $this->state = 'data';
    518. 

  518. 

  519.         } else {
    520. 

  520.             /* Anything else
    521. 

  521.             Start a new attribute in the current tag token. Set that attribute's
    522. 

  522.             name to the current input character, and its value to the empty string.
    523. 

  523.             Switch to the attribute name state. */
    524. 

  524.             $this->token['attr'][] = array(
    525. 

  525.                 'name'  => strtolower($char),
    526. 

  526.                 'value' => null
    527. 

  527.             );
    528. 

  528. 

  529.             $this->state = 'attributeName';
    530. 

  530.         }
    531. 

  531.     }
    532. 

  532. 

  533.     private function attributeNameState() {
    534. 

  534.         // Consume the next input character:
    535. 

  535.         $this->char++;
    536. 

  536.         $char = $this->character($this->char);
    537. 

  537. 

  538.         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
    539. 

  539.             /* U+0009 CHARACTER TABULATION
    540. 

  540.             U+000A LINE FEED (LF)
    541. 

  541.             U+000B LINE TABULATION
    542. 

  542.             U+000C FORM FEED (FF)
    543. 

  543.             U+0020 SPACE
    544. 

  544.             Stay in the before attribute name state. */
    545. 

  545.             $this->state = 'afterAttributeName';
    546. 

  546. 

  547.         } elseif($char === '=') {
    548. 

  548.             /* U+003D EQUALS SIGN (=)
    549. 

  549.             Switch to the before attribute value state. */
    550. 

  550.             $this->state = 'beforeAttributeValue';
    551. 

  551. 

  552.         } elseif($char === '>') {
    553. 

  553.             /* U+003E GREATER-THAN SIGN (>)
    554. 

  554.             Emit the current tag token. Switch to the data state. */
    555. 

  555.             $this->emitToken($this->token);
    556. 

  556.             $this->state = 'data';
    557. 

  557. 

  558.         } elseif($char === '/' && $this->character($this->char + 1) !== '>') {
    559. 

  559.             /* U+002F SOLIDUS (/)
    560. 

  560.             Parse error unless this is a permitted slash. Switch to the before
    561. 

  561.             attribute name state. */
    562. 

  562.             $this->state = 'beforeAttributeName';
    563. 

  563. 

  564.         } elseif($this->char === $this->EOF) {
    565. 

  565.             /* EOF
    566. 

  566.             Parse error. Emit the current tag token. Reconsume the EOF
    567. 

  567.             character in the data state. */
    568. 

  568.             $this->emitToken($this->token);
    569. 

  569. 

  570.             $this->char--;
    571. 

  571.             $this->state = 'data';
    572. 

  572. 

  573.         } else {
    574. 

  574.             /* Anything else
    575. 

  575.             Append the current input character to the current attribute's name.
    576. 

  576.             Stay in the attribute name state. */
    577. 

  577.             $last = count($this->token['attr']) - 1;
    578. 

  578.             $this->token['attr'][$last]['name'] .= strtolower($char);
    579. 

  579. 

  580.             $this->state = 'attributeName';
    581. 

  581.         }
    582. 

  582.     }
    583. 

  583. 

  584.     private function afterAttributeNameState() {
    585. 

  585.         // Consume the next input character:
    586. 

  586.         $this->char++;
    587. 

  587.         $char = $this->character($this->char);
    588. 

  588. 

  589.         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
    590. 

  590.             /* U+0009 CHARACTER TABULATION
    591. 

  591.             U+000A LINE FEED (LF)
    592. 

  592.             U+000B LINE TABULATION
    593. 

  593.             U+000C FORM FEED (FF)
    594. 

  594.             U+0020 SPACE
    595. 

  595.             Stay in the after attribute name state. */
    596. 

  596.             $this->state = 'afterAttributeName';
    597. 

  597. 

  598.         } elseif($char === '=') {
    599. 

  599.             /* U+003D EQUALS SIGN (=)
    600. 

  600.             Switch to the before attribute value state. */
    601. 

  601.             $this->state = 'beforeAttributeValue';
    602. 

  602. 

  603.         } elseif($char === '>') {
    604. 

  604.             /* U+003E GREATER-THAN SIGN (>)
    605. 

  605.             Emit the current tag token. Switch to the data state. */
    606. 

  606.             $this->emitToken($this->token);
    607. 

  607.             $this->state = 'data';
    608. 

  608. 

  609.         } elseif($char === '/' && $this->character($this->char + 1) !== '>') {
    610. 

  610.             /* U+002F SOLIDUS (/)
    611. 

  611.             Parse error unless this is a permitted slash. Switch to the
    612. 

  612.             before attribute name state. */
    613. 

  613.             $this->state = 'beforeAttributeName';
    614. 

  614. 

  615.         } elseif($this->char === $this->EOF) {
    616. 

  616.             /* EOF
    617. 

  617.             Parse error. Emit the current tag token. Reconsume the EOF
    618. 

  618.             character in the data state. */
    619. 

  619.             $this->emitToken($this->token);
    620. 

  620. 

  621.             $this->char--;
    622. 

  622.             $this->state = 'data';
    623. 

  623. 

  624.         } else {
    625. 

  625.             /* Anything else
    626. 

  626.             Start a new attribute in the current tag token. Set that attribute's
    627. 

  627.             name to the current input character, and its value to the empty string.
    628. 

  628.             Switch to the attribute name state. */
    629. 

  629.             $this->token['attr'][] = array(
    630. 

  630.                 'name'  => strtolower($char),
    631. 

  631.                 'value' => null
    632. 

  632.             );
    633. 

  633. 

  634.             $this->state = 'attributeName';
    635. 

  635.         }
    636. 

  636.     }
    637. 

  637. 

  638.     private function beforeAttributeValueState() {
    639. 

  639.         // Consume the next input character:
    640. 

  640.         $this->char++;
    641. 

  641.         $char = $this->character($this->char);
    642. 

  642. 

  643.         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
    644. 

  644.             /* U+0009 CHARACTER TABULATION
    645. 

  645.             U+000A LINE FEED (LF)
    646. 

  646.             U+000B LINE TABULATION
    647. 

  647.             U+000C FORM FEED (FF)
    648. 

  648.             U+0020 SPACE
    649. 

  649.             Stay in the before attribute value state. */
    650. 

  650.             $this->state = 'beforeAttributeValue';
    651. 

  651. 

  652.         } elseif($char === '"') {
    653. 

  653.             /* U+0022 QUOTATION MARK (")
    654. 

  654.             Switch to the attribute value (double-quoted) state. */
    655. 

  655.             $this->state = 'attributeValueDoubleQuoted';
    656. 

  656. 

  657.         } elseif($char === '&') {
    658. 

  658.             /* U+0026 AMPERSAND (&)
    659. 

  659.             Switch to the attribute value (unquoted) state and reconsume
    660. 

  660.             this input character. */
    661. 

  661.             $this->char--;
    662. 

  662.             $this->state = 'attributeValueUnquoted';
    663. 

  663. 

  664.         } elseif($char === '\'') {
    665. 

  665.             /* U+0027 APOSTROPHE (')
    666. 

  666.             Switch to the attribute value (single-quoted) state. */
    667. 

  667.             $this->state = 'attributeValueSingleQuoted';
    668. 

  668. 

  669.         } elseif($char === '>') {
    670. 

  670.             /* U+003E GREATER-THAN SIGN (>)
    671. 

  671.             Emit the current tag token. Switch to the data state. */
    672. 

  672.             $this->emitToken($this->token);
    673. 

  673.             $this->state = 'data';
    674. 

  674. 

  675.         } else {
    676. 

  676.             /* Anything else
    677. 

  677.             Append the current input character to the current attribute's value.
    678. 

  678.             Switch to the attribute value (unquoted) state. */
    679. 

  679.             $last = count($this->token['attr']) - 1;
    680. 

  680.             $this->token['attr'][$last]['value'] .= $char;
    681. 

  681. 

  682.             $this->state = 'attributeValueUnquoted';
    683. 

  683.         }
    684. 

  684.     }
    685. 

  685. 

  686.     private function attributeValueDoubleQuotedState() {
    687. 

  687.         // Consume the next input character:
    688. 

  688.         $this->char++;
    689. 

  689.         $char = $this->character($this->char);
    690. 

  690. 

  691.         if($char === '"') {
    692. 

  692.             /* U+0022 QUOTATION MARK (")
    693. 

  693.             Switch to the before attribute name state. */
    694. 

  694.             $this->state = 'beforeAttributeName';
    695. 

  695. 

  696.         } elseif($char === '&') {
    697. 

  697.             /* U+0026 AMPERSAND (&)
    698. 

  698.             Switch to the entity in attribute value state. */
    699. 

  699.             $this->entityInAttributeValueState('double');
    700. 

  700. 

  701.         } elseif($this->char === $this->EOF) {
    702. 

  702.             /* EOF
    703. 

  703.             Parse error. Emit the current tag token. Reconsume the character
    704. 

  704.             in the data state. */
    705. 

  705.             $this->emitToken($this->token);
    706. 

  706. 

  707.             $this->char--;
    708. 

  708.             $this->state = 'data';
    709. 

  709. 

  710.         } else {
    711. 

  711.             /* Anything else
    712. 

  712.             Append the current input character to the current attribute's value.
    713. 

  713.             Stay in the attribute value (double-quoted) state. */
    714. 

  714.             $last = count($this->token['attr']) - 1;
    715. 

  715.             $this->token['attr'][$last]['value'] .= $char;
    716. 

  716. 

  717.             $this->state = 'attributeValueDoubleQuoted';
    718. 

  718.         }
    719. 

  719.     }
    720. 

  720. 

  721.     private function attributeValueSingleQuotedState() {
    722. 

  722.         // Consume the next input character:
    723. 

  723.         $this->char++;
    724. 

  724.         $char = $this->character($this->char);
    725. 

  725. 

  726.         if($char === '\'') {
    727. 

  727.             /* U+0022 QUOTATION MARK (')
    728. 

  728.             Switch to the before attribute name state. */
    729. 

  729.             $this->state = 'beforeAttributeName';
    730. 

  730. 

  731.         } elseif($char === '&') {
    732. 

  732.             /* U+0026 AMPERSAND (&)
    733. 

  733.             Switch to the entity in attribute value state. */
    734. 

  734.             $this->entityInAttributeValueState('single');
    735. 

  735. 

  736.         } elseif($this->char === $this->EOF) {
    737. 

  737.             /* EOF
    738. 

  738.             Parse error. Emit the current tag token. Reconsume the character
    739. 

  739.             in the data state. */
    740. 

  740.             $this->emitToken($this->token);
    741. 

  741. 

  742.             $this->char--;
    743. 

  743.             $this->state = 'data';
    744. 

  744. 

  745.         } else {
    746. 

  746.             /* Anything else
    747. 

  747.             Append the current input character to the current attribute's value.
    748. 

  748.             Stay in the attribute value (single-quoted) state. */
    749. 

  749.             $last = count($this->token['attr']) - 1;
    750. 

  750.             $this->token['attr'][$last]['value'] .= $char;
    751. 

  751. 

  752.             $this->state = 'attributeValueSingleQuoted';
    753. 

  753.         }
    754. 

  754.     }
    755. 

  755. 

  756.     private function attributeValueUnquotedState() {
    757. 

  757.         // Consume the next input character:
    758. 

  758.         $this->char++;
    759. 

  759.         $char = $this->character($this->char);
    760. 

  760. 

  761.         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
    762. 

  762.             /* U+0009 CHARACTER TABULATION
    763. 

  763.             U+000A LINE FEED (LF)
    764. 

  764.             U+000B LINE TABULATION
    765. 

  765.             U+000C FORM FEED (FF)
    766. 

  766.             U+0020 SPACE
    767. 

  767.             Switch to the before attribute name state. */
    768. 

  768.             $this->state = 'beforeAttributeName';
    769. 

  769. 

  770.         } elseif($char === '&') {
    771. 

  771.             /* U+0026 AMPERSAND (&)
    772. 

  772.             Switch to the entity in attribute value state. */
    773. 

  773.             $this->entityInAttributeValueState();
    774. 

  774. 

  775.         } elseif($char === '>') {
    776. 

  776.             /* U+003E GREATER-THAN SIGN (>)
    777. 

  777.             Emit the current tag token. Switch to the data state. */
    778. 

  778.             $this->emitToken($this->token);
    779. 

  779.             $this->state = 'data';
    780. 

  780. 

  781.         } else {
    782. 

  782.             /* Anything else
    783. 

  783.             Append the current input character to the current attribute's value.
    784. 

  784.             Stay in the attribute value (unquoted) state. */
    785. 

  785.             $last = count($this->token['attr']) - 1;
    786. 

  786.             $this->token['attr'][$last]['value'] .= $char;
    787. 

  787. 

  788.             $this->state = 'attributeValueUnquoted';
    789. 

  789.         }
    790. 

  790.     }
    791. 

  791. 

  792.     private function entityInAttributeValueState() {
    793. 

  793.         // Attempt to consume an entity.
    794. 

  794.         $entity = $this->entity();
    795. 

  795. 

  796.         // If nothing is returned, append a U+0026 AMPERSAND character to the
    797. 

  797.         // current attribute's value. Otherwise, emit the character token that
    798. 

  798.         // was returned.
    799. 

  799.         $char = (!$entity)
    800. 

  800.             ? '&'
    801. 

  801.             : $entity;
    802. 

  802. 

  803.         $last = count($this->token['attr']) - 1;
    804. 

  804.         $this->token['attr'][$last]['value'] .= $char;
    805. 

  805.     }
    806. 

  806. 

  807.     private function bogusCommentState() {
    808. 

  808.         /* Consume every character up to the first U+003E GREATER-THAN SIGN
    809. 

  809.         character (>) or the end of the file (EOF), whichever comes first. Emit
    810. 

  810.         a comment token whose data is the concatenation of all the characters
    811. 

  811.         starting from and including the character that caused the state machine
    812. 

  812.         to switch into the bogus comment state, up to and including the last
    813. 

  813.         consumed character before the U+003E character, if any, or up to the
    814. 

  814.         end of the file otherwise. (If the comment was started by the end of
    815. 

  815.         the file (EOF), the token is empty.) */
    816. 

  816.         $data = $this->characters('^>', $this->char);
    817. 

  817.         $this->emitToken(array(
    818. 

  818.             'data' => $data,
    819. 

  819.             'type' => self::COMMENT
    820. 

  820.         ));
    821. 

  821. 

  822.         $this->char += strlen($data);
    823. 

  823. 

  824.         /* Switch to the data state. */
    825. 

  825.         $this->state = 'data';
    826. 

  826. 

  827.         /* If the end of the file was reached, reconsume the EOF character. */
    828. 

  828.         if($this->char === $this->EOF) {
    829. 

  829.             $this->char = $this->EOF - 1;
    830. 

  830.         }
    831. 

  831.     }
    832. 

  832. 

  833.     private function markupDeclarationOpenState() {
    834. 

  834.         /* If the next two characters are both U+002D HYPHEN-MINUS (-)
    835. 

  835.         characters, consume those two characters, create a comment token whose
    836. 

  836.         data is the empty string, and switch to the comment state. */
    837. 

  837.         if($this->character($this->char + 1, 2) === '--') {
    838. 

  838.             $this->char += 2;
    839. 

  839.             $this->state = 'comment';
    840. 

  840.             $this->token = array(
    841. 

  841.                 'data' => null,
    842. 

  842.                 'type' => self::COMMENT
    843. 

  843.             );
    844. 

  844. 

  845.         /* Otherwise if the next seven chacacters are a case-insensitive match
    846. 

  846.         for the word "DOCTYPE", then consume those characters and switch to the
    847. 

  847.         DOCTYPE state. */
    848. 

  848.         } elseif(strtolower($this->character($this->char + 1, 7)) === 'doctype') {
    849. 

  849.             $this->char += 7;
    850. 

  850.             $this->state = 'doctype';
    851. 

  851. 

  852.         /* Otherwise, is is a parse error. Switch to the bogus comment state.
    853. 

  853.         The next character that is consumed, if any, is the first character
    854. 

  854.         that will be in the comment. */
    855. 

  855.         } else {
    856. 

  856.             $this->char++;
    857. 

  857.             $this->state = 'bogusComment';
    858. 

  858.         }
    859. 

  859.     }
    860. 

  860. 

  861.     private function commentState() {
    862. 

  862.         /* Consume the next input character: */
    863. 

  863.         $this->char++;
    864. 

  864.         $char = $this->char();
    865. 

  865. 

  866.         /* U+002D HYPHEN-MINUS (-) */
    867. 

  867.         if($char === '-') {
    868. 

  868.             /* Switch to the comment dash state  */
    869. 

  869.             $this->state = 'commentDash';
    870. 

  870. 

  871.         /* EOF */
    872. 

  872.         } elseif($this->char === $this->EOF) {
    873. 

  873.             /* Parse error. Emit the comment token. Reconsume the EOF character
    874. 

  874.             in the data state. */
    875. 

  875.             $this->emitToken($this->token);
    876. 

  876.             $this->char--;
    877. 

  877.             $this->state = 'data';
    878. 

  878. 

  879.         /* Anything else */
    880. 

  880.         } else {
    881. 

  881.             /* Append the input character to the comment token's data. Stay in
    882. 

  882.             the comment state. */
    883. 

  883.             $this->token['data'] .= $char;
    884. 

  884.         }
    885. 

  885.     }
    886. 

  886. 

  887.     private function commentDashState() {
    888. 

  888.         /* Consume the next input character: */
    889. 

  889.         $this->char++;
    890. 

  890.         $char = $this->char();
    891. 

  891. 

  892.         /* U+002D HYPHEN-MINUS (-) */
    893. 

  893.         if($char === '-') {
    894. 

  894.             /* Switch to the comment end state  */
    895. 

  895.             $this->state = 'commentEnd';
    896. 

  896. 

  897.         /* EOF */
    898. 

  898.         } elseif($this->char === $this->EOF) {
    899. 

  899.             /* Parse error. Emit the comment token. Reconsume the EOF character
    900. 

  900.             in the data state. */
    901. 

  901.             $this->emitToken($this->token);
    902. 

  902.             $this->char--;
    903. 

  903.             $this->state = 'data';
    904. 

  904. 

  905.         /* Anything else */
    906. 

  906.         } else {
    907. 

  907.             /* Append a U+002D HYPHEN-MINUS (-) character and the input
    908. 

  908.             character to the comment token's data. Switch to the comment state. */
    909. 

  909.             $this->token['data'] .= '-'.$char;
    910. 

  910.             $this->state = 'comment';
    911. 

  911.         }
    912. 

  912.     }
    913. 

  913. 

  914.     private function commentEndState() {
    915. 

  915.         /* Consume the next input character: */
    916. 

  916.         $this->char++;
    917. 

  917.         $char = $this->char();
    918. 

  918. 

  919.         if($char === '>') {
    920. 

  920.             $this->emitToken($this->token);
    921. 

  921.             $this->state = 'data';
    922. 

  922. 

  923.         } elseif($char === '-') {
    924. 

  924.             $this->token['data'] .= '-';
    925. 

  925. 

  926.         } elseif($this->char === $this->EOF) {
    927. 

  927.             $this->emitToken($this->token);
    928. 

  928.             $this->char--;
    929. 

  929.             $this->state = 'data';
    930. 

  930. 

  931.         } else {
    932. 

  932.             $this->token['data'] .= '--'.$char;
    933. 

  933.             $this->state = 'comment';
    934. 

  934.         }
    935. 

  935.     }
    936. 

  936. 

  937.     private function doctypeState() {
    938. 

  938.         /* Consume the next input character: */
    939. 

  939.         $this->char++;
    940. 

  940.         $char = $this->char();
    941. 

  941. 

  942.         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
    943. 

  943.             $this->state = 'beforeDoctypeName';
    944. 

  944. 

  945.         } else {
    946. 

  946.             $this->char--;
    947. 

  947.             $this->state = 'beforeDoctypeName';
    948. 

  948.         }
    949. 

  949.     }
    950. 

  950. 

  951.     private function beforeDoctypeNameState() {
    952. 

  952.         /* Consume the next input character: */
    953. 

  953.         $this->char++;
    954. 

  954.         $char = $this->char();
    955. 

  955. 

  956.         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
    957. 

  957.             // Stay in the before DOCTYPE name state.
    958. 

  958. 

  959.         } elseif(preg_match('/^[a-z]$/', $char)) {
    960. 

  960.             $this->token = array(
    961. 

  961.                 'name' => strtoupper($char),
    962. 

  962.                 'type' => self::DOCTYPE,
    963. 

  963.                 'error' => true
    964. 

  964.             );
    965. 

  965. 

  966.             $this->state = 'doctypeName';
    967. 

  967. 

  968.         } elseif($char === '>') {
    969. 

  969.             $this->emitToken(array(
    970. 

  970.                 'name' => null,
    971. 

  971.                 'type' => self::DOCTYPE,
    972. 

  972.                 'error' => true
    973. 

  973.             ));
    974. 

  974. 

  975.             $this->state = 'data';
    976. 

  976. 

  977.         } elseif($this->char === $this->EOF) {
    978. 

  978.             $this->emitToken(array(
    979. 

  979.                 'name' => null,
    980. 

  980.                 'type' => self::DOCTYPE,
    981. 

  981.                 'error' => true
    982. 

  982.             ));
    983. 

  983. 

  984.             $this->char--;
    985. 

  985.             $this->state = 'data';
    986. 

  986. 

  987.         } else {
    988. 

  988.             $this->token = array(
    989. 

  989.                 'name' => $char,
    990. 

  990.                 'type' => self::DOCTYPE,
    991. 

  991.                 'error' => true
    992. 

  992.             );
    993. 

  993. 

  994.             $this->state = 'doctypeName';
    995. 

  995.         }
    996. 

  996.     }
    997. 

  997. 

  998.     private function doctypeNameState() {
    999. 

  999.         /* Consume the next input character: */
    1000. 

  1000.         $this->char++;
    1001. 

  1001.         $char = $this->char();
    1002. 

  1002. 

  1003.         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
    1004. 

  1004.             $this->state = 'AfterDoctypeName';
    1005. 

  1005. 

  1006.         } elseif($char === '>') {
    1007. 

  1007.             $this->emitToken($this->token);
    1008. 

  1008.             $this->state = 'data';
    1009. 

  1009. 

  1010.         } elseif(preg_match('/^[a-z]$/', $char)) {
    1011. 

  1011.             $this->token['name'] .= strtoupper($char);
    1012. 

  1012. 

  1013.         } elseif($this->char === $this->EOF) {
    1014. 

  1014.             $this->emitToken($this->token);
    1015. 

  1015.             $this->char--;
    1016. 

  1016.             $this->state = 'data';
    1017. 

  1017. 

  1018.         } else {
    1019. 

  1019.             $this->token['name'] .= $char;
    1020. 

  1020.         }
    1021. 

  1021. 

  1022.         $this->token['error'] = ($this->token['name'] === 'HTML')
    1023. 

  1023.             ? false
    1024. 

  1024.             : true;
    1025. 

  1025.     }
    1026. 

  1026. 

  1027.     private function afterDoctypeNameState() {
    1028. 

  1028.         /* Consume the next input character: */
    1029. 

  1029.         $this->char++;
    1030. 

  1030.         $char = $this->char();
    1031. 

  1031. 

  1032.         if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
    1033. 

  1033.             // Stay in the DOCTYPE name state.
    1034. 

  1034. 

  1035.         } elseif($char === '>') {
    1036. 

  1036.             $this->emitToken($this->token);
    1037. 

  1037.             $this->state = 'data';
    1038. 

  1038. 

  1039.         } elseif($this->char === $this->EOF) {
    1040. 

  1040.             $this->emitToken($this->token);
    1041. 

  1041.             $this->char--;
    1042. 

  1042.             $this->state = 'data';
    1043. 

  1043. 

  1044.         } else {
    1045. 

  1045.             $this->token['error'] = true;
    1046. 

  1046.             $this->state = 'bogusDoctype';
    1047. 

  1047.         }
    1048. 

  1048.     }
    1049. 

  1049. 

  1050.     private function bogusDoctypeState() {
    1051. 

  1051.         /* Consume the next input character: */
    1052. 

  1052.         $this->char++;
    1053. 

  1053.         $char = $this->char();
    1054. 

  1054. 

  1055.         if($char === '>') {
    1056. 

  1056.             $this->emitToken($this->token);
    1057. 

  1057.             $this->state = 'data';
    1058. 

  1058. 

  1059.         } elseif($this->char === $this->EOF) {
    1060. 

  1060.             $this->emitToken($this->token);
    1061. 

  1061.             $this->char--;
    1062. 

  1062.             $this->state = 'data';
    1063. 

  1063. 

  1064.         } else {
    1065. 

  1065.             // Stay in the bogus DOCTYPE state.
    1066. 

  1066.         }
    1067. 

  1067.     }
    1068. 

  1068. 

  1069.     private function entity() {
    1070. 

  1070.         $start = $this->char;
    1071. 

  1071. 

  1072.         // This section defines how to consume an entity. This definition is
    1073. 

  1073.         // used when parsing entities in text and in attributes.
    1074. 

  1074. 

  1075.         // The behaviour depends on the identity of the next character (the
    1076. 

  1076.         // one immediately after the U+0026 AMPERSAND character): 
    1077. 

  1077. 

  1078.         switch($this->character($this->char + 1)) {
    1079. 

  1079.             // U+0023 NUMBER SIGN (#)
    1080. 

  1080.             case '#':
    1081. 

  1081. 

  1082.                 // The behaviour further depends on the character after the
    1083. 

  1083.                 // U+0023 NUMBER SIGN:
    1084. 

  1084.                 switch($this->character($this->char + 1)) {
    1085. 

  1085.                     // U+0078 LATIN SMALL LETTER X
    1086. 

  1086.                     // U+0058 LATIN CAPITAL LETTER X
    1087. 

  1087.                     case 'x':
    1088. 

  1088.                     case 'X':
    1089. 

  1089.                         // Follow the steps below, but using the range of
    1090. 

  1090.                         // characters U+0030 DIGIT ZERO through to U+0039 DIGIT
    1091. 

  1091.                         // NINE, U+0061 LATIN SMALL LETTER A through to U+0066
    1092. 

  1092.                         // LATIN SMALL LETTER F, and U+0041 LATIN CAPITAL LETTER
    1093. 

  1093.                         // A, through to U+0046 LATIN CAPITAL LETTER F (in other
    1094. 

  1094.                         // words, 0-9, A-F, a-f).
    1095. 

  1095.                         $char = 1;
    1096. 

  1096.                         $char_class = '0-9A-Fa-f';
    1097. 

  1097.                     break;
    1098. 

  1098. 

  1099.                     // Anything else
    1100. 

  1100.                     default:
    1101. 

  1101.                         // Follow the steps below, but using the range of
    1102. 

  1102.                         // characters U+0030 DIGIT ZERO through to U+0039 DIGIT
    1103. 

  1103.                         // NINE (i.e. just 0-9).
    1104. 

  1104.                         $char = 0;
    1105. 

  1105.                         $char_class = '0-9';
    1106. 

  1106.                     break;
    1107. 

  1107.                 }
    1108. 

  1108. 

  1109.                 // Consume as many characters as match the range of characters
    1110. 

  1110.                 // given above.
    1111. 

  1111.                 $this->char++;
    1112. 

  1112.                 $e_name = $this->characters($char_class, $this->char + $char + 1);
    1113. 

  1113.                 $entity = $this->character($start, $this->char);
    1114. 

  1114.                 $cond = strlen($e_name) > 0;
    1115. 

  1115. 

  1116.                 // The rest of the parsing happens bellow.
    1117. 

  1117.             break;
    1118. 

  1118. 

  1119.             // Anything else
    1120. 

  1120.             default:
    1121. 

  1121.                 // Consume the maximum number of characters possible, with the
    1122. 

  1122.                 // consumed characters case-sensitively matching one of the
    1123. 

  1123.                 // identifiers in the first column of the entities table.
    1124. 

  1124.                 $e_name = $this->characters('0-9A-Za-z;', $this->char + 1);
    1125. 

  1125.                 $len = strlen($e_name);
    1126. 

  1126. 

  1127.                 for($c = 1; $c <= $len; $c++) {
    1128. 

  1128.                     $id = substr($e_name, 0, $c);
    1129. 

  1129.                     $this->char++;
    1130. 

  1130. 

  1131.                     if(in_array($id, $this->entities)) {
    1132. 

  1132.                         if ($e_name[$c-1] !== ';') {
    1133. 

  1133.                             if ($c < $len && $e_name[$c] == ';') {
    1134. 

  1134.                                 $this->char++; // consume extra semicolon
    1135. 

  1135.                             }
    1136. 

  1136.                         }
    1137. 

  1137.                         $entity = $id;
    1138. 

  1138.                         break;
    1139. 

  1139.                     }
    1140. 

  1140.                 }
    1141. 

  1141. 

  1142.                 $cond = isset($entity);
    1143. 

  1143.                 // The rest of the parsing happens bellow.
    1144. 

  1144.             break;
    1145. 

  1145.         }
    1146. 

  1146. 

  1147.         if(!$cond) {
    1148. 

  1148.             // If no match can be made, then this is a parse error. No
    1149. 

  1149.             // characters are consumed, and nothing is returned.
    1150. 

  1150.             $this->char = $start;
    1151. 

  1151.             return false;
    1152. 

  1152.         }
    1153. 

  1153. 

  1154.         // Return a character token for the character corresponding to the
    1155. 

  1155.         // entity name (as given by the second column of the entities table).
    1156. 

  1156.         return html_entity_decode('&'.$entity.';', ENT_QUOTES, 'UTF-8');
    1157. 

  1157.     }
    1158. 

  1158. 

  1159.     private function emitToken($token) {
    1160. 

  1160.         $emit = $this->tree->emitToken($token);
    1161. 

  1161. 

  1162.         if(is_int($emit)) {
    1163. 

  1163.             $this->content_model = $emit;
    1164. 

  1164. 

  1165.         } elseif($token['type'] === self::ENDTAG) {
    1166. 

  1166.             $this->content_model = self::PCDATA;
    1167. 

  1167.         }
    1168. 

  1168.     }
    1169. 

  1169. 

  1170.     private function EOF() {
    1171. 

  1171.         $this->state = null;
    1172. 

  1172.         $this->tree->emitToken(array(
    1173. 

  1173.             'type' => self::EOF
    1174. 

  1174.         ));
    1175. 

  1175.     }
    1176. 

  1176. }
    1177. 

  1177. 

  1178. class HTML5TreeConstructer {
    1179. 

  1179.     public $stack = array();
    1180. 

  1180. 

  1181.     private $phase;
    1182. 

  1182.     private $mode;
    1183. 

  1183.     private $dom;
    1184. 

  1184.     private $foster_parent = null;
    1185. 

  1185.     private $a_formatting  = array();
    1186. 

  1186. 

  1187.     private $head_pointer = null;
    1188. 

  1188.     private $form_pointer = null;
    1189. 

  1189. 

  1190.     private $scoping = array('button','caption','html','marquee','object','table','td','th');
    1191. 

  1191.     private $formatting = array('a','b','big','em','font','i','nobr','s','small','strike','strong','tt','u');
    1192. 

  1192.     private $special = array('address','area','base','basefont','bgsound',
    1193. 

  1193.     'blockquote','body','br','center','col','colgroup','dd','dir','div','dl',
    1194. 

  1194.     'dt','embed','fieldset','form','frame','frameset','h1','h2','h3','h4','h5',
    1195. 

  1195.     'h6','head','hr','iframe','image','img','input','isindex','li','link',
    1196. 

  1196.     'listing','menu','meta','noembed','noframes','noscript','ol','optgroup',
    1197. 

  1197.     'option','p','param','plaintext','pre','script','select','spacer','style',
    1198. 

  1198.     'tbody','textarea','tfoot','thead','title','tr','ul','wbr');
    1199. 

  1199. 

  1200.     // The different phases.
    1201. 

  1201.     const INIT_PHASE = 0;
    1202. 

  1202.     const ROOT_PHASE = 1;
    1203. 

  1203.     const MAIN_PHASE = 2;
    1204. 

  1204.     const END_PHASE  = 3;
    1205. 

  1205. 

  1206.     // The different insertion modes for the main phase.
    1207. 

  1207.     const BEFOR_HEAD = 0;
    1208. 

  1208.     const IN_HEAD    = 1;
    1209. 

  1209.     const AFTER_HEAD = 2;
    1210. 

  1210.     const IN_BODY    = 3;
    1211. 

  1211.     const IN_TABLE   = 4;
    1212. 

  1212.     const IN_CAPTION = 5;
    1213. 

  1213.     const IN_CGROUP  = 6;
    1214. 

  1214.     const IN_TBODY   = 7;
    1215. 

  1215.     const IN_ROW     = 8;
    1216. 

  1216.     const IN_CELL    = 9;
    1217. 

  1217.     const IN_SELECT  = 10;
    1218. 

  1218.     const AFTER_BODY = 11;
    1219. 

  1219.     const IN_FRAME   = 12;
    1220. 

  1220.     const AFTR_FRAME = 13;
    1221. 

  1221. 

  1222.     // The different types of elements.
    1223. 

  1223.     const SPECIAL    = 0;
    1224. 

  1224.     const SCOPING    = 1;
    1225. 

  1225.     const FORMATTING = 2;
    1226. 

  1226.     const PHRASING   = 3;
    1227. 

  1227. 

  1228.     const MARKER     = 0;
    1229. 

  1229. 

  1230.     public function __construct() {
    1231. 

  1231.         $this->phase = self::INIT_PHASE;
    1232. 

  1232.         $this->mode = self::BEFOR_HEAD;
    1233. 

  1233.         $this->dom = new DOMDocument;
    1234. 

  1234. 

  1235.         $this->dom->encoding = 'UTF-8';
    1236. 

  1236.         $this->dom->preserveWhiteSpace = true;
    1237. 

  1237.         $this->dom->substituteEntities = true;
    1238. 

  1238.         $this->dom->strictErrorChecking = false;
    1239. 

  1239.     }
    1240. 

  1240. 

  1241.     // Process tag tokens
    1242. 

  1242.     public function emitToken($token) {
    1243. 

  1243.         switch($this->phase) {
    1244. 

  1244.             case self::INIT_PHASE: return $this->initPhase($token); break;
    1245. 

  1245.             case self::ROOT_PHASE: return $this->rootElementPhase($token); break;
    1246. 

  1246.             case self::MAIN_PHASE: return $this->mainPhase($token); break;
    1247. 

  1247.             case self::END_PHASE : return $this->trailingEndPhase($token); break;
    1248. 

  1248.         }
    1249. 

  1249.     }
    1250. 

  1250. 

  1251.     private function initPhase($token) {
    1252. 

  1252.         /* Initially, the tree construction stage must handle each token
    1253. 

  1253.         emitted from the tokenisation stage as follows: */
    1254. 

  1254. 

  1255.         /* A DOCTYPE token that is marked as being in error
    1256. 

  1256.         A comment token
    1257. 

  1257.         A start tag token
    1258. 

  1258.         An end tag token
    1259. 

  1259.         A character token that is not one of one of U+0009 CHARACTER TABULATION,
    1260. 

  1260.             U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
    1261. 

  1261.             or U+0020 SPACE
    1262. 

  1262.         An end-of-file token */
    1263. 

  1263.         if((isset($token['error']) && $token['error']) ||
    1264. 

  1264.         $token['type'] === HTML5::COMMENT ||
    1265. 

  1265.         $token['type'] === HTML5::STARTTAG ||
    1266. 

  1266.         $token['type'] === HTML5::ENDTAG ||
    1267. 

  1267.         $token['type'] === HTML5::EOF ||
    1268. 

  1268.         ($token['type'] === HTML5::CHARACTR && isset($token['data']) &&
    1269. 

  1269.         !preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data']))) {
    1270. 

  1270.             /* This specification does not define how to handle this case. In
    1271. 

  1271.             particular, user agents may ignore the entirety of this specification
    1272. 

  1272.             altogether for such documents, and instead invoke special parse modes
    1273. 

  1273.             with a greater emphasis on backwards compatibility. */
    1274. 

  1274. 

  1275.             $this->phase = self::ROOT_PHASE;
    1276. 

  1276.             return $this->rootElementPhase($token);
    1277. 

  1277. 

  1278.         /* A DOCTYPE token marked as being correct */
    1279. 

  1279.         } elseif(isset($token['error']) && !$token['error']) {
    1280. 

  1280.             /* Append a DocumentType node to the Document  node, with the name
    1281. 

  1281.             attribute set to the name given in the DOCTYPE token (which will be
    1282. 

  1282.             "HTML"), and the other attributes specific to DocumentType objects
    1283. 

  1283.             set to null, empty lists, or the empty string as appropriate. */
    1284. 

  1284.             $doctype = new DOMDocumentType(null, null, 'HTML');
    1285. 

  1285. 

  1286.             /* Then, switch to the root element phase of the tree construction
    1287. 

  1287.             stage. */
    1288. 

  1288.             $this->phase = self::ROOT_PHASE;
    1289. 

  1289. 

  1290.         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
    1291. 

  1291.         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
    1292. 

  1292.         or U+0020 SPACE */
    1293. 

  1293.         } elseif(isset($token['data']) && preg_match('/^[\t\n\x0b\x0c ]+$/',
    1294. 

  1294.         $token['data'])) {
    1295. 

  1295.             /* Append that character  to the Document node. */
    1296. 

  1296.             $text = $this->dom->createTextNode($token['data']);
    1297. 

  1297.             $this->dom->appendChild($text);
    1298. 

  1298.         }
    1299. 

  1299.     }
    1300. 

  1300. 

  1301.     private function rootElementPhase($token) {
    1302. 

  1302.         /* After the initial phase, as each token is emitted from the tokenisation
    1303. 

  1303.         stage, it must be processed as described in this section. */
    1304. 

  1304. 

  1305.         /* A DOCTYPE token */
    1306. 

  1306.         if($token['type'] === HTML5::DOCTYPE) {
    1307. 

  1307.             // Parse error. Ignore the token.
    1308. 

  1308. 

  1309.         /* A comment token */
    1310. 

  1310.         } elseif($token['type'] === HTML5::COMMENT) {
    1311. 

  1311.             /* Append a Comment node to the Document object with the data
    1312. 

  1312.             attribute set to the data given in the comment token. */
    1313. 

  1313.             $comment = $this->dom->createComment($token['data']);
    1314. 

  1314.             $this->dom->appendChild($comment);
    1315. 

  1315. 

  1316.         /* A character token that is one of one of U+0009 CHARACTER TABULATION,
    1317. 

  1317.         U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
    1318. 

  1318.         or U+0020 SPACE */
    1319. 

  1319.         } elseif($token['type'] === HTML5::CHARACTR &&
    1320. 

  1320.         preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
    1321. 

  1321.             /* Append that character  to the Document node. */
    1322. 

  1322.             $text = $this->dom->createTextNode($token['data…
    1323.

Large files files are truncated, but you can click here to view the full file