Context Navigation

PH5P.php @ 21

Revision 21, 165.0 kB (checked in by admin, 18 years ago)

Line
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	'type' => self::CHARACTR,
429	'data' => '</'
430	));
431
432	$this->char--;
433	$this->state = 'data';
434
435	} else {
436	/* Parse error. Switch to the bogus comment state. */
437	$this->state = 'bogusComment';
438	}
439	}
440	}
441
442	private function tagNameState() {
443	// Consume the next input character:
444	$this->char++;
445	$char = $this->character($this->char);
446
447	if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
448	/* U+0009 CHARACTER TABULATION
449	U+000A LINE FEED (LF)
450	U+000B LINE TABULATION
451	U+000C FORM FEED (FF)
452	U+0020 SPACE
453	Switch to the before attribute name state. */
454	$this->state = 'beforeAttributeName';
455
456	} elseif($char === '>') {
457	/* U+003E GREATER-THAN SIGN (>)
458	Emit the current tag token. Switch to the data state. */
459	$this->emitToken($this->token);
460	$this->state = 'data';
461
462	} elseif($this->char === $this->EOF) {
463	/* EOF
464	Parse error. Emit the current tag token. Reconsume the EOF
465	character in the data state. */
466	$this->emitToken($this->token);
467
468	$this->char--;
469	$this->state = 'data';
470
471	} elseif($char === '/') {
472	/* U+002F SOLIDUS (/)
473	Parse error unless this is a permitted slash. Switch to the before
474	attribute name state. */
475	$this->state = 'beforeAttributeName';
476
477	} else {
478	/* Anything else
479	Append the current input character to the current tag token's tag name.
480	Stay in the tag name state. */
481	$this->token['name'] .= strtolower($char);
482	$this->state = 'tagName';
483	}
484	}
485
486	private function beforeAttributeNameState() {
487	// Consume the next input character:
488	$this->char++;
489	$char = $this->character($this->char);
490
491	if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
492	/* U+0009 CHARACTER TABULATION
493	U+000A LINE FEED (LF)
494	U+000B LINE TABULATION
495	U+000C FORM FEED (FF)
496	U+0020 SPACE
497	Stay in the before attribute name state. */
498	$this->state = 'beforeAttributeName';
499
500	} elseif($char === '>') {
501	/* U+003E GREATER-THAN SIGN (>)
502	Emit the current tag token. Switch to the data state. */
503	$this->emitToken($this->token);
504	$this->state = 'data';
505
506	} elseif($char === '/') {
507	/* U+002F SOLIDUS (/)
508	Parse error unless this is a permitted slash. Stay in the before
509	attribute name state. */
510	$this->state = 'beforeAttributeName';
511
512	} elseif($this->char === $this->EOF) {
513	/* EOF
514	Parse error. Emit the current tag token. Reconsume the EOF
515	character in the data state. */
516	$this->emitToken($this->token);
517
518	$this->char--;
519	$this->state = 'data';
520
521	} else {
522	/* Anything else
523	Start a new attribute in the current tag token. Set that attribute's
524	name to the current input character, and its value to the empty string.
525	Switch to the attribute name state. */
526	$this->token['attr'][] = array(
527	'name' => strtolower($char),
528	'value' => null
529	);
530
531	$this->state = 'attributeName';
532	}
533	}
534
535	private function attributeNameState() {
536	// Consume the next input character:
537	$this->char++;
538	$char = $this->character($this->char);
539
540	if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
541	/* U+0009 CHARACTER TABULATION
542	U+000A LINE FEED (LF)
543	U+000B LINE TABULATION
544	U+000C FORM FEED (FF)
545	U+0020 SPACE
546	Stay in the before attribute name state. */
547	$this->state = 'afterAttributeName';
548
549	} elseif($char === '=') {
550	/* U+003D EQUALS SIGN (=)
551	Switch to the before attribute value state. */
552	$this->state = 'beforeAttributeValue';
553
554	} elseif($char === '>') {
555	/* U+003E GREATER-THAN SIGN (>)
556	Emit the current tag token. Switch to the data state. */
557	$this->emitToken($this->token);
558	$this->state = 'data';
559
560	} elseif($char === '/' && $this->character($this->char + 1) !== '>') {
561	/* U+002F SOLIDUS (/)
562	Parse error unless this is a permitted slash. Switch to the before
563	attribute name state. */
564	$this->state = 'beforeAttributeName';
565
566	} elseif($this->char === $this->EOF) {
567	/* EOF
568	Parse error. Emit the current tag token. Reconsume the EOF
569	character in the data state. */
570	$this->emitToken($this->token);
571
572	$this->char--;
573	$this->state = 'data';
574
575	} else {
576	/* Anything else
577	Append the current input character to the current attribute's name.
578	Stay in the attribute name state. */
579	$last = count($this->token['attr']) - 1;
580	$this->token['attr'][$last]['name'] .= strtolower($char);
581
582	$this->state = 'attributeName';
583	}
584	}
585
586	private function afterAttributeNameState() {
587	// Consume the next input character:
588	$this->char++;
589	$char = $this->character($this->char);
590
591	if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
592	/* U+0009 CHARACTER TABULATION
593	U+000A LINE FEED (LF)
594	U+000B LINE TABULATION
595	U+000C FORM FEED (FF)
596	U+0020 SPACE
597	Stay in the after attribute name state. */
598	$this->state = 'afterAttributeName';
599
600	} elseif($char === '=') {
601	/* U+003D EQUALS SIGN (=)
602	Switch to the before attribute value state. */
603	$this->state = 'beforeAttributeValue';
604
605	} elseif($char === '>') {
606	/* U+003E GREATER-THAN SIGN (>)
607	Emit the current tag token. Switch to the data state. */
608	$this->emitToken($this->token);
609	$this->state = 'data';
610
611	} elseif($char === '/' && $this->character($this->char + 1) !== '>') {
612	/* U+002F SOLIDUS (/)
613	Parse error unless this is a permitted slash. Switch to the
614	before attribute name state. */
615	$this->state = 'beforeAttributeName';
616
617	} elseif($this->char === $this->EOF) {
618	/* EOF
619	Parse error. Emit the current tag token. Reconsume the EOF
620	character in the data state. */
621	$this->emitToken($this->token);
622
623	$this->char--;
624	$this->state = 'data';
625
626	} else {
627	/* Anything else
628	Start a new attribute in the current tag token. Set that attribute's
629	name to the current input character, and its value to the empty string.
630	Switch to the attribute name state. */
631	$this->token['attr'][] = array(
632	'name' => strtolower($char),
633	'value' => null
634	);
635
636	$this->state = 'attributeName';
637	}
638	}
639
640	private function beforeAttributeValueState() {
641	// Consume the next input character:
642	$this->char++;
643	$char = $this->character($this->char);
644
645	if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
646	/* U+0009 CHARACTER TABULATION
647	U+000A LINE FEED (LF)
648	U+000B LINE TABULATION
649	U+000C FORM FEED (FF)
650	U+0020 SPACE
651	Stay in the before attribute value state. */
652	$this->state = 'beforeAttributeValue';
653
654	} elseif($char === '"') {
655	/* U+0022 QUOTATION MARK (")
656	Switch to the attribute value (double-quoted) state. */
657	$this->state = 'attributeValueDoubleQuoted';
658
659	} elseif($char === '&') {
660	/* U+0026 AMPERSAND (&)
661	Switch to the attribute value (unquoted) state and reconsume
662	this input character. */
663	$this->char--;
664	$this->state = 'attributeValueUnquoted';
665
666	} elseif($char === '\'') {
667	/* U+0027 APOSTROPHE (')
668	Switch to the attribute value (single-quoted) state. */
669	$this->state = 'attributeValueSingleQuoted';
670
671	} elseif($char === '>') {
672	/* U+003E GREATER-THAN SIGN (>)
673	Emit the current tag token. Switch to the data state. */
674	$this->emitToken($this->token);
675	$this->state = 'data';
676
677	} else {
678	/* Anything else
679	Append the current input character to the current attribute's value.
680	Switch to the attribute value (unquoted) state. */
681	$last = count($this->token['attr']) - 1;
682	$this->token['attr'][$last]['value'] .= $char;
683
684	$this->state = 'attributeValueUnquoted';
685	}
686	}
687
688	private function attributeValueDoubleQuotedState() {
689	// Consume the next input character:
690	$this->char++;
691	$char = $this->character($this->char);
692
693	if($char === '"') {
694	/* U+0022 QUOTATION MARK (")
695	Switch to the before attribute name state. */
696	$this->state = 'beforeAttributeName';
697
698	} elseif($char === '&') {
699	/* U+0026 AMPERSAND (&)
700	Switch to the entity in attribute value state. */
701	$this->entityInAttributeValueState('double');
702
703	} elseif($this->char === $this->EOF) {
704	/* EOF
705	Parse error. Emit the current tag token. Reconsume the character
706	in the data state. */
707	$this->emitToken($this->token);
708
709	$this->char--;
710	$this->state = 'data';
711
712	} else {
713	/* Anything else
714	Append the current input character to the current attribute's value.
715	Stay in the attribute value (double-quoted) state. */
716	$last = count($this->token['attr']) - 1;
717	$this->token['attr'][$last]['value'] .= $char;
718
719	$this->state = 'attributeValueDoubleQuoted';
720	}
721	}
722
723	private function attributeValueSingleQuotedState() {
724	// Consume the next input character:
725	$this->char++;
726	$char = $this->character($this->char);
727
728	if($char === '\'') {
729	/* U+0022 QUOTATION MARK (')
730	Switch to the before attribute name state. */
731	$this->state = 'beforeAttributeName';
732
733	} elseif($char === '&') {
734	/* U+0026 AMPERSAND (&)
735	Switch to the entity in attribute value state. */
736	$this->entityInAttributeValueState('single');
737
738	} elseif($this->char === $this->EOF) {
739	/* EOF
740	Parse error. Emit the current tag token. Reconsume the character
741	in the data state. */
742	$this->emitToken($this->token);
743
744	$this->char--;
745	$this->state = 'data';
746
747	} else {
748	/* Anything else
749	Append the current input character to the current attribute's value.
750	Stay in the attribute value (single-quoted) state. */
751	$last = count($this->token['attr']) - 1;
752	$this->token['attr'][$last]['value'] .= $char;
753
754	$this->state = 'attributeValueSingleQuoted';
755	}
756	}
757
758	private function attributeValueUnquotedState() {
759	// Consume the next input character:
760	$this->char++;
761	$char = $this->character($this->char);
762
763	if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
764	/* U+0009 CHARACTER TABULATION
765	U+000A LINE FEED (LF)
766	U+000B LINE TABULATION
767	U+000C FORM FEED (FF)
768	U+0020 SPACE
769	Switch to the before attribute name state. */
770	$this->state = 'beforeAttributeName';
771
772	} elseif($char === '&') {
773	/* U+0026 AMPERSAND (&)
774	Switch to the entity in attribute value state. */
775	$this->entityInAttributeValueState();
776
777	} elseif($char === '>') {
778	/* U+003E GREATER-THAN SIGN (>)
779	Emit the current tag token. Switch to the data state. */
780	$this->emitToken($this->token);
781	$this->state = 'data';
782
783	} else {
784	/* Anything else
785	Append the current input character to the current attribute's value.
786	Stay in the attribute value (unquoted) state. */
787	$last = count($this->token['attr']) - 1;
788	$this->token['attr'][$last]['value'] .= $char;
789
790	$this->state = 'attributeValueUnquoted';
791	}
792	}
793
794	private function entityInAttributeValueState() {
795	// Attempt to consume an entity.
796	$entity = $this->entity();
797
798	// If nothing is returned, append a U+0026 AMPERSAND character to the
799	// current attribute's value. Otherwise, emit the character token that
800	// was returned.
801	$char = (!$entity)
802	? '&'
803	: $entity;
804
805	$last = count($this->token['attr']) - 1;
806	$this->token['attr'][$last]['value'] .= $char;
807	}
808
809	private function bogusCommentState() {
810	/* Consume every character up to the first U+003E GREATER-THAN SIGN
811	character (>) or the end of the file (EOF), whichever comes first. Emit
812	a comment token whose data is the concatenation of all the characters
813	starting from and including the character that caused the state machine
814	to switch into the bogus comment state, up to and including the last
815	consumed character before the U+003E character, if any, or up to the
816	end of the file otherwise. (If the comment was started by the end of
817	the file (EOF), the token is empty.) */
818	$data = $this->characters('^>', $this->char);
819	$this->emitToken(array(
820	'data' => $data,
821	'type' => self::COMMENT
822	));
823
824	$this->char += strlen($data);
825
826	/* Switch to the data state. */
827	$this->state = 'data';
828
829	/* If the end of the file was reached, reconsume the EOF character. */
830	if($this->char === $this->EOF) {
831	$this->char = $this->EOF - 1;
832	}
833	}
834
835	private function markupDeclarationOpenState() {
836	/* If the next two characters are both U+002D HYPHEN-MINUS (-)
837	characters, consume those two characters, create a comment token whose
838	data is the empty string, and switch to the comment state. */
839	if($this->character($this->char + 1, 2) === '--') {
840	$this->char += 2;
841	$this->state = 'comment';
842	$this->token = array(
843	'data' => null,
844	'type' => self::COMMENT
845	);
846
847	/* Otherwise if the next seven chacacters are a case-insensitive match
848	for the word "DOCTYPE", then consume those characters and switch to the
849	DOCTYPE state. */
850	} elseif(strtolower($this->character($this->char + 1, 7)) === 'doctype') {
851	$this->char += 7;
852	$this->state = 'doctype';
853
854	/* Otherwise, is is a parse error. Switch to the bogus comment state.
855	The next character that is consumed, if any, is the first character
856	that will be in the comment. */
857	} else {
858	$this->char++;
859	$this->state = 'bogusComment';
860	}
861	}
862
863	private function commentState() {
864	/* Consume the next input character: */
865	$this->char++;
866	$char = $this->char();
867
868	/* U+002D HYPHEN-MINUS (-) */
869	if($char === '-') {
870	/* Switch to the comment dash state */
871	$this->state = 'commentDash';
872
873	/* EOF */
874	} elseif($this->char === $this->EOF) {
875	/* Parse error. Emit the comment token. Reconsume the EOF character
876	in the data state. */
877	$this->emitToken($this->token);
878	$this->char--;
879	$this->state = 'data';
880
881	/* Anything else */
882	} else {
883	/* Append the input character to the comment token's data. Stay in
884	the comment state. */
885	$this->token['data'] .= $char;
886	}
887	}
888
889	private function commentDashState() {
890	/* Consume the next input character: */
891	$this->char++;
892	$char = $this->char();
893
894	/* U+002D HYPHEN-MINUS (-) */
895	if($char === '-') {
896	/* Switch to the comment end state */
897	$this->state = 'commentEnd';
898
899	/* EOF */
900	} elseif($this->char === $this->EOF) {
901	/* Parse error. Emit the comment token. Reconsume the EOF character
902	in the data state. */
903	$this->emitToken($this->token);
904	$this->char--;
905	$this->state = 'data';
906
907	/* Anything else */
908	} else {
909	/* Append a U+002D HYPHEN-MINUS (-) character and the input
910	character to the comment token's data. Switch to the comment state. */
911	$this->token['data'] .= '-'.$char;
912	$this->state = 'comment';
913	}
914	}
915
916	private function commentEndState() {
917	/* Consume the next input character: */
918	$this->char++;
919	$char = $this->char();
920
921	if($char === '>') {
922	$this->emitToken($this->token);
923	$this->state = 'data';
924
925	} elseif($char === '-') {
926	$this->token['data'] .= '-';
927
928	} elseif($this->char === $this->EOF) {
929	$this->emitToken($this->token);
930	$this->char--;
931	$this->state = 'data';
932
933	} else {
934	$this->token['data'] .= '--'.$char;
935	$this->state = 'comment';
936	}
937	}
938
939	private function doctypeState() {
940	/* Consume the next input character: */
941	$this->char++;
942	$char = $this->char();
943
944	if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
945	$this->state = 'beforeDoctypeName';
946
947	} else {
948	$this->char--;
949	$this->state = 'beforeDoctypeName';
950	}
951	}
952
953	private function beforeDoctypeNameState() {
954	/* Consume the next input character: */
955	$this->char++;
956	$char = $this->char();
957
958	if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
959	// Stay in the before DOCTYPE name state.
960
961	} elseif(preg_match('/^[a-z]$/', $char)) {
962	$this->token = array(
963	'name' => strtoupper($char),
964	'type' => self::DOCTYPE,
965	'error' => true
966	);
967
968	$this->state = 'doctypeName';
969
970	} elseif($char === '>') {
971	$this->emitToken(array(
972	'name' => null,
973	'type' => self::DOCTYPE,
974	'error' => true
975	));
976
977	$this->state = 'data';
978
979	} elseif($this->char === $this->EOF) {
980	$this->emitToken(array(
981	'name' => null,
982	'type' => self::DOCTYPE,
983	'error' => true
984	));
985
986	$this->char--;
987	$this->state = 'data';
988
989	} else {
990	$this->token = array(
991	'name' => $char,
992	'type' => self::DOCTYPE,
993	'error' => true
994	);
995
996	$this->state = 'doctypeName';
997	}
998	}
999
1000	private function doctypeNameState() {
1001	/* Consume the next input character: */
1002	$this->char++;
1003	$char = $this->char();
1004
1005	if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
1006	$this->state = 'AfterDoctypeName';
1007
1008	} elseif($char === '>') {
1009	$this->emitToken($this->token);
1010	$this->state = 'data';
1011
1012	} elseif(preg_match('/^[a-z]$/', $char)) {
1013	$this->token['name'] .= strtoupper($char);
1014
1015	} elseif($this->char === $this->EOF) {
1016	$this->emitToken($this->token);
1017	$this->char--;
1018	$this->state = 'data';
1019
1020	} else {
1021	$this->token['name'] .= $char;
1022	}
1023
1024	$this->token['error'] = ($this->token['name'] === 'HTML')
1025	? false
1026	: true;
1027	}
1028
1029	private function afterDoctypeNameState() {
1030	/* Consume the next input character: */
1031	$this->char++;
1032	$char = $this->char();
1033
1034	if(preg_match('/^[\t\n\x0b\x0c ]$/', $char)) {
1035	// Stay in the DOCTYPE name state.
1036
1037	} elseif($char === '>') {
1038	$this->emitToken($this->token);
1039	$this->state = 'data';
1040
1041	} elseif($this->char === $this->EOF) {
1042	$this->emitToken($this->token);
1043	$this->char--;
1044	$this->state = 'data';
1045
1046	} else {
1047	$this->token['error'] = true;
1048	$this->state = 'bogusDoctype';
1049	}
1050	}
1051
1052	private function bogusDoctypeState() {
1053	/* Consume the next input character: */
1054	$this->char++;
1055	$char = $this->char();
1056
1057	if($char === '>') {
1058	$this->emitToken($this->token);
1059	$this->state = 'data';
1060
1061	} elseif($this->char === $this->EOF) {
1062	$this->emitToken($this->token);
1063	$this->char--;
1064	$this->state = 'data';
1065
1066	} else {
1067	// Stay in the bogus DOCTYPE state.
1068	}
1069	}
1070
1071	private function entity() {
1072	$start = $this->char;
1073
1074	// This section defines how to consume an entity. This definition is
1075	// used when parsing entities in text and in attributes.
1076
1077	// The behaviour depends on the identity of the next character (the
1078	// one immediately after the U+0026 AMPERSAND character):
1079
1080	switch($this->character($this->char + 1)) {
1081	// U+0023 NUMBER SIGN (#)
1082	case '#':
1083
1084	// The behaviour further depends on the character after the
1085	// U+0023 NUMBER SIGN:
1086	switch($this->character($this->char + 1)) {
1087	// U+0078 LATIN SMALL LETTER X
1088	// U+0058 LATIN CAPITAL LETTER X
1089	case 'x':
1090	case 'X':
1091	// Follow the steps below, but using the range of
1092	// characters U+0030 DIGIT ZERO through to U+0039 DIGIT
1093	// NINE, U+0061 LATIN SMALL LETTER A through to U+0066
1094	// LATIN SMALL LETTER F, and U+0041 LATIN CAPITAL LETTER
1095	// A, through to U+0046 LATIN CAPITAL LETTER F (in other
1096	// words, 0-9, A-F, a-f).
1097	$char = 1;
1098	$char_class = '0-9A-Fa-f';
1099	break;
1100
1101	// Anything else
1102	default:
1103	// Follow the steps below, but using the range of
1104	// characters U+0030 DIGIT ZERO through to U+0039 DIGIT
1105	// NINE (i.e. just 0-9).
1106	$char = 0;
1107	$char_class = '0-9';
1108	break;
1109	}
1110
1111	// Consume as many characters as match the range of characters
1112	// given above.
1113	$this->char++;
1114	$e_name = $this->characters($char_class, $this->char + $char + 1);
1115	$entity = $this->character($start, $this->char);
1116	$cond = strlen($e_name) > 0;
1117
1118	// The rest of the parsing happens bellow.
1119	break;
1120
1121	// Anything else
1122	default:
1123	// Consume the maximum number of characters possible, with the
1124	// consumed characters case-sensitively matching one of the
1125	// identifiers in the first column of the entities table.
1126	$e_name = $this->characters('0-9A-Za-z;', $this->char + 1);
1127	$len = strlen($e_name);
1128
1129	for($c = 1; $c <= $len; $c++) {
1130	$id = substr($e_name, 0, $c);
1131	$this->char++;
1132
1133	if(in_array($id, $this->entities)) {
1134	if ($e_name[$c-1] !== ';') {
1135	if ($c < $len && $e_name[$c] == ';') {
1136	$this->char++; // consume extra semicolon
1137	}
1138	}
1139	$entity = $id;
1140	break;
1141	}
1142	}
1143
1144	$cond = isset($entity);
1145	// The rest of the parsing happens bellow.
1146	break;
1147	}
1148
1149	if(!$cond) {
1150	// If no match can be made, then this is a parse error. No
1151	// characters are consumed, and nothing is returned.
1152	$this->char = $start;
1153	return false;
1154	}
1155
1156	// Return a character token for the character corresponding to the
1157	// entity name (as given by the second column of the entities table).
1158	return html_entity_decode('&'.$entity.';', ENT_QUOTES, 'UTF-8');
1159	}
1160
1161	private function emitToken($token) {
1162	$emit = $this->tree->emitToken($token);
1163
1164	if(is_int($emit)) {
1165	$this->content_model = $emit;
1166
1167	} elseif($token['type'] === self::ENDTAG) {
1168	$this->content_model = self::PCDATA;
1169	}
1170	}
1171
1172	private function EOF() {
1173	$this->state = null;
1174	$this->tree->emitToken(array(
1175	'type' => self::EOF
1176	));
1177	}
1178	}
1179
1180	class HTML5TreeConstructer {
1181	public $stack = array();
1182
1183	private $phase;
1184	private $mode;
1185	private $dom;
1186	private $foster_parent = null;
1187	private $a_formatting = array();
1188
1189	private $head_pointer = null;
1190	private $form_pointer = null;
1191
1192	private $scoping = array('button','caption','html','marquee','object','table','td','th');
1193	private $formatting = array('a','b','big','em','font','i','nobr','s','small','strike','strong','tt','u');
1194	private $special = array('address','area','base','basefont','bgsound',
1195	'blockquote','body','br','center','col','colgroup','dd','dir','div','dl',
1196	'dt','embed','fieldset','form','frame','frameset','h1','h2','h3','h4','h5',
1197	'h6','head','hr','iframe','image','img','input','isindex','li','link',
1198	'listing','menu','meta','noembed','noframes','noscript','ol','optgroup',
1199	'option','p','param','plaintext','pre','script','select','spacer','style',
1200	'tbody','textarea','tfoot','thead','title','tr','ul','wbr');
1201
1202	// The different phases.
1203	const INIT_PHASE = 0;
1204	const ROOT_PHASE = 1;
1205	const MAIN_PHASE = 2;
1206	const END_PHASE = 3;
1207
1208	// The different insertion modes for the main phase.
1209	const BEFOR_HEAD = 0;
1210	const IN_HEAD = 1;
1211	const AFTER_HEAD = 2;
1212	const IN_BODY = 3;
1213	const IN_TABLE = 4;
1214	const IN_CAPTION = 5;
1215	const IN_CGROUP = 6;
1216	const IN_TBODY = 7;
1217	const IN_ROW = 8;
1218	const IN_CELL = 9;
1219	const IN_SELECT = 10;
1220	const AFTER_BODY = 11;
1221	const IN_FRAME = 12;
1222	const AFTR_FRAME = 13;
1223
1224	// The different types of elements.
1225	const SPECIAL = 0;
1226	const SCOPING = 1;
1227	const FORMATTING = 2;
1228	const PHRASING = 3;
1229
1230	const MARKER = 0;
1231
1232	public function __construct() {
1233	$this->phase = self::INIT_PHASE;
1234	$this->mode = self::BEFOR_HEAD;
1235	$this->dom = new DOMDocument;
1236
1237	$this->dom->encoding = 'UTF-8';
1238	$this->dom->preserveWhiteSpace = true;
1239	$this->dom->substituteEntities = true;
1240	$this->dom->strictErrorChecking = false;
1241	}
1242
1243	// Process tag tokens
1244	public function emitToken($token) {
1245	switch($this->phase) {
1246	case self::INIT_PHASE: return $this->initPhase($token); break;
1247	case self::ROOT_PHASE: return $this->rootElementPhase($token); break;
1248	case self::MAIN_PHASE: return $this->mainPhase($token); break;
1249	case self::END_PHASE : return $this->trailingEndPhase($token); break;
1250	}
1251	}
1252
1253	private function initPhase($token) {
1254	/* Initially, the tree construction stage must handle each token
1255	emitted from the tokenisation stage as follows: */
1256
1257	/* A DOCTYPE token that is marked as being in error
1258	A comment token
1259	A start tag token
1260	An end tag token
1261	A character token that is not one of one of U+0009 CHARACTER TABULATION,
1262	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1263	or U+0020 SPACE
1264	An end-of-file token */
1265	if((isset($token['error']) && $token['error']) \|\|
1266	$token['type'] === HTML5::COMMENT \|\|
1267	$token['type'] === HTML5::STARTTAG \|\|
1268	$token['type'] === HTML5::ENDTAG \|\|
1269	$token['type'] === HTML5::EOF \|\|
1270	($token['type'] === HTML5::CHARACTR && isset($token['data']) &&
1271	!preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data']))) {
1272	/* This specification does not define how to handle this case. In
1273	particular, user agents may ignore the entirety of this specification
1274	altogether for such documents, and instead invoke special parse modes
1275	with a greater emphasis on backwards compatibility. */
1276
1277	$this->phase = self::ROOT_PHASE;
1278	return $this->rootElementPhase($token);
1279
1280	/* A DOCTYPE token marked as being correct */
1281	} elseif(isset($token['error']) && !$token['error']) {
1282	/* Append a DocumentType node to the Document node, with the name
1283	attribute set to the name given in the DOCTYPE token (which will be
1284	"HTML"), and the other attributes specific to DocumentType objects
1285	set to null, empty lists, or the empty string as appropriate. */
1286	$doctype = new DOMDocumentType(null, null, 'HTML');
1287
1288	/* Then, switch to the root element phase of the tree construction
1289	stage. */
1290	$this->phase = self::ROOT_PHASE;
1291
1292	/* A character token that is one of one of U+0009 CHARACTER TABULATION,
1293	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1294	or U+0020 SPACE */
1295	} elseif(isset($token['data']) && preg_match('/^[\t\n\x0b\x0c ]+$/',
1296	$token['data'])) {
1297	/* Append that character to the Document node. */
1298	$text = $this->dom->createTextNode($token['data']);
1299	$this->dom->appendChild($text);
1300	}
1301	}
1302
1303	private function rootElementPhase($token) {
1304	/* After the initial phase, as each token is emitted from the tokenisation
1305	stage, it must be processed as described in this section. */
1306
1307	/* A DOCTYPE token */
1308	if($token['type'] === HTML5::DOCTYPE) {
1309	// Parse error. Ignore the token.
1310
1311	/* A comment token */
1312	} elseif($token['type'] === HTML5::COMMENT) {
1313	/* Append a Comment node to the Document object with the data
1314	attribute set to the data given in the comment token. */
1315	$comment = $this->dom->createComment($token['data']);
1316	$this->dom->appendChild($comment);
1317
1318	/* A character token that is one of one of U+0009 CHARACTER TABULATION,
1319	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1320	or U+0020 SPACE */
1321	} elseif($token['type'] === HTML5::CHARACTR &&
1322	preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
1323	/* Append that character to the Document node. */
1324	$text = $this->dom->createTextNode($token['data']);
1325	$this->dom->appendChild($text);
1326
1327	/* A character token that is not one of U+0009 CHARACTER TABULATION,
1328	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED
1329	(FF), or U+0020 SPACE
1330	A start tag token
1331	An end tag token
1332	An end-of-file token */
1333	} elseif(($token['type'] === HTML5::CHARACTR &&
1334	!preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) \|\|
1335	$token['type'] === HTML5::STARTTAG \|\|
1336	$token['type'] === HTML5::ENDTAG \|\|
1337	$token['type'] === HTML5::EOF) {
1338	/* Create an HTMLElement node with the tag name html, in the HTML
1339	namespace. Append it to the Document object. Switch to the main
1340	phase and reprocess the current token. */
1341	$html = $this->dom->createElement('html');
1342	$this->dom->appendChild($html);
1343	$this->stack[] = $html;
1344
1345	$this->phase = self::MAIN_PHASE;
1346	return $this->mainPhase($token);
1347	}
1348	}
1349
1350	private function mainPhase($token) {
1351	/* Tokens in the main phase must be handled as follows: */
1352
1353	/* A DOCTYPE token */
1354	if($token['type'] === HTML5::DOCTYPE) {
1355	// Parse error. Ignore the token.
1356
1357	/* A start tag token with the tag name "html" */
1358	} elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'html') {
1359	/* If this start tag token was not the first start tag token, then
1360	it is a parse error. */
1361
1362	/* For each attribute on the token, check to see if the attribute
1363	is already present on the top element of the stack of open elements.
1364	If it is not, add the attribute and its corresponding value to that
1365	element. */
1366	foreach($token['attr'] as $attr) {
1367	if(!$this->stack[0]->hasAttribute($attr['name'])) {
1368	$this->stack[0]->setAttribute($attr['name'], $attr['value']);
1369	}
1370	}
1371
1372	/* An end-of-file token */
1373	} elseif($token['type'] === HTML5::EOF) {
1374	/* Generate implied end tags. */
1375	$this->generateImpliedEndTags();
1376
1377	/* Anything else. */
1378	} else {
1379	/* Depends on the insertion mode: */
1380	switch($this->mode) {
1381	case self::BEFOR_HEAD: return $this->beforeHead($token); break;
1382	case self::IN_HEAD: return $this->inHead($token); break;
1383	case self::AFTER_HEAD: return $this->afterHead($token); break;
1384	case self::IN_BODY: return $this->inBody($token); break;
1385	case self::IN_TABLE: return $this->inTable($token); break;
1386	case self::IN_CAPTION: return $this->inCaption($token); break;
1387	case self::IN_CGROUP: return $this->inColumnGroup($token); break;
1388	case self::IN_TBODY: return $this->inTableBody($token); break;
1389	case self::IN_ROW: return $this->inRow($token); break;
1390	case self::IN_CELL: return $this->inCell($token); break;
1391	case self::IN_SELECT: return $this->inSelect($token); break;
1392	case self::AFTER_BODY: return $this->afterBody($token); break;
1393	case self::IN_FRAME: return $this->inFrameset($token); break;
1394	case self::AFTR_FRAME: return $this->afterFrameset($token); break;
1395	case self::END_PHASE: return $this->trailingEndPhase($token); break;
1396	}
1397	}
1398	}
1399
1400	private function beforeHead($token) {
1401	/* Handle the token as follows: */
1402
1403	/* A character token that is one of one of U+0009 CHARACTER TABULATION,
1404	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1405	or U+0020 SPACE */
1406	if($token['type'] === HTML5::CHARACTR &&
1407	preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
1408	/* Append the character to the current node. */
1409	$this->insertText($token['data']);
1410
1411	/* A comment token */
1412	} elseif($token['type'] === HTML5::COMMENT) {
1413	/* Append a Comment node to the current node with the data attribute
1414	set to the data given in the comment token. */
1415	$this->insertComment($token['data']);
1416
1417	/* A start tag token with the tag name "head" */
1418	} elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'head') {
1419	/* Create an element for the token, append the new element to the
1420	current node and push it onto the stack of open elements. */
1421	$element = $this->insertElement($token);
1422
1423	/* Set the head element pointer to this new element node. */
1424	$this->head_pointer = $element;
1425
1426	/* Change the insertion mode to "in head". */
1427	$this->mode = self::IN_HEAD;
1428
1429	/* A start tag token whose tag name is one of: "base", "link", "meta",
1430	"script", "style", "title". Or an end tag with the tag name "html".
1431	Or a character token that is not one of U+0009 CHARACTER TABULATION,
1432	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1433	or U+0020 SPACE. Or any other start tag token */
1434	} elseif($token['type'] === HTML5::STARTTAG \|\|
1435	($token['type'] === HTML5::ENDTAG && $token['name'] === 'html') \|\|
1436	($token['type'] === HTML5::CHARACTR && !preg_match('/^[\t\n\x0b\x0c ]$/',
1437	$token['data']))) {
1438	/* Act as if a start tag token with the tag name "head" and no
1439	attributes had been seen, then reprocess the current token. */
1440	$this->beforeHead(array(
1441	'name' => 'head',
1442	'type' => HTML5::STARTTAG,
1443	'attr' => array()
1444	));
1445
1446	return $this->inHead($token);
1447
1448	/* Any other end tag */
1449	} elseif($token['type'] === HTML5::ENDTAG) {
1450	/* Parse error. Ignore the token. */
1451	}
1452	}
1453
1454	private function inHead($token) {
1455	/* Handle the token as follows: */
1456
1457	/* A character token that is one of one of U+0009 CHARACTER TABULATION,
1458	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1459	or U+0020 SPACE.
1460
1461	THIS DIFFERS FROM THE SPEC: If the current node is either a title, style
1462	or script element, append the character to the current node regardless
1463	of its content. */
1464	if(($token['type'] === HTML5::CHARACTR &&
1465	preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) \|\| (
1466	$token['type'] === HTML5::CHARACTR && in_array(end($this->stack)->nodeName,
1467	array('title', 'style', 'script')))) {
1468	/* Append the character to the current node. */
1469	$this->insertText($token['data']);
1470
1471	/* A comment token */
1472	} elseif($token['type'] === HTML5::COMMENT) {
1473	/* Append a Comment node to the current node with the data attribute
1474	set to the data given in the comment token. */
1475	$this->insertComment($token['data']);
1476
1477	} elseif($token['type'] === HTML5::ENDTAG &&
1478	in_array($token['name'], array('title', 'style', 'script'))) {
1479	array_pop($this->stack);
1480	return HTML5::PCDATA;
1481
1482	/* A start tag with the tag name "title" */
1483	} elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'title') {
1484	/* Create an element for the token and append the new element to the
1485	node pointed to by the head element pointer, or, if that is null
1486	(innerHTML case), to the current node. */
1487	if($this->head_pointer !== null) {
1488	$element = $this->insertElement($token, false);
1489	$this->head_pointer->appendChild($element);
1490
1491	} else {
1492	$element = $this->insertElement($token);
1493	}
1494
1495	/* Switch the tokeniser's content model flag to the RCDATA state. */
1496	return HTML5::RCDATA;
1497
1498	/* A start tag with the tag name "style" */
1499	} elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'style') {
1500	/* Create an element for the token and append the new element to the
1501	node pointed to by the head element pointer, or, if that is null
1502	(innerHTML case), to the current node. */
1503	if($this->head_pointer !== null) {
1504	$element = $this->insertElement($token, false);
1505	$this->head_pointer->appendChild($element);
1506
1507	} else {
1508	$this->insertElement($token);
1509	}
1510
1511	/* Switch the tokeniser's content model flag to the CDATA state. */
1512	return HTML5::CDATA;
1513
1514	/* A start tag with the tag name "script" */
1515	} elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'script') {
1516	/* Create an element for the token. */
1517	$element = $this->insertElement($token, false);
1518	$this->head_pointer->appendChild($element);
1519
1520	/* Switch the tokeniser's content model flag to the CDATA state. */
1521	return HTML5::CDATA;
1522
1523	/* A start tag with the tag name "base", "link", or "meta" */
1524	} elseif($token['type'] === HTML5::STARTTAG && in_array($token['name'],
1525	array('base', 'link', 'meta'))) {
1526	/* Create an element for the token and append the new element to the
1527	node pointed to by the head element pointer, or, if that is null
1528	(innerHTML case), to the current node. */
1529	if($this->head_pointer !== null) {
1530	$element = $this->insertElement($token, false);
1531	$this->head_pointer->appendChild($element);
1532	array_pop($this->stack);
1533
1534	} else {
1535	$this->insertElement($token);
1536	}
1537
1538	/* An end tag with the tag name "head" */
1539	} elseif($token['type'] === HTML5::ENDTAG && $token['name'] === 'head') {
1540	/* If the current node is a head element, pop the current node off
1541	the stack of open elements. */
1542	if($this->head_pointer->isSameNode(end($this->stack))) {
1543	array_pop($this->stack);
1544
1545	/* Otherwise, this is a parse error. */
1546	} else {
1547	// k
1548	}
1549
1550	/* Change the insertion mode to "after head". */
1551	$this->mode = self::AFTER_HEAD;
1552
1553	/* A start tag with the tag name "head" or an end tag except "html". */
1554	} elseif(($token['type'] === HTML5::STARTTAG && $token['name'] === 'head') \|\|
1555	($token['type'] === HTML5::ENDTAG && $token['name'] !== 'html')) {
1556	// Parse error. Ignore the token.
1557
1558	/* Anything else */
1559	} else {
1560	/* If the current node is a head element, act as if an end tag
1561	token with the tag name "head" had been seen. */
1562	if($this->head_pointer->isSameNode(end($this->stack))) {
1563	$this->inHead(array(
1564	'name' => 'head',
1565	'type' => HTML5::ENDTAG
1566	));
1567
1568	/* Otherwise, change the insertion mode to "after head". */
1569	} else {
1570	$this->mode = self::AFTER_HEAD;
1571	}
1572
1573	/* Then, reprocess the current token. */
1574	return $this->afterHead($token);
1575	}
1576	}
1577
1578	private function afterHead($token) {
1579	/* Handle the token as follows: */
1580
1581	/* A character token that is one of one of U+0009 CHARACTER TABULATION,
1582	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
1583	or U+0020 SPACE */
1584	if($token['type'] === HTML5::CHARACTR &&
1585	preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
1586	/* Append the character to the current node. */
1587	$this->insertText($token['data']);
1588
1589	/* A comment token */
1590	} elseif($token['type'] === HTML5::COMMENT) {
1591	/* Append a Comment node to the current node with the data attribute
1592	set to the data given in the comment token. */
1593	$this->insertComment($token['data']);
1594
1595	/* A start tag token with the tag name "body" */
1596	} elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'body') {
1597	/* Insert a body element for the token. */
1598	$this->insertElement($token);
1599
1600	/* Change the insertion mode to "in body". */
1601	$this->mode = self::IN_BODY;
1602
1603	/* A start tag token with the tag name "frameset" */
1604	} elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'frameset') {
1605	/* Insert a frameset element for the token. */
1606	$this->insertElement($token);
1607
1608	/* Change the insertion mode to "in frameset". */
1609	$this->mode = self::IN_FRAME;
1610
1611	/* A start tag token whose tag name is one of: "base", "link", "meta",
1612	"script", "style", "title" */
1613	} elseif($token['type'] === HTML5::STARTTAG && in_array($token['name'],
1614	array('base', 'link', 'meta', 'script', 'style', 'title'))) {
1615	/* Parse error. Switch the insertion mode back to "in head" and
1616	reprocess the token. */
1617	$this->mode = self::IN_HEAD;
1618	return $this->inHead($token);
1619
1620	/* Anything else */
1621	} else {
1622	/* Act as if a start tag token with the tag name "body" and no
1623	attributes had been seen, and then reprocess the current token. */
1624	$this->afterHead(array(
1625	'name' => 'body',
1626	'type' => HTML5::STARTTAG,
1627	'attr' => array()
1628	));
1629
1630	return $this->inBody($token);
1631	}
1632	}
1633
1634	private function inBody($token) {
1635	/* Handle the token as follows: */
1636
1637	switch($token['type']) {
1638	/* A character token */
1639	case HTML5::CHARACTR:
1640	/* Reconstruct the active formatting elements, if any. */
1641	$this->reconstructActiveFormattingElements();
1642
1643	/* Append the token's character to the current node. */
1644	$this->insertText($token['data']);
1645	break;
1646
1647	/* A comment token */
1648	case HTML5::COMMENT:
1649	/* Append a Comment node to the current node with the data
1650	attribute set to the data given in the comment token. */
1651	$this->insertComment($token['data']);
1652	break;
1653
1654	case HTML5::STARTTAG:
1655	switch($token['name']) {
1656	/* A start tag token whose tag name is one of: "script",
1657	"style" */
1658	case 'script': case 'style':
1659	/* Process the token as if the insertion mode had been "in
1660	head". */
1661	return $this->inHead($token);
1662	break;
1663
1664	/* A start tag token whose tag name is one of: "base", "link",
1665	"meta", "title" */
1666	case 'base': case 'link': case 'meta': case 'title':
1667	/* Parse error. Process the token as if the insertion mode
1668	had been "in head". */
1669	return $this->inHead($token);
1670	break;
1671
1672	/* A start tag token with the tag name "body" */
1673	case 'body':
1674	/* Parse error. If the second element on the stack of open
1675	elements is not a body element, or, if the stack of open
1676	elements has only one node on it, then ignore the token.
1677	(innerHTML case) */
1678	if(count($this->stack) === 1 \|\| $this->stack[1]->nodeName !== 'body') {
1679	// Ignore
1680
1681	/* Otherwise, for each attribute on the token, check to see
1682	if the attribute is already present on the body element (the
1683	second element) on the stack of open elements. If it is not,
1684	add the attribute and its corresponding value to that
1685	element. */
1686	} else {
1687	foreach($token['attr'] as $attr) {
1688	if(!$this->stack[1]->hasAttribute($attr['name'])) {
1689	$this->stack[1]->setAttribute($attr['name'], $attr['value']);
1690	}
1691	}
1692	}
1693	break;
1694
1695	/* A start tag whose tag name is one of: "address",
1696	"blockquote", "center", "dir", "div", "dl", "fieldset",
1697	"listing", "menu", "ol", "p", "ul" */
1698	case 'address': case 'blockquote': case 'center': case 'dir':
1699	case 'div': case 'dl': case 'fieldset': case 'listing':
1700	case 'menu': case 'ol': case 'p': case 'ul':
1701	/* If the stack of open elements has a p element in scope,
1702	then act as if an end tag with the tag name p had been
1703	seen. */
1704	if($this->elementInScope('p')) {
1705	$this->emitToken(array(
1706	'name' => 'p',
1707	'type' => HTML5::ENDTAG
1708	));
1709	}
1710
1711	/* Insert an HTML element for the token. */
1712	$this->insertElement($token);
1713	break;
1714
1715	/* A start tag whose tag name is "form" */
1716	case 'form':
1717	/* If the form element pointer is not null, ignore the
1718	token with a parse error. */
1719	if($this->form_pointer !== null) {
1720	// Ignore.
1721
1722	/* Otherwise: */
1723	} else {
1724	/* If the stack of open elements has a p element in
1725	scope, then act as if an end tag with the tag name p
1726	had been seen. */
1727	if($this->elementInScope('p')) {
1728	$this->emitToken(array(
1729	'name' => 'p',
1730	'type' => HTML5::ENDTAG
1731	));
1732	}
1733
1734	/* Insert an HTML element for the token, and set the
1735	form element pointer to point to the element created. */
1736	$element = $this->insertElement($token);
1737	$this->form_pointer = $element;
1738	}
1739	break;
1740
1741	/* A start tag whose tag name is "li", "dd" or "dt" */
1742	case 'li': case 'dd': case 'dt':
1743	/* If the stack of open elements has a p element in scope,
1744	then act as if an end tag with the tag name p had been
1745	seen. */
1746	if($this->elementInScope('p')) {
1747	$this->emitToken(array(
1748	'name' => 'p',
1749	'type' => HTML5::ENDTAG
1750	));
1751	}
1752
1753	$stack_length = count($this->stack) - 1;
1754
1755	for($n = $stack_length; 0 <= $n; $n--) {
1756	/* 1. Initialise node to be the current node (the
1757	bottommost node of the stack). */
1758	$stop = false;
1759	$node = $this->stack[$n];
1760	$cat = $this->getElementCategory($node->tagName);
1761
1762	/* 2. If node is an li, dd or dt element, then pop all
1763	the nodes from the current node up to node, including
1764	node, then stop this algorithm. */
1765	if($token['name'] === $node->tagName \|\| ($token['name'] !== 'li'
1766	&& ($node->tagName === 'dd' \|\| $node->tagName === 'dt'))) {
1767	for($x = $stack_length; $x >= $n ; $x--) {
1768	array_pop($this->stack);
1769	}
1770
1771	break;
1772	}
1773
1774	/* 3. If node is not in the formatting category, and is
1775	not in the phrasing category, and is not an address or
1776	div element, then stop this algorithm. */
1777	if($cat !== self::FORMATTING && $cat !== self::PHRASING &&
1778	$node->tagName !== 'address' && $node->tagName !== 'div') {
1779	break;
1780	}
1781	}
1782
1783	/* Finally, insert an HTML element with the same tag
1784	name as the token's. */
1785	$this->insertElement($token);
1786	break;
1787
1788	/* A start tag token whose tag name is "plaintext" */
1789	case 'plaintext':
1790	/* If the stack of open elements has a p element in scope,
1791	then act as if an end tag with the tag name p had been
1792	seen. */
1793	if($this->elementInScope('p')) {
1794	$this->emitToken(array(
1795	'name' => 'p',
1796	'type' => HTML5::ENDTAG
1797	));
1798	}
1799
1800	/* Insert an HTML element for the token. */
1801	$this->insertElement($token);
1802
1803	return HTML5::PLAINTEXT;
1804	break;
1805
1806	/* A start tag whose tag name is one of: "h1", "h2", "h3", "h4",
1807	"h5", "h6" */
1808	case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':
1809	/* If the stack of open elements has a p element in scope,
1810	then act as if an end tag with the tag name p had been seen. */
1811	if($this->elementInScope('p')) {
1812	$this->emitToken(array(
1813	'name' => 'p',
1814	'type' => HTML5::ENDTAG
1815	));
1816	}
1817
1818	/* If the stack of open elements has in scope an element whose
1819	tag name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
1820	this is a parse error; pop elements from the stack until an
1821	element with one of those tag names has been popped from the
1822	stack. */
1823	while($this->elementInScope(array('h1', 'h2', 'h3', 'h4', 'h5', 'h6'))) {
1824	array_pop($this->stack);
1825	}
1826
1827	/* Insert an HTML element for the token. */
1828	$this->insertElement($token);
1829	break;
1830
1831	/* A start tag whose tag name is "a" */
1832	case 'a':
1833	/* If the list of active formatting elements contains
1834	an element whose tag name is "a" between the end of the
1835	list and the last marker on the list (or the start of
1836	the list if there is no marker on the list), then this
1837	is a parse error; act as if an end tag with the tag name
1838	"a" had been seen, then remove that element from the list
1839	of active formatting elements and the stack of open
1840	elements if the end tag didn't already remove it (it
1841	might not have if the element is not in table scope). */
1842	$leng = count($this->a_formatting);
1843
1844	for($n = $leng - 1; $n >= 0; $n--) {
1845	if($this->a_formatting[$n] === self::MARKER) {
1846	break;
1847
1848	} elseif($this->a_formatting[$n]->nodeName === 'a') {
1849	$this->emitToken(array(
1850	'name' => 'a',
1851	'type' => HTML5::ENDTAG
1852	));
1853	break;
1854	}
1855	}
1856
1857	/* Reconstruct the active formatting elements, if any. */
1858	$this->reconstructActiveFormattingElements();
1859
1860	/* Insert an HTML element for the token. */
1861	$el = $this->insertElement($token);
1862
1863	/* Add that element to the list of active formatting
1864	elements. */
1865	$this->a_formatting[] = $el;
1866	break;
1867
1868	/* A start tag whose tag name is one of: "b", "big", "em", "font",
1869	"i", "nobr", "s", "small", "strike", "strong", "tt", "u" */
1870	case 'b': case 'big': case 'em': case 'font': case 'i':
1871	case 'nobr': case 's': case 'small': case 'strike':
1872	case 'strong': case 'tt': case 'u':
1873	/* Reconstruct the active formatting elements, if any. */
1874	$this->reconstructActiveFormattingElements();
1875
1876	/* Insert an HTML element for the token. */
1877	$el = $this->insertElement($token);
1878
1879	/* Add that element to the list of active formatting
1880	elements. */
1881	$this->a_formatting[] = $el;
1882	break;
1883
1884	/* A start tag token whose tag name is "button" */
1885	case 'button':
1886	/* If the stack of open elements has a button element in scope,
1887	then this is a parse error; act as if an end tag with the tag
1888	name "button" had been seen, then reprocess the token. (We don't
1889	do that. Unnecessary.) */
1890	if($this->elementInScope('button')) {
1891	$this->inBody(array(
1892	'name' => 'button',
1893	'type' => HTML5::ENDTAG
1894	));
1895	}
1896
1897	/* Reconstruct the active formatting elements, if any. */
1898	$this->reconstructActiveFormattingElements();
1899
1900	/* Insert an HTML element for the token. */
1901	$this->insertElement($token);
1902
1903	/* Insert a marker at the end of the list of active
1904	formatting elements. */
1905	$this->a_formatting[] = self::MARKER;
1906	break;
1907
1908	/* A start tag token whose tag name is one of: "marquee", "object" */
1909	case 'marquee': case 'object':
1910	/* Reconstruct the active formatting elements, if any. */
1911	$this->reconstructActiveFormattingElements();
1912
1913	/* Insert an HTML element for the token. */
1914	$this->insertElement($token);
1915
1916	/* Insert a marker at the end of the list of active
1917	formatting elements. */
1918	$this->a_formatting[] = self::MARKER;
1919	break;
1920
1921	/* A start tag token whose tag name is "xmp" */
1922	case 'xmp':
1923	/* Reconstruct the active formatting elements, if any. */
1924	$this->reconstructActiveFormattingElements();
1925
1926	/* Insert an HTML element for the token. */
1927	$this->insertElement($token);
1928
1929	/* Switch the content model flag to the CDATA state. */
1930	return HTML5::CDATA;
1931	break;
1932
1933	/* A start tag whose tag name is "table" */
1934	case 'table':
1935	/* If the stack of open elements has a p element in scope,
1936	then act as if an end tag with the tag name p had been seen. */
1937	if($this->elementInScope('p')) {
1938	$this->emitToken(array(
1939	'name' => 'p',
1940	'type' => HTML5::ENDTAG
1941	));
1942	}
1943
1944	/* Insert an HTML element for the token. */
1945	$this->insertElement($token);
1946
1947	/* Change the insertion mode to "in table". */
1948	$this->mode = self::IN_TABLE;
1949	break;
1950
1951	/* A start tag whose tag name is one of: "area", "basefont",
1952	"bgsound", "br", "embed", "img", "param", "spacer", "wbr" */
1953	case 'area': case 'basefont': case 'bgsound': case 'br':
1954	case 'embed': case 'img': case 'param': case 'spacer':
1955	case 'wbr':
1956	/* Reconstruct the active formatting elements, if any. */
1957	$this->reconstructActiveFormattingElements();
1958
1959	/* Insert an HTML element for the token. */
1960	$this->insertElement($token);
1961
1962	/* Immediately pop the current node off the stack of open elements. */
1963	array_pop($this->stack);
1964	break;
1965
1966	/* A start tag whose tag name is "hr" */
1967	case 'hr':
1968	/* If the stack of open elements has a p element in scope,
1969	then act as if an end tag with the tag name p had been seen. */
1970	if($this->elementInScope('p')) {
1971	$this->emitToken(array(
1972	'name' => 'p',
1973	'type' => HTML5::ENDTAG
1974	));
1975	}
1976
1977	/* Insert an HTML element for the token. */
1978	$this->insertElement($token);
1979
1980	/* Immediately pop the current node off the stack of open elements. */
1981	array_pop($this->stack);
1982	break;
1983
1984	/* A start tag whose tag name is "image" */
1985	case 'image':
1986	/* Parse error. Change the token's tag name to "img" and
1987	reprocess it. (Don't ask.) */
1988	$token['name'] = 'img';
1989	return $this->inBody($token);
1990	break;
1991
1992	/* A start tag whose tag name is "input" */
1993	case 'input':
1994	/* Reconstruct the active formatting elements, if any. */
1995	$this->reconstructActiveFormattingElements();
1996
1997	/* Insert an input element for the token. */
1998	$element = $this->insertElement($token, false);
1999
2000	/* If the form element pointer is not null, then associate the
2001	input element with the form element pointed to by the form
2002	element pointer. */
2003	$this->form_pointer !== null
2004	? $this->form_pointer->appendChild($element)
2005	: end($this->stack)->appendChild($element);
2006
2007	/* Pop that input element off the stack of open elements. */
2008	array_pop($this->stack);
2009	break;
2010
2011	/* A start tag whose tag name is "isindex" */
2012	case 'isindex':
2013	/* Parse error. */
2014	// w/e
2015
2016	/* If the form element pointer is not null,
2017	then ignore the token. */
2018	if($this->form_pointer === null) {
2019	/* Act as if a start tag token with the tag name "form" had
2020	been seen. */
2021	$this->inBody(array(
2022	'name' => 'body',
2023	'type' => HTML5::STARTTAG,
2024	'attr' => array()
2025	));
2026
2027	/* Act as if a start tag token with the tag name "hr" had
2028	been seen. */
2029	$this->inBody(array(
2030	'name' => 'hr',
2031	'type' => HTML5::STARTTAG,
2032	'attr' => array()
2033	));
2034
2035	/* Act as if a start tag token with the tag name "p" had
2036	been seen. */
2037	$this->inBody(array(
2038	'name' => 'p',
2039	'type' => HTML5::STARTTAG,
2040	'attr' => array()
2041	));
2042
2043	/* Act as if a start tag token with the tag name "label"
2044	had been seen. */
2045	$this->inBody(array(
2046	'name' => 'label',
2047	'type' => HTML5::STARTTAG,
2048	'attr' => array()
2049	));
2050
2051	/* Act as if a stream of character tokens had been seen. */
2052	$this->insertText('This is a searchable index. '.
2053	'Insert your search keywords here: ');
2054
2055	/* Act as if a start tag token with the tag name "input"
2056	had been seen, with all the attributes from the "isindex"
2057	token, except with the "name" attribute set to the value
2058	"isindex" (ignoring any explicit "name" attribute). */
2059	$attr = $token['attr'];
2060	$attr[] = array('name' => 'name', 'value' => 'isindex');
2061
2062	$this->inBody(array(
2063	'name' => 'input',
2064	'type' => HTML5::STARTTAG,
2065	'attr' => $attr
2066	));
2067
2068	/* Act as if a stream of character tokens had been seen
2069	(see below for what they should say). */
2070	$this->insertText('This is a searchable index. '.
2071	'Insert your search keywords here: ');
2072
2073	/* Act as if an end tag token with the tag name "label"
2074	had been seen. */
2075	$this->inBody(array(
2076	'name' => 'label',
2077	'type' => HTML5::ENDTAG
2078	));
2079
2080	/* Act as if an end tag token with the tag name "p" had
2081	been seen. */
2082	$this->inBody(array(
2083	'name' => 'p',
2084	'type' => HTML5::ENDTAG
2085	));
2086
2087	/* Act as if a start tag token with the tag name "hr" had
2088	been seen. */
2089	$this->inBody(array(
2090	'name' => 'hr',
2091	'type' => HTML5::ENDTAG
2092	));
2093
2094	/* Act as if an end tag token with the tag name "form" had
2095	been seen. */
2096	$this->inBody(array(
2097	'name' => 'form',
2098	'type' => HTML5::ENDTAG
2099	));
2100	}
2101	break;
2102
2103	/* A start tag whose tag name is "textarea" */
2104	case 'textarea':
2105	$this->insertElement($token);
2106
2107	/* Switch the tokeniser's content model flag to the
2108	RCDATA state. */
2109	return HTML5::RCDATA;
2110	break;
2111
2112	/* A start tag whose tag name is one of: "iframe", "noembed",
2113	"noframes" */
2114	case 'iframe': case 'noembed': case 'noframes':
2115	$this->insertElement($token);
2116
2117	/* Switch the tokeniser's content model flag to the CDATA state. */
2118	return HTML5::CDATA;
2119	break;
2120
2121	/* A start tag whose tag name is "select" */
2122	case 'select':
2123	/* Reconstruct the active formatting elements, if any. */
2124	$this->reconstructActiveFormattingElements();
2125
2126	/* Insert an HTML element for the token. */
2127	$this->insertElement($token);
2128
2129	/* Change the insertion mode to "in select". */
2130	$this->mode = self::IN_SELECT;
2131	break;
2132
2133	/* A start or end tag whose tag name is one of: "caption", "col",
2134	"colgroup", "frame", "frameset", "head", "option", "optgroup",
2135	"tbody", "td", "tfoot", "th", "thead", "tr". */
2136	case 'caption': case 'col': case 'colgroup': case 'frame':
2137	case 'frameset': case 'head': case 'option': case 'optgroup':
2138	case 'tbody': case 'td': case 'tfoot': case 'th': case 'thead':
2139	case 'tr':
2140	// Parse error. Ignore the token.
2141	break;
2142
2143	/* A start or end tag whose tag name is one of: "event-source",
2144	"section", "nav", "article", "aside", "header", "footer",
2145	"datagrid", "command" */
2146	case 'event-source': case 'section': case 'nav': case 'article':
2147	case 'aside': case 'header': case 'footer': case 'datagrid':
2148	case 'command':
2149	// Work in progress!
2150	break;
2151
2152	/* A start tag token not covered by the previous entries */
2153	default:
2154	/* Reconstruct the active formatting elements, if any. */
2155	$this->reconstructActiveFormattingElements();
2156
2157	$this->insertElement($token, true, true);
2158	break;
2159	}
2160	break;
2161
2162	case HTML5::ENDTAG:
2163	switch($token['name']) {
2164	/* An end tag with the tag name "body" */
2165	case 'body':
2166	/* If the second element in the stack of open elements is
2167	not a body element, this is a parse error. Ignore the token.
2168	(innerHTML case) */
2169	if(count($this->stack) < 2 \|\| $this->stack[1]->nodeName !== 'body') {
2170	// Ignore.
2171
2172	/* If the current node is not the body element, then this
2173	is a parse error. */
2174	} elseif(end($this->stack)->nodeName !== 'body') {
2175	// Parse error.
2176	}
2177
2178	/* Change the insertion mode to "after body". */
2179	$this->mode = self::AFTER_BODY;
2180	break;
2181
2182	/* An end tag with the tag name "html" */
2183	case 'html':
2184	/* Act as if an end tag with tag name "body" had been seen,
2185	then, if that token wasn't ignored, reprocess the current
2186	token. */
2187	$this->inBody(array(
2188	'name' => 'body',
2189	'type' => HTML5::ENDTAG
2190	));
2191
2192	return $this->afterBody($token);
2193	break;
2194
2195	/* An end tag whose tag name is one of: "address", "blockquote",
2196	"center", "dir", "div", "dl", "fieldset", "listing", "menu",
2197	"ol", "pre", "ul" */
2198	case 'address': case 'blockquote': case 'center': case 'dir':
2199	case 'div': case 'dl': case 'fieldset': case 'listing':
2200	case 'menu': case 'ol': case 'pre': case 'ul':
2201	/* If the stack of open elements has an element in scope
2202	with the same tag name as that of the token, then generate
2203	implied end tags. */
2204	if($this->elementInScope($token['name'])) {
2205	$this->generateImpliedEndTags();
2206
2207	/* Now, if the current node is not an element with
2208	the same tag name as that of the token, then this
2209	is a parse error. */
2210	// w/e
2211
2212	/* If the stack of open elements has an element in
2213	scope with the same tag name as that of the token,
2214	then pop elements from this stack until an element
2215	with that tag name has been popped from the stack. */
2216	for($n = count($this->stack) - 1; $n >= 0; $n--) {
2217	if($this->stack[$n]->nodeName === $token['name']) {
2218	$n = -1;
2219	}
2220
2221	array_pop($this->stack);
2222	}
2223	}
2224	break;
2225
2226	/* An end tag whose tag name is "form" */
2227	case 'form':
2228	/* If the stack of open elements has an element in scope
2229	with the same tag name as that of the token, then generate
2230	implied end tags. */
2231	if($this->elementInScope($token['name'])) {
2232	$this->generateImpliedEndTags();
2233
2234	}
2235
2236	if(end($this->stack)->nodeName !== $token['name']) {
2237	/* Now, if the current node is not an element with the
2238	same tag name as that of the token, then this is a parse
2239	error. */
2240	// w/e
2241
2242	} else {
2243	/* Otherwise, if the current node is an element with
2244	the same tag name as that of the token pop that element
2245	from the stack. */
2246	array_pop($this->stack);
2247	}
2248
2249	/* In any case, set the form element pointer to null. */
2250	$this->form_pointer = null;
2251	break;
2252
2253	/* An end tag whose tag name is "p" */
2254	case 'p':
2255	/* If the stack of open elements has a p element in scope,
2256	then generate implied end tags, except for p elements. */
2257	if($this->elementInScope('p')) {
2258	$this->generateImpliedEndTags(array('p'));
2259
2260	/* If the current node is not a p element, then this is
2261	a parse error. */
2262	// k
2263
2264	/* If the stack of open elements has a p element in
2265	scope, then pop elements from this stack until the stack
2266	no longer has a p element in scope. */
2267	for($n = count($this->stack) - 1; $n >= 0; $n--) {
2268	if($this->elementInScope('p')) {
2269	array_pop($this->stack);
2270
2271	} else {
2272	break;
2273	}
2274	}
2275	}
2276	break;
2277
2278	/* An end tag whose tag name is "dd", "dt", or "li" */
2279	case 'dd': case 'dt': case 'li':
2280	/* If the stack of open elements has an element in scope
2281	whose tag name matches the tag name of the token, then
2282	generate implied end tags, except for elements with the
2283	same tag name as the token. */
2284	if($this->elementInScope($token['name'])) {
2285	$this->generateImpliedEndTags(array($token['name']));
2286
2287	/* If the current node is not an element with the same
2288	tag name as the token, then this is a parse error. */
2289	// w/e
2290
2291	/* If the stack of open elements has an element in scope
2292	whose tag name matches the tag name of the token, then
2293	pop elements from this stack until an element with that
2294	tag name has been popped from the stack. */
2295	for($n = count($this->stack) - 1; $n >= 0; $n--) {
2296	if($this->stack[$n]->nodeName === $token['name']) {
2297	$n = -1;
2298	}
2299
2300	array_pop($this->stack);
2301	}
2302	}
2303	break;
2304
2305	/* An end tag whose tag name is one of: "h1", "h2", "h3", "h4",
2306	"h5", "h6" */
2307	case 'h1': case 'h2': case 'h3': case 'h4': case 'h5': case 'h6':
2308	$elements = array('h1', 'h2', 'h3', 'h4', 'h5', 'h6');
2309
2310	/* If the stack of open elements has in scope an element whose
2311	tag name is one of "h1", "h2", "h3", "h4", "h5", or "h6", then
2312	generate implied end tags. */
2313	if($this->elementInScope($elements)) {
2314	$this->generateImpliedEndTags();
2315
2316	/* Now, if the current node is not an element with the same
2317	tag name as that of the token, then this is a parse error. */
2318	// w/e
2319
2320	/* If the stack of open elements has in scope an element
2321	whose tag name is one of "h1", "h2", "h3", "h4", "h5", or
2322	"h6", then pop elements from the stack until an element
2323	with one of those tag names has been popped from the stack. */
2324	while($this->elementInScope($elements)) {
2325	array_pop($this->stack);
2326	}
2327	}
2328	break;
2329
2330	/* An end tag whose tag name is one of: "a", "b", "big", "em",
2331	"font", "i", "nobr", "s", "small", "strike", "strong", "tt", "u" */
2332	case 'a': case 'b': case 'big': case 'em': case 'font':
2333	case 'i': case 'nobr': case 's': case 'small': case 'strike':
2334	case 'strong': case 'tt': case 'u':
2335	/* 1. Let the formatting element be the last element in
2336	the list of active formatting elements that:
2337	* is between the end of the list and the last scope
2338	marker in the list, if any, or the start of the list
2339	otherwise, and
2340	* has the same tag name as the token.
2341	*/
2342	while(true) {
2343	for($a = count($this->a_formatting) - 1; $a >= 0; $a--) {
2344	if($this->a_formatting[$a] === self::MARKER) {
2345	break;
2346
2347	} elseif($this->a_formatting[$a]->tagName === $token['name']) {
2348	$formatting_element = $this->a_formatting[$a];
2349	$in_stack = in_array($formatting_element, $this->stack, true);
2350	$fe_af_pos = $a;
2351	break;
2352	}
2353	}
2354
2355	/* If there is no such node, or, if that node is
2356	also in the stack of open elements but the element
2357	is not in scope, then this is a parse error. Abort
2358	these steps. The token is ignored. */
2359	if(!isset($formatting_element) \|\| ($in_stack &&
2360	!$this->elementInScope($token['name']))) {
2361	break;
2362
2363	/* Otherwise, if there is such a node, but that node
2364	is not in the stack of open elements, then this is a
2365	parse error; remove the element from the list, and
2366	abort these steps. */
2367	} elseif(isset($formatting_element) && !$in_stack) {
2368	unset($this->a_formatting[$fe_af_pos]);
2369	$this->a_formatting = array_merge($this->a_formatting);
2370	break;
2371	}
2372
2373	/* 2. Let the furthest block be the topmost node in the
2374	stack of open elements that is lower in the stack
2375	than the formatting element, and is not an element in
2376	the phrasing or formatting categories. There might
2377	not be one. */
2378	$fe_s_pos = array_search($formatting_element, $this->stack, true);
2379	$length = count($this->stack);
2380
2381	for($s = $fe_s_pos + 1; $s < $length; $s++) {
2382	$category = $this->getElementCategory($this->stack[$s]->nodeName);
2383
2384	if($category !== self::PHRASING && $category !== self::FORMATTING) {
2385	$furthest_block = $this->stack[$s];
2386	}
2387	}
2388
2389	/* 3. If there is no furthest block, then the UA must
2390	skip the subsequent steps and instead just pop all
2391	the nodes from the bottom of the stack of open
2392	elements, from the current node up to the formatting
2393	element, and remove the formatting element from the
2394	list of active formatting elements. */
2395	if(!isset($furthest_block)) {
2396	for($n = $length - 1; $n >= $fe_s_pos; $n--) {
2397	array_pop($this->stack);
2398	}
2399
2400	unset($this->a_formatting[$fe_af_pos]);
2401	$this->a_formatting = array_merge($this->a_formatting);
2402	break;
2403	}
2404
2405	/* 4. Let the common ancestor be the element
2406	immediately above the formatting element in the stack
2407	of open elements. */
2408	$common_ancestor = $this->stack[$fe_s_pos - 1];
2409
2410	/* 5. If the furthest block has a parent node, then
2411	remove the furthest block from its parent node. */
2412	if($furthest_block->parentNode !== null) {
2413	$furthest_block->parentNode->removeChild($furthest_block);
2414	}
2415
2416	/* 6. Let a bookmark note the position of the
2417	formatting element in the list of active formatting
2418	elements relative to the elements on either side
2419	of it in the list. */
2420	$bookmark = $fe_af_pos;
2421
2422	/* 7. Let node and last node be the furthest block.
2423	Follow these steps: */
2424	$node = $furthest_block;
2425	$last_node = $furthest_block;
2426
2427	while(true) {
2428	for($n = array_search($node, $this->stack, true) - 1; $n >= 0; $n--) {
2429	/* 7.1 Let node be the element immediately
2430	prior to node in the stack of open elements. */
2431	$node = $this->stack[$n];
2432
2433	/* 7.2 If node is not in the list of active
2434	formatting elements, then remove node from
2435	the stack of open elements and then go back
2436	to step 1. */
2437	if(!in_array($node, $this->a_formatting, true)) {
2438	unset($this->stack[$n]);
2439	$this->stack = array_merge($this->stack);
2440
2441	} else {
2442	break;
2443	}
2444	}
2445
2446	/* 7.3 Otherwise, if node is the formatting
2447	element, then go to the next step in the overall
2448	algorithm. */
2449	if($node === $formatting_element) {
2450	break;
2451
2452	/* 7.4 Otherwise, if last node is the furthest
2453	block, then move the aforementioned bookmark to
2454	be immediately after the node in the list of
2455	active formatting elements. */
2456	} elseif($last_node === $furthest_block) {
2457	$bookmark = array_search($node, $this->a_formatting, true) + 1;
2458	}
2459
2460	/* 7.5 If node has any children, perform a
2461	shallow clone of node, replace the entry for
2462	node in the list of active formatting elements
2463	with an entry for the clone, replace the entry
2464	for node in the stack of open elements with an
2465	entry for the clone, and let node be the clone. */
2466	if($node->hasChildNodes()) {
2467	$clone = $node->cloneNode();
2468	$s_pos = array_search($node, $this->stack, true);
2469	$a_pos = array_search($node, $this->a_formatting, true);
2470
2471	$this->stack[$s_pos] = $clone;
2472	$this->a_formatting[$a_pos] = $clone;
2473	$node = $clone;
2474	}
2475
2476	/* 7.6 Insert last node into node, first removing
2477	it from its previous parent node if any. */
2478	if($last_node->parentNode !== null) {
2479	$last_node->parentNode->removeChild($last_node);
2480	}
2481
2482	$node->appendChild($last_node);
2483
2484	/* 7.7 Let last node be node. */
2485	$last_node = $node;
2486	}
2487
2488	/* 8. Insert whatever last node ended up being in
2489	the previous step into the common ancestor node,
2490	first removing it from its previous parent node if
2491	any. */
2492	if($last_node->parentNode !== null) {
2493	$last_node->parentNode->removeChild($last_node);
2494	}
2495
2496	$common_ancestor->appendChild($last_node);
2497
2498	/* 9. Perform a shallow clone of the formatting
2499	element. */
2500	$clone = $formatting_element->cloneNode();
2501
2502	/* 10. Take all of the child nodes of the furthest
2503	block and append them to the clone created in the
2504	last step. */
2505	while($furthest_block->hasChildNodes()) {
2506	$child = $furthest_block->firstChild;
2507	$furthest_block->removeChild($child);
2508	$clone->appendChild($child);
2509	}
2510
2511	/* 11. Append that clone to the furthest block. */
2512	$furthest_block->appendChild($clone);
2513
2514	/* 12. Remove the formatting element from the list
2515	of active formatting elements, and insert the clone
2516	into the list of active formatting elements at the
2517	position of the aforementioned bookmark. */
2518	$fe_af_pos = array_search($formatting_element, $this->a_formatting, true);
2519	unset($this->a_formatting[$fe_af_pos]);
2520	$this->a_formatting = array_merge($this->a_formatting);
2521
2522	$af_part1 = array_slice($this->a_formatting, 0, $bookmark - 1);
2523	$af_part2 = array_slice($this->a_formatting, $bookmark, count($this->a_formatting));
2524	$this->a_formatting = array_merge($af_part1, array($clone), $af_part2);
2525
2526	/* 13. Remove the formatting element from the stack
2527	of open elements, and insert the clone into the stack
2528	of open elements immediately after (i.e. in a more
2529	deeply nested position than) the position of the
2530	furthest block in that stack. */
2531	$fe_s_pos = array_search($formatting_element, $this->stack, true);
2532	$fb_s_pos = array_search($furthest_block, $this->stack, true);
2533	unset($this->stack[$fe_s_pos]);
2534
2535	$s_part1 = array_slice($this->stack, 0, $fb_s_pos);
2536	$s_part2 = array_slice($this->stack, $fb_s_pos + 1, count($this->stack));
2537	$this->stack = array_merge($s_part1, array($clone), $s_part2);
2538
2539	/* 14. Jump back to step 1 in this series of steps. */
2540	unset($formatting_element, $fe_af_pos, $fe_s_pos, $furthest_block);
2541	}
2542	break;
2543
2544	/* An end tag token whose tag name is one of: "button",
2545	"marquee", "object" */
2546	case 'button': case 'marquee': case 'object':
2547	/* If the stack of open elements has an element in scope whose
2548	tag name matches the tag name of the token, then generate implied
2549	tags. */
2550	if($this->elementInScope($token['name'])) {
2551	$this->generateImpliedEndTags();
2552
2553	/* Now, if the current node is not an element with the same
2554	tag name as the token, then this is a parse error. */
2555	// k
2556
2557	/* Now, if the stack of open elements has an element in scope
2558	whose tag name matches the tag name of the token, then pop
2559	elements from the stack until that element has been popped from
2560	the stack, and clear the list of active formatting elements up
2561	to the last marker. */
2562	for($n = count($this->stack) - 1; $n >= 0; $n--) {
2563	if($this->stack[$n]->nodeName === $token['name']) {
2564	$n = -1;
2565	}
2566
2567	array_pop($this->stack);
2568	}
2569
2570	$marker = end(array_keys($this->a_formatting, self::MARKER, true));
2571
2572	for($n = count($this->a_formatting) - 1; $n > $marker; $n--) {
2573	array_pop($this->a_formatting);
2574	}
2575	}
2576	break;
2577
2578	/* Or an end tag whose tag name is one of: "area", "basefont",
2579	"bgsound", "br", "embed", "hr", "iframe", "image", "img",
2580	"input", "isindex", "noembed", "noframes", "param", "select",
2581	"spacer", "table", "textarea", "wbr" */
2582	case 'area': case 'basefont': case 'bgsound': case 'br':
2583	case 'embed': case 'hr': case 'iframe': case 'image':
2584	case 'img': case 'input': case 'isindex': case 'noembed':
2585	case 'noframes': case 'param': case 'select': case 'spacer':
2586	case 'table': case 'textarea': case 'wbr':
2587	// Parse error. Ignore the token.
2588	break;
2589
2590	/* An end tag token not covered by the previous entries */
2591	default:
2592	for($n = count($this->stack) - 1; $n >= 0; $n--) {
2593	/* Initialise node to be the current node (the bottommost
2594	node of the stack). */
2595	$node = end($this->stack);
2596
2597	/* If node has the same tag name as the end tag token,
2598	then: */
2599	if($token['name'] === $node->nodeName) {
2600	/* Generate implied end tags. */
2601	$this->generateImpliedEndTags();
2602
2603	/* If the tag name of the end tag token does not
2604	match the tag name of the current node, this is a
2605	parse error. */
2606	// k
2607
2608	/* Pop all the nodes from the current node up to
2609	node, including node, then stop this algorithm. */
2610	for($x = count($this->stack) - $n; $x >= $n; $x--) {
2611	array_pop($this->stack);
2612	}
2613
2614	} else {
2615	$category = $this->getElementCategory($node);
2616
2617	if($category !== self::SPECIAL && $category !== self::SCOPING) {
2618	/* Otherwise, if node is in neither the formatting
2619	category nor the phrasing category, then this is a
2620	parse error. Stop this algorithm. The end tag token
2621	is ignored. */
2622	return false;
2623	}
2624	}
2625	}
2626	break;
2627	}
2628	break;
2629	}
2630	}
2631
2632	private function inTable($token) {
2633	$clear = array('html', 'table');
2634
2635	/* A character token that is one of one of U+0009 CHARACTER TABULATION,
2636	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
2637	or U+0020 SPACE */
2638	if($token['type'] === HTML5::CHARACTR &&
2639	preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
2640	/* Append the character to the current node. */
2641	$text = $this->dom->createTextNode($token['data']);
2642	end($this->stack)->appendChild($text);
2643
2644	/* A comment token */
2645	} elseif($token['type'] === HTML5::COMMENT) {
2646	/* Append a Comment node to the current node with the data
2647	attribute set to the data given in the comment token. */
2648	$comment = $this->dom->createComment($token['data']);
2649	end($this->stack)->appendChild($comment);
2650
2651	/* A start tag whose tag name is "caption" */
2652	} elseif($token['type'] === HTML5::STARTTAG &&
2653	$token['name'] === 'caption') {
2654	/* Clear the stack back to a table context. */
2655	$this->clearStackToTableContext($clear);
2656
2657	/* Insert a marker at the end of the list of active
2658	formatting elements. */
2659	$this->a_formatting[] = self::MARKER;
2660
2661	/* Insert an HTML element for the token, then switch the
2662	insertion mode to "in caption". */
2663	$this->insertElement($token);
2664	$this->mode = self::IN_CAPTION;
2665
2666	/* A start tag whose tag name is "colgroup" */
2667	} elseif($token['type'] === HTML5::STARTTAG &&
2668	$token['name'] === 'colgroup') {
2669	/* Clear the stack back to a table context. */
2670	$this->clearStackToTableContext($clear);
2671
2672	/* Insert an HTML element for the token, then switch the
2673	insertion mode to "in column group". */
2674	$this->insertElement($token);
2675	$this->mode = self::IN_CGROUP;
2676
2677	/* A start tag whose tag name is "col" */
2678	} elseif($token['type'] === HTML5::STARTTAG &&
2679	$token['name'] === 'col') {
2680	$this->inTable(array(
2681	'name' => 'colgroup',
2682	'type' => HTML5::STARTTAG,
2683	'attr' => array()
2684	));
2685
2686	$this->inColumnGroup($token);
2687
2688	/* A start tag whose tag name is one of: "tbody", "tfoot", "thead" */
2689	} elseif($token['type'] === HTML5::STARTTAG && in_array($token['name'],
2690	array('tbody', 'tfoot', 'thead'))) {
2691	/* Clear the stack back to a table context. */
2692	$this->clearStackToTableContext($clear);
2693
2694	/* Insert an HTML element for the token, then switch the insertion
2695	mode to "in table body". */
2696	$this->insertElement($token);
2697	$this->mode = self::IN_TBODY;
2698
2699	/* A start tag whose tag name is one of: "td", "th", "tr" */
2700	} elseif($token['type'] === HTML5::STARTTAG &&
2701	in_array($token['name'], array('td', 'th', 'tr'))) {
2702	/* Act as if a start tag token with the tag name "tbody" had been
2703	seen, then reprocess the current token. */
2704	$this->inTable(array(
2705	'name' => 'tbody',
2706	'type' => HTML5::STARTTAG,
2707	'attr' => array()
2708	));
2709
2710	return $this->inTableBody($token);
2711
2712	/* A start tag whose tag name is "table" */
2713	} elseif($token['type'] === HTML5::STARTTAG &&
2714	$token['name'] === 'table') {
2715	/* Parse error. Act as if an end tag token with the tag name "table"
2716	had been seen, then, if that token wasn't ignored, reprocess the
2717	current token. */
2718	$this->inTable(array(
2719	'name' => 'table',
2720	'type' => HTML5::ENDTAG
2721	));
2722
2723	return $this->mainPhase($token);
2724
2725	/* An end tag whose tag name is "table" */
2726	} elseif($token['type'] === HTML5::ENDTAG &&
2727	$token['name'] === 'table') {
2728	/* If the stack of open elements does not have an element in table
2729	scope with the same tag name as the token, this is a parse error.
2730	Ignore the token. (innerHTML case) */
2731	if(!$this->elementInScope($token['name'], true)) {
2732	return false;
2733
2734	/* Otherwise: */
2735	} else {
2736	/* Generate implied end tags. */
2737	$this->generateImpliedEndTags();
2738
2739	/* Now, if the current node is not a table element, then this
2740	is a parse error. */
2741	// w/e
2742
2743	/* Pop elements from this stack until a table element has been
2744	popped from the stack. */
2745	while(true) {
2746	$current = end($this->stack)->nodeName;
2747	array_pop($this->stack);
2748
2749	if($current === 'table') {
2750	break;
2751	}
2752	}
2753
2754	/* Reset the insertion mode appropriately. */
2755	$this->resetInsertionMode();
2756	}
2757
2758	/* An end tag whose tag name is one of: "body", "caption", "col",
2759	"colgroup", "html", "tbody", "td", "tfoot", "th", "thead", "tr" */
2760	} elseif($token['type'] === HTML5::ENDTAG && in_array($token['name'],
2761	array('body', 'caption', 'col', 'colgroup', 'html', 'tbody', 'td',
2762	'tfoot', 'th', 'thead', 'tr'))) {
2763	// Parse error. Ignore the token.
2764
2765	/* Anything else */
2766	} else {
2767	/* Parse error. Process the token as if the insertion mode was "in
2768	body", with the following exception: */
2769
2770	/* If the current node is a table, tbody, tfoot, thead, or tr
2771	element, then, whenever a node would be inserted into the current
2772	node, it must instead be inserted into the foster parent element. */
2773	if(in_array(end($this->stack)->nodeName,
2774	array('table', 'tbody', 'tfoot', 'thead', 'tr'))) {
2775	/* The foster parent element is the parent element of the last
2776	table element in the stack of open elements, if there is a
2777	table element and it has such a parent element. If there is no
2778	table element in the stack of open elements (innerHTML case),
2779	then the foster parent element is the first element in the
2780	stack of open elements (the html element). Otherwise, if there
2781	is a table element in the stack of open elements, but the last
2782	table element in the stack of open elements has no parent, or
2783	its parent node is not an element, then the foster parent
2784	element is the element before the last table element in the
2785	stack of open elements. */
2786	for($n = count($this->stack) - 1; $n >= 0; $n--) {
2787	if($this->stack[$n]->nodeName === 'table') {
2788	$table = $this->stack[$n];
2789	break;
2790	}
2791	}
2792
2793	if(isset($table) && $table->parentNode !== null) {
2794	$this->foster_parent = $table->parentNode;
2795
2796	} elseif(!isset($table)) {
2797	$this->foster_parent = $this->stack[0];
2798
2799	} elseif(isset($table) && ($table->parentNode === null \|\|
2800	$table->parentNode->nodeType !== XML_ELEMENT_NODE)) {
2801	$this->foster_parent = $this->stack[$n - 1];
2802	}
2803	}
2804
2805	$this->inBody($token);
2806	}
2807	}
2808
2809	private function inCaption($token) {
2810	/* An end tag whose tag name is "caption" */
2811	if($token['type'] === HTML5::ENDTAG && $token['name'] === 'caption') {
2812	/* If the stack of open elements does not have an element in table
2813	scope with the same tag name as the token, this is a parse error.
2814	Ignore the token. (innerHTML case) */
2815	if(!$this->elementInScope($token['name'], true)) {
2816	// Ignore
2817
2818	/* Otherwise: */
2819	} else {
2820	/* Generate implied end tags. */
2821	$this->generateImpliedEndTags();
2822
2823	/* Now, if the current node is not a caption element, then this
2824	is a parse error. */
2825	// w/e
2826
2827	/* Pop elements from this stack until a caption element has
2828	been popped from the stack. */
2829	while(true) {
2830	$node = end($this->stack)->nodeName;
2831	array_pop($this->stack);
2832
2833	if($node === 'caption') {
2834	break;
2835	}
2836	}
2837
2838	/* Clear the list of active formatting elements up to the last
2839	marker. */
2840	$this->clearTheActiveFormattingElementsUpToTheLastMarker();
2841
2842	/* Switch the insertion mode to "in table". */
2843	$this->mode = self::IN_TABLE;
2844	}
2845
2846	/* A start tag whose tag name is one of: "caption", "col", "colgroup",
2847	"tbody", "td", "tfoot", "th", "thead", "tr", or an end tag whose tag
2848	name is "table" */
2849	} elseif(($token['type'] === HTML5::STARTTAG && in_array($token['name'],
2850	array('caption', 'col', 'colgroup', 'tbody', 'td', 'tfoot', 'th',
2851	'thead', 'tr'))) \|\| ($token['type'] === HTML5::ENDTAG &&
2852	$token['name'] === 'table')) {
2853	/* Parse error. Act as if an end tag with the tag name "caption"
2854	had been seen, then, if that token wasn't ignored, reprocess the
2855	current token. */
2856	$this->inCaption(array(
2857	'name' => 'caption',
2858	'type' => HTML5::ENDTAG
2859	));
2860
2861	return $this->inTable($token);
2862
2863	/* An end tag whose tag name is one of: "body", "col", "colgroup",
2864	"html", "tbody", "td", "tfoot", "th", "thead", "tr" */
2865	} elseif($token['type'] === HTML5::ENDTAG && in_array($token['name'],
2866	array('body', 'col', 'colgroup', 'html', 'tbody', 'tfoot', 'th',
2867	'thead', 'tr'))) {
2868	// Parse error. Ignore the token.
2869
2870	/* Anything else */
2871	} else {
2872	/* Process the token as if the insertion mode was "in body". */
2873	$this->inBody($token);
2874	}
2875	}
2876
2877	private function inColumnGroup($token) {
2878	/* A character token that is one of one of U+0009 CHARACTER TABULATION,
2879	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
2880	or U+0020 SPACE */
2881	if($token['type'] === HTML5::CHARACTR &&
2882	preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
2883	/* Append the character to the current node. */
2884	$text = $this->dom->createTextNode($token['data']);
2885	end($this->stack)->appendChild($text);
2886
2887	/* A comment token */
2888	} elseif($token['type'] === HTML5::COMMENT) {
2889	/* Append a Comment node to the current node with the data
2890	attribute set to the data given in the comment token. */
2891	$comment = $this->dom->createComment($token['data']);
2892	end($this->stack)->appendChild($comment);
2893
2894	/* A start tag whose tag name is "col" */
2895	} elseif($token['type'] === HTML5::STARTTAG && $token['name'] === 'col') {
2896	/* Insert a col element for the token. Immediately pop the current
2897	node off the stack of open elements. */
2898	$this->insertElement($token);
2899	array_pop($this->stack);
2900
2901	/* An end tag whose tag name is "colgroup" */
2902	} elseif($token['type'] === HTML5::ENDTAG &&
2903	$token['name'] === 'colgroup') {
2904	/* If the current node is the root html element, then this is a
2905	parse error, ignore the token. (innerHTML case) */
2906	if(end($this->stack)->nodeName === 'html') {
2907	// Ignore
2908
2909	/* Otherwise, pop the current node (which will be a colgroup
2910	element) from the stack of open elements. Switch the insertion
2911	mode to "in table". */
2912	} else {
2913	array_pop($this->stack);
2914	$this->mode = self::IN_TABLE;
2915	}
2916
2917	/* An end tag whose tag name is "col" */
2918	} elseif($token['type'] === HTML5::ENDTAG && $token['name'] === 'col') {
2919	/* Parse error. Ignore the token. */
2920
2921	/* Anything else */
2922	} else {
2923	/* Act as if an end tag with the tag name "colgroup" had been seen,
2924	and then, if that token wasn't ignored, reprocess the current token. */
2925	$this->inColumnGroup(array(
2926	'name' => 'colgroup',
2927	'type' => HTML5::ENDTAG
2928	));
2929
2930	return $this->inTable($token);
2931	}
2932	}
2933
2934	private function inTableBody($token) {
2935	$clear = array('tbody', 'tfoot', 'thead', 'html');
2936
2937	/* A start tag whose tag name is "tr" */
2938	if($token['type'] === HTML5::STARTTAG && $token['name'] === 'tr') {
2939	/* Clear the stack back to a table body context. */
2940	$this->clearStackToTableContext($clear);
2941
2942	/* Insert a tr element for the token, then switch the insertion
2943	mode to "in row". */
2944	$this->insertElement($token);
2945	$this->mode = self::IN_ROW;
2946
2947	/* A start tag whose tag name is one of: "th", "td" */
2948	} elseif($token['type'] === HTML5::STARTTAG &&
2949	($token['name'] === 'th' \|\| $token['name'] === 'td')) {
2950	/* Parse error. Act as if a start tag with the tag name "tr" had
2951	been seen, then reprocess the current token. */
2952	$this->inTableBody(array(
2953	'name' => 'tr',
2954	'type' => HTML5::STARTTAG,
2955	'attr' => array()
2956	));
2957
2958	return $this->inRow($token);
2959
2960	/* An end tag whose tag name is one of: "tbody", "tfoot", "thead" */
2961	} elseif($token['type'] === HTML5::ENDTAG &&
2962	in_array($token['name'], array('tbody', 'tfoot', 'thead'))) {
2963	/* If the stack of open elements does not have an element in table
2964	scope with the same tag name as the token, this is a parse error.
2965	Ignore the token. */
2966	if(!$this->elementInScope($token['name'], true)) {
2967	// Ignore
2968
2969	/* Otherwise: */
2970	} else {
2971	/* Clear the stack back to a table body context. */
2972	$this->clearStackToTableContext($clear);
2973
2974	/* Pop the current node from the stack of open elements. Switch
2975	the insertion mode to "in table". */
2976	array_pop($this->stack);
2977	$this->mode = self::IN_TABLE;
2978	}
2979
2980	/* A start tag whose tag name is one of: "caption", "col", "colgroup",
2981	"tbody", "tfoot", "thead", or an end tag whose tag name is "table" */
2982	} elseif(($token['type'] === HTML5::STARTTAG && in_array($token['name'],
2983	array('caption', 'col', 'colgroup', 'tbody', 'tfoor', 'thead'))) \|\|
2984	($token['type'] === HTML5::STARTTAG && $token['name'] === 'table')) {
2985	/* If the stack of open elements does not have a tbody, thead, or
2986	tfoot element in table scope, this is a parse error. Ignore the
2987	token. (innerHTML case) */
2988	if(!$this->elementInScope(array('tbody', 'thead', 'tfoot'), true)) {
2989	// Ignore.
2990
2991	/* Otherwise: */
2992	} else {
2993	/* Clear the stack back to a table body context. */
2994	$this->clearStackToTableContext($clear);
2995
2996	/* Act as if an end tag with the same tag name as the current
2997	node ("tbody", "tfoot", or "thead") had been seen, then
2998	reprocess the current token. */
2999	$this->inTableBody(array(
3000	'name' => end($this->stack)->nodeName,
3001	'type' => HTML5::ENDTAG
3002	));
3003
3004	return $this->mainPhase($token);
3005	}
3006
3007	/* An end tag whose tag name is one of: "body", "caption", "col",
3008	"colgroup", "html", "td", "th", "tr" */
3009	} elseif($token['type'] === HTML5::ENDTAG && in_array($token['name'],
3010	array('body', 'caption', 'col', 'colgroup', 'html', 'td', 'th', 'tr'))) {
3011	/* Parse error. Ignore the token. */
3012
3013	/* Anything else */
3014	} else {
3015	/* Process the token as if the insertion mode was "in table". */
3016	$this->inTable($token);
3017	}
3018	}
3019
3020	private function inRow($token) {
3021	$clear = array('tr', 'html');
3022
3023	/* A start tag whose tag name is one of: "th", "td" */
3024	if($token['type'] === HTML5::STARTTAG &&
3025	($token['name'] === 'th' \|\| $token['name'] === 'td')) {
3026	/* Clear the stack back to a table row context. */
3027	$this->clearStackToTableContext($clear);
3028
3029	/* Insert an HTML element for the token, then switch the insertion
3030	mode to "in cell". */
3031	$this->insertElement($token);
3032	$this->mode = self::IN_CELL;
3033
3034	/* Insert a marker at the end of the list of active formatting
3035	elements. */
3036	$this->a_formatting[] = self::MARKER;
3037
3038	/* An end tag whose tag name is "tr" */
3039	} elseif($token['type'] === HTML5::ENDTAG && $token['name'] === 'tr') {
3040	/* If the stack of open elements does not have an element in table
3041	scope with the same tag name as the token, this is a parse error.
3042	Ignore the token. (innerHTML case) */
3043	if(!$this->elementInScope($token['name'], true)) {
3044	// Ignore.
3045
3046	/* Otherwise: */
3047	} else {
3048	/* Clear the stack back to a table row context. */
3049	$this->clearStackToTableContext($clear);
3050
3051	/* Pop the current node (which will be a tr element) from the
3052	stack of open elements. Switch the insertion mode to "in table
3053	body". */
3054	array_pop($this->stack);
3055	$this->mode = self::IN_TBODY;
3056	}
3057
3058	/* A start tag whose tag name is one of: "caption", "col", "colgroup",
3059	"tbody", "tfoot", "thead", "tr" or an end tag whose tag name is "table" */
3060	} elseif($token['type'] === HTML5::STARTTAG && in_array($token['name'],
3061	array('caption', 'col', 'colgroup', 'tbody', 'tfoot', 'thead', 'tr'))) {
3062	/* Act as if an end tag with the tag name "tr" had been seen, then,
3063	if that token wasn't ignored, reprocess the current token. */
3064	$this->inRow(array(
3065	'name' => 'tr',
3066	'type' => HTML5::ENDTAG
3067	));
3068
3069	return $this->inCell($token);
3070
3071	/* An end tag whose tag name is one of: "tbody", "tfoot", "thead" */
3072	} elseif($token['type'] === HTML5::ENDTAG &&
3073	in_array($token['name'], array('tbody', 'tfoot', 'thead'))) {
3074	/* If the stack of open elements does not have an element in table
3075	scope with the same tag name as the token, this is a parse error.
3076	Ignore the token. */
3077	if(!$this->elementInScope($token['name'], true)) {
3078	// Ignore.
3079
3080	/* Otherwise: */
3081	} else {
3082	/* Otherwise, act as if an end tag with the tag name "tr" had
3083	been seen, then reprocess the current token. */
3084	$this->inRow(array(
3085	'name' => 'tr',
3086	'type' => HTML5::ENDTAG
3087	));
3088
3089	return $this->inCell($token);
3090	}
3091
3092	/* An end tag whose tag name is one of: "body", "caption", "col",
3093	"colgroup", "html", "td", "th" */
3094	} elseif($token['type'] === HTML5::ENDTAG && in_array($token['name'],
3095	array('body', 'caption', 'col', 'colgroup', 'html', 'td', 'th', 'tr'))) {
3096	/* Parse error. Ignore the token. */
3097
3098	/* Anything else */
3099	} else {
3100	/* Process the token as if the insertion mode was "in table". */
3101	$this->inTable($token);
3102	}
3103	}
3104
3105	private function inCell($token) {
3106	/* An end tag whose tag name is one of: "td", "th" */
3107	if($token['type'] === HTML5::ENDTAG &&
3108	($token['name'] === 'td' \|\| $token['name'] === 'th')) {
3109	/* If the stack of open elements does not have an element in table
3110	scope with the same tag name as that of the token, then this is a
3111	parse error and the token must be ignored. */
3112	if(!$this->elementInScope($token['name'], true)) {
3113	// Ignore.
3114
3115	/* Otherwise: */
3116	} else {
3117	/* Generate implied end tags, except for elements with the same
3118	tag name as the token. */
3119	$this->generateImpliedEndTags(array($token['name']));
3120
3121	/* Now, if the current node is not an element with the same tag
3122	name as the token, then this is a parse error. */
3123	// k
3124
3125	/* Pop elements from this stack until an element with the same
3126	tag name as the token has been popped from the stack. */
3127	while(true) {
3128	$node = end($this->stack)->nodeName;
3129	array_pop($this->stack);
3130
3131	if($node === $token['name']) {
3132	break;
3133	}
3134	}
3135
3136	/* Clear the list of active formatting elements up to the last
3137	marker. */
3138	$this->clearTheActiveFormattingElementsUpToTheLastMarker();
3139
3140	/* Switch the insertion mode to "in row". (The current node
3141	will be a tr element at this point.) */
3142	$this->mode = self::IN_ROW;
3143	}
3144
3145	/* A start tag whose tag name is one of: "caption", "col", "colgroup",
3146	"tbody", "td", "tfoot", "th", "thead", "tr" */
3147	} elseif($token['type'] === HTML5::STARTTAG && in_array($token['name'],
3148	array('caption', 'col', 'colgroup', 'tbody', 'td', 'tfoot', 'th',
3149	'thead', 'tr'))) {
3150	/* If the stack of open elements does not have a td or th element
3151	in table scope, then this is a parse error; ignore the token.
3152	(innerHTML case) */
3153	if(!$this->elementInScope(array('td', 'th'), true)) {
3154	// Ignore.
3155
3156	/* Otherwise, close the cell (see below) and reprocess the current
3157	token. */
3158	} else {
3159	$this->closeCell();
3160	return $this->inRow($token);
3161	}
3162
3163	/* A start tag whose tag name is one of: "caption", "col", "colgroup",
3164	"tbody", "td", "tfoot", "th", "thead", "tr" */
3165	} elseif($token['type'] === HTML5::STARTTAG && in_array($token['name'],
3166	array('caption', 'col', 'colgroup', 'tbody', 'td', 'tfoot', 'th',
3167	'thead', 'tr'))) {
3168	/* If the stack of open elements does not have a td or th element
3169	in table scope, then this is a parse error; ignore the token.
3170	(innerHTML case) */
3171	if(!$this->elementInScope(array('td', 'th'), true)) {
3172	// Ignore.
3173
3174	/* Otherwise, close the cell (see below) and reprocess the current
3175	token. */
3176	} else {
3177	$this->closeCell();
3178	return $this->inRow($token);
3179	}
3180
3181	/* An end tag whose tag name is one of: "body", "caption", "col",
3182	"colgroup", "html" */
3183	} elseif($token['type'] === HTML5::ENDTAG && in_array($token['name'],
3184	array('body', 'caption', 'col', 'colgroup', 'html'))) {
3185	/* Parse error. Ignore the token. */
3186
3187	/* An end tag whose tag name is one of: "table", "tbody", "tfoot",
3188	"thead", "tr" */
3189	} elseif($token['type'] === HTML5::ENDTAG && in_array($token['name'],
3190	array('table', 'tbody', 'tfoot', 'thead', 'tr'))) {
3191	/* If the stack of open elements does not have an element in table
3192	scope with the same tag name as that of the token (which can only
3193	happen for "tbody", "tfoot" and "thead", or, in the innerHTML case),
3194	then this is a parse error and the token must be ignored. */
3195	if(!$this->elementInScope($token['name'], true)) {
3196	// Ignore.
3197
3198	/* Otherwise, close the cell (see below) and reprocess the current
3199	token. */
3200	} else {
3201	$this->closeCell();
3202	return $this->inRow($token);
3203	}
3204
3205	/* Anything else */
3206	} else {
3207	/* Process the token as if the insertion mode was "in body". */
3208	$this->inBody($token);
3209	}
3210	}
3211
3212	private function inSelect($token) {
3213	/* Handle the token as follows: */
3214
3215	/* A character token */
3216	if($token['type'] === HTML5::CHARACTR) {
3217	/* Append the token's character to the current node. */
3218	$this->insertText($token['data']);
3219
3220	/* A comment token */
3221	} elseif($token['type'] === HTML5::COMMENT) {
3222	/* Append a Comment node to the current node with the data
3223	attribute set to the data given in the comment token. */
3224	$this->insertComment($token['data']);
3225
3226	/* A start tag token whose tag name is "option" */
3227	} elseif($token['type'] === HTML5::STARTTAG &&
3228	$token['name'] === 'option') {
3229	/* If the current node is an option element, act as if an end tag
3230	with the tag name "option" had been seen. */
3231	if(end($this->stack)->nodeName === 'option') {
3232	$this->inSelect(array(
3233	'name' => 'option',
3234	'type' => HTML5::ENDTAG
3235	));
3236	}
3237
3238	/* Insert an HTML element for the token. */
3239	$this->insertElement($token);
3240
3241	/* A start tag token whose tag name is "optgroup" */
3242	} elseif($token['type'] === HTML5::STARTTAG &&
3243	$token['name'] === 'optgroup') {
3244	/* If the current node is an option element, act as if an end tag
3245	with the tag name "option" had been seen. */
3246	if(end($this->stack)->nodeName === 'option') {
3247	$this->inSelect(array(
3248	'name' => 'option',
3249	'type' => HTML5::ENDTAG
3250	));
3251	}
3252
3253	/* If the current node is an optgroup element, act as if an end tag
3254	with the tag name "optgroup" had been seen. */
3255	if(end($this->stack)->nodeName === 'optgroup') {
3256	$this->inSelect(array(
3257	'name' => 'optgroup',
3258	'type' => HTML5::ENDTAG
3259	));
3260	}
3261
3262	/* Insert an HTML element for the token. */
3263	$this->insertElement($token);
3264
3265	/* An end tag token whose tag name is "optgroup" */
3266	} elseif($token['type'] === HTML5::ENDTAG &&
3267	$token['name'] === 'optgroup') {
3268	/* First, if the current node is an option element, and the node
3269	immediately before it in the stack of open elements is an optgroup
3270	element, then act as if an end tag with the tag name "option" had
3271	been seen. */
3272	$elements_in_stack = count($this->stack);
3273
3274	if($this->stack[$elements_in_stack - 1]->nodeName === 'option' &&
3275	$this->stack[$elements_in_stack - 2]->nodeName === 'optgroup') {
3276	$this->inSelect(array(
3277	'name' => 'option',
3278	'type' => HTML5::ENDTAG
3279	));
3280	}
3281
3282	/* If the current node is an optgroup element, then pop that node
3283	from the stack of open elements. Otherwise, this is a parse error,
3284	ignore the token. */
3285	if($this->stack[$elements_in_stack - 1] === 'optgroup') {
3286	array_pop($this->stack);
3287	}
3288
3289	/* An end tag token whose tag name is "option" */
3290	} elseif($token['type'] === HTML5::ENDTAG &&
3291	$token['name'] === 'option') {
3292	/* If the current node is an option element, then pop that node
3293	from the stack of open elements. Otherwise, this is a parse error,
3294	ignore the token. */
3295	if(end($this->stack)->nodeName === 'option') {
3296	array_pop($this->stack);
3297	}
3298
3299	/* An end tag whose tag name is "select" */
3300	} elseif($token['type'] === HTML5::ENDTAG &&
3301	$token['name'] === 'select') {
3302	/* If the stack of open elements does not have an element in table
3303	scope with the same tag name as the token, this is a parse error.
3304	Ignore the token. (innerHTML case) */
3305	if(!$this->elementInScope($token['name'], true)) {
3306	// w/e
3307
3308	/* Otherwise: */
3309	} else {
3310	/* Pop elements from the stack of open elements until a select
3311	element has been popped from the stack. */
3312	while(true) {
3313	$current = end($this->stack)->nodeName;
3314	array_pop($this->stack);
3315
3316	if($current === 'select') {
3317	break;
3318	}
3319	}
3320
3321	/* Reset the insertion mode appropriately. */
3322	$this->resetInsertionMode();
3323	}
3324
3325	/* A start tag whose tag name is "select" */
3326	} elseif($token['name'] === 'select' &&
3327	$token['type'] === HTML5::STARTTAG) {
3328	/* Parse error. Act as if the token had been an end tag with the
3329	tag name "select" instead. */
3330	$this->inSelect(array(
3331	'name' => 'select',
3332	'type' => HTML5::ENDTAG
3333	));
3334
3335	/* An end tag whose tag name is one of: "caption", "table", "tbody",
3336	"tfoot", "thead", "tr", "td", "th" */
3337	} elseif(in_array($token['name'], array('caption', 'table', 'tbody',
3338	'tfoot', 'thead', 'tr', 'td', 'th')) && $token['type'] === HTML5::ENDTAG) {
3339	/* Parse error. */
3340	// w/e
3341
3342	/* If the stack of open elements has an element in table scope with
3343	the same tag name as that of the token, then act as if an end tag
3344	with the tag name "select" had been seen, and reprocess the token.
3345	Otherwise, ignore the token. */
3346	if($this->elementInScope($token['name'], true)) {
3347	$this->inSelect(array(
3348	'name' => 'select',
3349	'type' => HTML5::ENDTAG
3350	));
3351
3352	$this->mainPhase($token);
3353	}
3354
3355	/* Anything else */
3356	} else {
3357	/* Parse error. Ignore the token. */
3358	}
3359	}
3360
3361	private function afterBody($token) {
3362	/* Handle the token as follows: */
3363
3364	/* A character token that is one of one of U+0009 CHARACTER TABULATION,
3365	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
3366	or U+0020 SPACE */
3367	if($token['type'] === HTML5::CHARACTR &&
3368	preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
3369	/* Process the token as it would be processed if the insertion mode
3370	was "in body". */
3371	$this->inBody($token);
3372
3373	/* A comment token */
3374	} elseif($token['type'] === HTML5::COMMENT) {
3375	/* Append a Comment node to the first element in the stack of open
3376	elements (the html element), with the data attribute set to the
3377	data given in the comment token. */
3378	$comment = $this->dom->createComment($token['data']);
3379	$this->stack[0]->appendChild($comment);
3380
3381	/* An end tag with the tag name "html" */
3382	} elseif($token['type'] === HTML5::ENDTAG && $token['name'] === 'html') {
3383	/* If the parser was originally created in order to handle the
3384	setting of an element's innerHTML attribute, this is a parse error;
3385	ignore the token. (The element will be an html element in this
3386	case.) (innerHTML case) */
3387
3388	/* Otherwise, switch to the trailing end phase. */
3389	$this->phase = self::END_PHASE;
3390
3391	/* Anything else */
3392	} else {
3393	/* Parse error. Set the insertion mode to "in body" and reprocess
3394	the token. */
3395	$this->mode = self::IN_BODY;
3396	return $this->inBody($token);
3397	}
3398	}
3399
3400	private function inFrameset($token) {
3401	/* Handle the token as follows: */
3402
3403	/* A character token that is one of one of U+0009 CHARACTER TABULATION,
3404	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
3405	U+000D CARRIAGE RETURN (CR), or U+0020 SPACE */
3406	if($token['type'] === HTML5::CHARACTR &&
3407	preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
3408	/* Append the character to the current node. */
3409	$this->insertText($token['data']);
3410
3411	/* A comment token */
3412	} elseif($token['type'] === HTML5::COMMENT) {
3413	/* Append a Comment node to the current node with the data
3414	attribute set to the data given in the comment token. */
3415	$this->insertComment($token['data']);
3416
3417	/* A start tag with the tag name "frameset" */
3418	} elseif($token['name'] === 'frameset' &&
3419	$token['type'] === HTML5::STARTTAG) {
3420	$this->insertElement($token);
3421
3422	/* An end tag with the tag name "frameset" */
3423	} elseif($token['name'] === 'frameset' &&
3424	$token['type'] === HTML5::ENDTAG) {
3425	/* If the current node is the root html element, then this is a
3426	parse error; ignore the token. (innerHTML case) */
3427	if(end($this->stack)->nodeName === 'html') {
3428	// Ignore
3429
3430	} else {
3431	/* Otherwise, pop the current node from the stack of open
3432	elements. */
3433	array_pop($this->stack);
3434
3435	/* If the parser was not originally created in order to handle
3436	the setting of an element's innerHTML attribute (innerHTML case),
3437	and the current node is no longer a frameset element, then change
3438	the insertion mode to "after frameset". */
3439	$this->mode = self::AFTR_FRAME;
3440	}
3441
3442	/* A start tag with the tag name "frame" */
3443	} elseif($token['name'] === 'frame' &&
3444	$token['type'] === HTML5::STARTTAG) {
3445	/* Insert an HTML element for the token. */
3446	$this->insertElement($token);
3447
3448	/* Immediately pop the current node off the stack of open elements. */
3449	array_pop($this->stack);
3450
3451	/* A start tag with the tag name "noframes" */
3452	} elseif($token['name'] === 'noframes' &&
3453	$token['type'] === HTML5::STARTTAG) {
3454	/* Process the token as if the insertion mode had been "in body". */
3455	$this->inBody($token);
3456
3457	/* Anything else */
3458	} else {
3459	/* Parse error. Ignore the token. */
3460	}
3461	}
3462
3463	private function afterFrameset($token) {
3464	/* Handle the token as follows: */
3465
3466	/* A character token that is one of one of U+0009 CHARACTER TABULATION,
3467	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
3468	U+000D CARRIAGE RETURN (CR), or U+0020 SPACE */
3469	if($token['type'] === HTML5::CHARACTR &&
3470	preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
3471	/* Append the character to the current node. */
3472	$this->insertText($token['data']);
3473
3474	/* A comment token */
3475	} elseif($token['type'] === HTML5::COMMENT) {
3476	/* Append a Comment node to the current node with the data
3477	attribute set to the data given in the comment token. */
3478	$this->insertComment($token['data']);
3479
3480	/* An end tag with the tag name "html" */
3481	} elseif($token['name'] === 'html' &&
3482	$token['type'] === HTML5::ENDTAG) {
3483	/* Switch to the trailing end phase. */
3484	$this->phase = self::END_PHASE;
3485
3486	/* A start tag with the tag name "noframes" */
3487	} elseif($token['name'] === 'noframes' &&
3488	$token['type'] === HTML5::STARTTAG) {
3489	/* Process the token as if the insertion mode had been "in body". */
3490	$this->inBody($token);
3491
3492	/* Anything else */
3493	} else {
3494	/* Parse error. Ignore the token. */
3495	}
3496	}
3497
3498	private function trailingEndPhase($token) {
3499	/* After the main phase, as each token is emitted from the tokenisation
3500	stage, it must be processed as described in this section. */
3501
3502	/* A DOCTYPE token */
3503	if($token['type'] === HTML5::DOCTYPE) {
3504	// Parse error. Ignore the token.
3505
3506	/* A comment token */
3507	} elseif($token['type'] === HTML5::COMMENT) {
3508	/* Append a Comment node to the Document object with the data
3509	attribute set to the data given in the comment token. */
3510	$comment = $this->dom->createComment($token['data']);
3511	$this->dom->appendChild($comment);
3512
3513	/* A character token that is one of one of U+0009 CHARACTER TABULATION,
3514	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
3515	or U+0020 SPACE */
3516	} elseif($token['type'] === HTML5::CHARACTR &&
3517	preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) {
3518	/* Process the token as it would be processed in the main phase. */
3519	$this->mainPhase($token);
3520
3521	/* A character token that is not one of U+0009 CHARACTER TABULATION,
3522	U+000A LINE FEED (LF), U+000B LINE TABULATION, U+000C FORM FEED (FF),
3523	or U+0020 SPACE. Or a start tag token. Or an end tag token. */
3524	} elseif(($token['type'] === HTML5::CHARACTR &&
3525	preg_match('/^[\t\n\x0b\x0c ]+$/', $token['data'])) \|\|
3526	$token['type'] === HTML5::STARTTAG \|\| $token['type'] === HTML5::ENDTAG) {
3527	/* Parse error. Switch back to the main phase and reprocess the
3528	token. */
3529	$this->phase = self::MAIN_PHASE;
3530	return $this->mainPhase($token);
3531
3532	/* An end-of-file token */
3533	} elseif($token['type'] === HTML5::EOF) {
3534	/* OMG DONE!! */
3535	}
3536	}
3537
3538	private function insertElement($token, $append = true, $check = false) {
3539	// Proprietary workaround for libxml2's limitations with tag names
3540	if ($check) {
3541	// Slightly modified HTML5 tag-name modification,
3542	// removing anything that's not an ASCII letter, digit, or hyphen
3543	$token['name'] = preg_replace('/[^a-z0-9-]/i', '', $token['name']);
3544	// Remove leading hyphens and numbers
3545	$token['name'] = ltrim($token['name'], '-0..9');
3546	// In theory, this should ever be needed, but just in case
3547	if ($token['name'] === '') $token['name'] = 'span'; // arbitrary generic choice
3548	}
3549
3550	$el = $this->dom->createElement($token['name']);
3551
3552	foreach($token['attr'] as $attr) {
3553	if(!$el->hasAttribute($attr['name'])) {
3554	$el->setAttribute($attr['name'], $attr['value']);
3555	}
3556	}
3557
3558	$this->appendToRealParent($el);
3559	$this->stack[] = $el;
3560
3561	return $el;
3562	}
3563
3564	private function insertText($data) {
3565	$text = $this->dom->createTextNode($data);
3566	$this->appendToRealParent($text);
3567	}
3568
3569	private function insertComment($data) {
3570	$comment = $this->dom->createComment($data);
3571	$this->appendToRealParent($comment);
3572	}
3573
3574	private function appendToRealParent($node) {
3575	if($this->foster_parent === null) {
3576	end($this->stack)->appendChild($node);
3577
3578	} elseif($this->foster_parent !== null) {
3579	/* If the foster parent element is the parent element of the
3580	last table element in the stack of open elements, then the new
3581	node must be inserted immediately before the last table element
3582	in the stack of open elements in the foster parent element;
3583	otherwise, the new node must be appended to the foster parent
3584	element. */
3585	for($n = count($this->stack) - 1; $n >= 0; $n--) {
3586	if($this->stack[$n]->nodeName === 'table' &&
3587	$this->stack[$n]->parentNode !== null) {
3588	$table = $this->stack[$n];
3589	break;
3590	}
3591	}
3592
3593	if(isset($table) && $this->foster_parent->isSameNode($table->parentNode))
3594	$this->foster_parent->insertBefore($node, $table);
3595	else
3596	$this->foster_parent->appendChild($node);
3597
3598	$this->foster_parent = null;
3599	}
3600	}
3601
3602	private function elementInScope($el, $table = false) {
3603	if(is_array($el)) {
3604	foreach($el as $element) {
3605	if($this->elementInScope($element, $table)) {
3606	return true;
3607	}
3608	}
3609
3610	return false;
3611	}
3612
3613	$leng = count($this->stack);
3614
3615	for($n = 0; $n < $leng; $n++) {
3616	/* 1. Initialise node to be the current node (the bottommost node of
3617	the stack). */
3618	$node = $this->stack[$leng - 1 - $n];
3619
3620	if($node->tagName === $el) {
3621	/* 2. If node is the target node, terminate in a match state. */
3622	return true;
3623
3624	} elseif($node->tagName === 'table') {
3625	/* 3. Otherwise, if node is a table element, terminate in a failure
3626	state. */
3627	return false;
3628
3629	} elseif($table === true && in_array($node->tagName, array('caption', 'td',
3630	'th', 'button', 'marquee', 'object'))) {
3631	/* 4. Otherwise, if the algorithm is the "has an element in scope"
3632	variant (rather than the "has an element in table scope" variant),
3633	and node is one of the following, terminate in a failure state. */
3634	return false;
3635
3636	} elseif($node === $node->ownerDocument->documentElement) {
3637	/* 5. Otherwise, if node is an html element (root element), terminate
3638	in a failure state. (This can only happen if the node is the topmost
3639	node of the stack of open elements, and prevents the next step from
3640	being invoked if there are no more elements in the stack.) */
3641	return false;
3642	}
3643
3644	/* Otherwise, set node to the previous entry in the stack of open
3645	elements and return to step 2. (This will never fail, since the loop
3646	will always terminate in the previous step if the top of the stack
3647	is reached.) */
3648	}
3649	}
3650
3651	private function reconstructActiveFormattingElements() {
3652	/* 1. If there are no entries in the list of active formatting elements,
3653	then there is nothing to reconstruct; stop this algorithm. */
3654	$formatting_elements = count($this->a_formatting);
3655
3656	if($formatting_elements === 0) {
3657	return false;
3658	}
3659
3660	/* 3. Let entry be the last (most recently added) element in the list
3661	of active formatting elements. */
3662	$entry = end($this->a_formatting);
3663
3664	/* 2. If the last (most recently added) entry in the list of active
3665	formatting elements is a marker, or if it is an element that is in the
3666	stack of open elements, then there is nothing to reconstruct; stop this
3667	algorithm. */
3668	if($entry === self::MARKER \|\| in_array($entry, $this->stack, true)) {
3669	return false;
3670	}
3671
3672	for($a = $formatting_elements - 1; $a >= 0; true) {
3673	/* 4. If there are no entries before entry in the list of active
3674	formatting elements, then jump to step 8. */
3675	if($a === 0) {
3676	$step_seven = false;
3677	break;
3678	}
3679
3680	/* 5. Let entry be the entry one earlier than entry in the list of
3681	active formatting elements. */
3682	$a--;
3683	$entry = $this->a_formatting[$a];
3684
3685	/* 6. If entry is neither a marker nor an element that is also in
3686	thetack of open elements, go to step 4. */
3687	if($entry === self::MARKER \|\| in_array($entry, $this->stack, true)) {
3688	break;
3689	}
3690	}
3691
3692	while(true) {
3693	/* 7. Let entry be the element one later than entry in the list of
3694	active formatting elements. */
3695	if(isset($step_seven) && $step_seven === true) {
3696	$a++;
3697	$entry = $this->a_formatting[$a];
3698	}
3699
3700	/* 8. Perform a shallow clone of the element entry to obtain clone. */
3701	$clone = $entry->cloneNode();
3702
3703	/* 9. Append clone to the current node and push it onto the stack
3704	of open elements so that it is the new current node. */
3705	end($this->stack)->appendChild($clone);
3706	$this->stack[] = $clone;
3707
3708	/* 10. Replace the entry for entry in the list with an entry for
3709	clone. */
3710	$this->a_formatting[$a] = $clone;
3711
3712	/* 11. If the entry for clone in the list of active formatting
3713	elements is not the last entry in the list, return to step 7. */
3714	if(end($this->a_formatting) !== $clone) {
3715	$step_seven = true;
3716	} else {
3717	break;
3718	}
3719	}
3720	}
3721
3722	private function clearTheActiveFormattingElementsUpToTheLastMarker() {
3723	/* When the steps below require the UA to clear the list of active
3724	formatting elements up to the last marker, the UA must perform the
3725	following steps: */
3726
3727	while(true) {
3728	/* 1. Let entry be the last (most recently added) entry in the list
3729	of active formatting elements. */
3730	$entry = end($this->a_formatting);
3731
3732	/* 2. Remove entry from the list of active formatting elements. */
3733	array_pop($this->a_formatting);
3734
3735	/* 3. If entry was a marker, then stop the algorithm at this point.
3736	The list has been cleared up to the last marker. */
3737	if($entry === self::MARKER) {
3738	break;
3739	}
3740	}
3741	}
3742
3743	private function generateImpliedEndTags($exclude = array()) {
3744	/* When the steps below require the UA to generate implied end tags,
3745	then, if the current node is a dd element, a dt element, an li element,
3746	a p element, a td element, a th element, or a tr element, the UA must
3747	act as if an end tag with the respective tag name had been seen and
3748	then generate implied end tags again. */
3749	$node = end($this->stack);
3750	$elements = array_diff(array('dd', 'dt', 'li', 'p', 'td', 'th', 'tr'), $exclude);
3751
3752	while(in_array(end($this->stack)->nodeName, $elements)) {
3753	array_pop($this->stack);
3754	}
3755	}
3756
3757	private function getElementCategory($node) {
3758	$name = $node->tagName;
3759	if(in_array($name, $this->special))
3760	return self::SPECIAL;
3761
3762	elseif(in_array($name, $this->scoping))
3763	return self::SCOPING;
3764
3765	elseif(in_array($name, $this->formatting))
3766	return self::FORMATTING;
3767
3768	else
3769	return self::PHRASING;
3770	}
3771
3772	private function clearStackToTableContext($elements) {
3773	/* When the steps above require the UA to clear the stack back to a
3774	table context, it means that the UA must, while the current node is not
3775	a table element or an html element, pop elements from the stack of open
3776	elements. If this causes any elements to be popped from the stack, then
3777	this is a parse error. */
3778	while(true) {
3779	$node = end($this->stack)->nodeName;
3780
3781	if(in_array($node, $elements)) {
3782	break;
3783	} else {
3784	array_pop($this->stack);
3785	}
3786	}
3787	}
3788
3789	private function resetInsertionMode() {
3790	/* 1. Let last be false. */
3791	$last = false;
3792	$leng = count($this->stack);
3793
3794	for($n = $leng - 1; $n >= 0; $n--) {
3795	/* 2. Let node be the last node in the stack of open elements. */
3796	$node = $this->stack[$n];
3797
3798	/* 3. If node is the first node in the stack of open elements, then
3799	set last to true. If the element whose innerHTML attribute is being
3800	set is neither a td element nor a th element, then set node to the
3801	element whose innerHTML attribute is being set. (innerHTML case) */
3802	if($this->stack[0]->isSameNode($node)) {
3803	$last = true;
3804	}
3805
3806	/* 4. If node is a select element, then switch the insertion mode to
3807	"in select" and abort these steps. (innerHTML case) */
3808	if($node->nodeName === 'select') {
3809	$this->mode = self::IN_SELECT;
3810	break;
3811
3812	/* 5. If node is a td or th element, then switch the insertion mode
3813	to "in cell" and abort these steps. */
3814	} elseif($node->nodeName === 'td' \|\| $node->nodeName === 'th') {
3815	$this->mode = self::IN_CELL;
3816	break;
3817
3818	/* 6. If node is a tr element, then switch the insertion mode to
3819	"in row" and abort these steps. */
3820	} elseif($node->nodeName === 'tr') {
3821	$this->mode = self::IN_ROW;
3822	break;
3823
3824	/* 7. If node is a tbody, thead, or tfoot element, then switch the
3825	insertion mode to "in table body" and abort these steps. */
3826	} elseif(in_array($node->nodeName, array('tbody', 'thead', 'tfoot'))) {
3827	$this->mode = self::IN_TBODY;
3828	break;
3829
3830	/* 8. If node is a caption element, then switch the insertion mode
3831	to "in caption" and abort these steps. */
3832	} elseif($node->nodeName === 'caption') {
3833	$this->mode = self::IN_CAPTION;
3834	break;
3835
3836	/* 9. If node is a colgroup element, then switch the insertion mode
3837	to "in column group" and abort these steps. (innerHTML case) */
3838	} elseif($node->nodeName === 'colgroup') {
3839	$this->mode = self::IN_CGROUP;
3840	break;
3841
3842	/* 10. If node is a table element, then switch the insertion mode
3843	to "in table" and abort these steps. */
3844	} elseif($node->nodeName === 'table') {
3845	$this->mode = self::IN_TABLE;
3846	break;
3847
3848	/* 11. If node is a head element, then switch the insertion mode
3849	to "in body" ("in body"! not "in head"!) and abort these steps.
3850	(innerHTML case) */
3851	} elseif($node->nodeName === 'head') {
3852	$this->mode = self::IN_BODY;
3853	break;
3854
3855	/* 12. If node is a body element, then switch the insertion mode to
3856	"in body" and abort these steps. */
3857	} elseif($node->nodeName === 'body') {
3858	$this->mode = self::IN_BODY;
3859	break;
3860
3861	/* 13. If node is a frameset element, then switch the insertion
3862	mode to "in frameset" and abort these steps. (innerHTML case) */
3863	} elseif($node->nodeName === 'frameset') {
3864	$this->mode = self::IN_FRAME;
3865	break;
3866
3867	/* 14. If node is an html element, then: if the head element
3868	pointer is null, switch the insertion mode to "before head",
3869	otherwise, switch the insertion mode to "after head". In either
3870	case, abort these steps. (innerHTML case) */
3871	} elseif($node->nodeName === 'html') {
3872	$this->mode = ($this->head_pointer === null)
3873	? self::BEFOR_HEAD
3874	: self::AFTER_HEAD;
3875
3876	break;
3877
3878	/* 15. If last is true, then set the insertion mode to "in body"
3879	and abort these steps. (innerHTML case) */
3880	} elseif($last) {
3881	$this->mode = self::IN_BODY;
3882	break;
3883	}
3884	}
3885	}
3886
3887	private function closeCell() {
3888	/* If the stack of open elements has a td or th element in table scope,
3889	then act as if an end tag token with that tag name had been seen. */
3890	foreach(array('td', 'th') as $cell) {
3891	if($this->elementInScope($cell, true)) {
3892	$this->inCell(array(
3893	'name' => $cell,
3894	'type' => HTML5::ENDTAG
3895	));
3896
3897	break;
3898	}
3899	}
3900	}
3901
3902	public function save() {
3903	return $this->dom;
3904	}
3905	}
3906	?>

Note: See TracBrowser for help on using the browser.

Context Navigation

root/afridex/plugins/Flutter/purifier_lib/HTMLPurifier/Lexer/PH5P.php @ 21

Download in other formats: