/[suikacvs]/markup/html/whatpm/Whatpm/HTML.pm.src
Suika

Contents of /markup/html/whatpm/Whatpm/HTML.pm.src

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1.240 - (show annotations) (download) (as text)
Sun Sep 6 10:21:14 2009 UTC (17 years, 1 month ago) by wakaba
Branch: MAIN
Changes since 1.239: +3 -3 lines
File MIME type: application/x-wais-source 
++ whatpm/t/ChangeLog	6 Sep 2009 10:19:52 -0000
	* tokenizer-test-2.dat: Added a test case of <hr/>.

2009-09-06  Wakaba  <wakaba@suika.fam.cx>

++ whatpm/Whatpm/ChangeLog	6 Sep 2009 10:20:12 -0000
	* HTML.pm.src: |<hr/>| was incorrectly marked as an error.

2009-09-06  Wakaba  <wakaba@suika.fam.cx>
1 package Whatpm::HTML;
2 use strict;
3 our $VERSION=do{my @r=(q$Revision: 1.239 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
4 use Error qw(:try);
5
6 use Whatpm::HTML::Tokenizer;
7
8 ## NOTE: This module don't check all HTML5 parse errors; character
9 ## encoding related parse errors are expected to be handled by relevant
10 ## modules.
11 ## Parse errors for control characters that are not allowed in HTML5
12 ## documents, for surrogate code points, and for noncharacter code
13 ## points, as well as U+FFFD substitions for characters whose code points
14 ## is higher than U+10FFFF may be detected by combining the parser with
15 ## the checker implemented by Whatpm::Charset::UnicodeChecker (for its
16 ## usage example, see |t/HTML-tree.t| in the Whatpm package or the
17 ## WebHACC::Language::HTML module in the WebHACC package).
18
19 ## ISSUE:
20 ## var doc = implementation.createDocument (null, null, null);
21 ## doc.write ('');
22 ## alert (doc.compatMode);
23
24 require IO::Handle;
25
26 ## Namespace URLs
27
28 my $HTML_NS = q<http://www.w3.org/1999/xhtml>;
29 my $MML_NS = q<http://www.w3.org/1998/Math/MathML>;
30 my $SVG_NS = q<http://www.w3.org/2000/svg>;
31 my $XLINK_NS = q<http://www.w3.org/1999/xlink>;
32 my $XML_NS = q<http://www.w3.org/XML/1998/namespace>;
33 my $XMLNS_NS = q<http://www.w3.org/2000/xmlns/>;
34
35 ## Element categories
36
37 ## Bits 12-15
38 sub SPECIAL_EL () { 0b1_000000000000000 }
39 sub SCOPING_EL () { 0b1_00000000000000 }
40 sub FORMATTING_EL () { 0b1_0000000000000 }
41 sub PHRASING_EL () { 0b1_000000000000 }
42
43 ## Bits 10-11
44 #sub FOREIGN_EL () { 0b1_00000000000 } # see Whatpm::HTML::Tokenizer
45 sub FOREIGN_FLOW_CONTENT_EL () { 0b1_0000000000 }
46
47 ## Bits 6-9
48 sub TABLE_SCOPING_EL () { 0b1_000000000 }
49 sub TABLE_ROWS_SCOPING_EL () { 0b1_00000000 }
50 sub TABLE_ROW_SCOPING_EL () { 0b1_0000000 }
51 sub TABLE_ROWS_EL () { 0b1_000000 }
52
53 ## Bit 5
54 sub ADDRESS_DIV_P_EL () { 0b1_00000 }
55
56 ## NOTE: Used in </body> and EOF algorithms.
57 ## Bit 4
58 sub ALL_END_TAG_OPTIONAL_EL () { 0b1_0000 }
59
60 ## NOTE: Used in "generate implied end tags" algorithm.
61 ## NOTE: There is a code where a modified version of
62 ## END_TAG_OPTIONAL_EL is used in "generate implied end tags"
63 ## implementation (search for the algorithm name).
64 ## Bit 3
65 sub END_TAG_OPTIONAL_EL () { 0b1_000 }
66
67 ## Bits 0-2
68
69 sub MISC_SPECIAL_EL () { SPECIAL_EL | 0b000 }
70 sub FORM_EL () { SPECIAL_EL | 0b001 }
71 sub FRAMESET_EL () { SPECIAL_EL | 0b010 }
72 sub HEADING_EL () { SPECIAL_EL | 0b011 }
73 sub SELECT_EL () { SPECIAL_EL | 0b100 }
74 sub SCRIPT_EL () { SPECIAL_EL | 0b101 }
75
76 sub ADDRESS_DIV_EL () { SPECIAL_EL | ADDRESS_DIV_P_EL | 0b001 }
77 sub BODY_EL () { SPECIAL_EL | ALL_END_TAG_OPTIONAL_EL | 0b001 }
78
79 sub DTDD_EL () {
80 SPECIAL_EL |
81 END_TAG_OPTIONAL_EL |
82 ALL_END_TAG_OPTIONAL_EL |
83 0b010
84 }
85 sub LI_EL () {
86 SPECIAL_EL |
87 END_TAG_OPTIONAL_EL |
88 ALL_END_TAG_OPTIONAL_EL |
89 0b100
90 }
91 sub P_EL () {
92 SPECIAL_EL |
93 ADDRESS_DIV_P_EL |
94 END_TAG_OPTIONAL_EL |
95 ALL_END_TAG_OPTIONAL_EL |
96 0b001
97 }
98
99 sub TABLE_ROW_EL () {
100 SPECIAL_EL |
101 TABLE_ROWS_EL |
102 TABLE_ROW_SCOPING_EL |
103 ALL_END_TAG_OPTIONAL_EL |
104 0b001
105 }
106 sub TABLE_ROW_GROUP_EL () {
107 SPECIAL_EL |
108 TABLE_ROWS_EL |
109 TABLE_ROWS_SCOPING_EL |
110 ALL_END_TAG_OPTIONAL_EL |
111 0b001
112 }
113
114 sub MISC_SCOPING_EL () { SCOPING_EL | 0b000 }
115 sub BUTTON_EL () { SCOPING_EL | 0b001 }
116 sub CAPTION_EL () { SCOPING_EL | 0b010 }
117 sub HTML_EL () {
118 SCOPING_EL |
119 TABLE_SCOPING_EL |
120 TABLE_ROWS_SCOPING_EL |
121 TABLE_ROW_SCOPING_EL |
122 ALL_END_TAG_OPTIONAL_EL |
123 0b001
124 }
125 sub TABLE_EL () {
126 SCOPING_EL |
127 TABLE_ROWS_EL |
128 TABLE_SCOPING_EL |
129 0b001
130 }
131 sub TABLE_CELL_EL () {
132 SCOPING_EL |
133 TABLE_ROW_SCOPING_EL |
134 ALL_END_TAG_OPTIONAL_EL |
135 0b001
136 }
137
138 sub MISC_FORMATTING_EL () { FORMATTING_EL | 0b000 }
139 sub A_EL () { FORMATTING_EL | 0b001 }
140 sub NOBR_EL () { FORMATTING_EL | 0b010 }
141
142 sub RUBY_EL () { PHRASING_EL | 0b001 }
143
144 ## ISSUE: ALL_END_TAG_OPTIONAL_EL?
145 sub OPTGROUP_EL () { PHRASING_EL | END_TAG_OPTIONAL_EL | 0b001 }
146 sub OPTION_EL () { PHRASING_EL | END_TAG_OPTIONAL_EL | 0b010 }
147 sub RUBY_COMPONENT_EL () { PHRASING_EL | END_TAG_OPTIONAL_EL | 0b100 }
148
149 sub MML_AXML_EL () { PHRASING_EL | FOREIGN_EL | 0b001 }
150
151 my $el_category = {
152 a => A_EL,
153 address => ADDRESS_DIV_EL,
154 applet => MISC_SCOPING_EL,
155 area => MISC_SPECIAL_EL,
156 article => MISC_SPECIAL_EL,
157 aside => MISC_SPECIAL_EL,
158 b => FORMATTING_EL,
159 base => MISC_SPECIAL_EL,
160 basefont => MISC_SPECIAL_EL,
161 bgsound => MISC_SPECIAL_EL,
162 big => FORMATTING_EL,
163 blockquote => MISC_SPECIAL_EL,
164 body => BODY_EL,
165 br => MISC_SPECIAL_EL,
166 button => BUTTON_EL,
167 caption => CAPTION_EL,
168 center => MISC_SPECIAL_EL,
169 col => MISC_SPECIAL_EL,
170 colgroup => MISC_SPECIAL_EL,
171 command => MISC_SPECIAL_EL,
172 datagrid => MISC_SPECIAL_EL,
173 dd => DTDD_EL,
174 details => MISC_SPECIAL_EL,
175 dialog => MISC_SPECIAL_EL,
176 dir => MISC_SPECIAL_EL,
177 div => ADDRESS_DIV_EL,
178 dl => MISC_SPECIAL_EL,
179 dt => DTDD_EL,
180 em => FORMATTING_EL,
181 embed => MISC_SPECIAL_EL,
182 fieldset => MISC_SPECIAL_EL,
183 figure => MISC_SPECIAL_EL,
184 font => FORMATTING_EL,
185 footer => MISC_SPECIAL_EL,
186 form => FORM_EL,
187 frame => MISC_SPECIAL_EL,
188 frameset => FRAMESET_EL,
189 h1 => HEADING_EL,
190 h2 => HEADING_EL,
191 h3 => HEADING_EL,
192 h4 => HEADING_EL,
193 h5 => HEADING_EL,
194 h6 => HEADING_EL,
195 head => MISC_SPECIAL_EL,
196 header => MISC_SPECIAL_EL,
197 hgroup => MISC_SPECIAL_EL,
198 hr => MISC_SPECIAL_EL,
199 html => HTML_EL,
200 i => FORMATTING_EL,
201 iframe => MISC_SPECIAL_EL,
202 img => MISC_SPECIAL_EL,
203 #image => MISC_SPECIAL_EL, ## NOTE: Commented out in the spec.
204 input => MISC_SPECIAL_EL,
205 isindex => MISC_SPECIAL_EL,
206 ## XXX keygen? (Whether a void element is in Special or not does not
207 ## affect to the processing, however.)
208 li => LI_EL,
209 link => MISC_SPECIAL_EL,
210 listing => MISC_SPECIAL_EL,
211 marquee => MISC_SCOPING_EL,
212 menu => MISC_SPECIAL_EL,
213 meta => MISC_SPECIAL_EL,
214 nav => MISC_SPECIAL_EL,
215 nobr => NOBR_EL,
216 noembed => MISC_SPECIAL_EL,
217 noframes => MISC_SPECIAL_EL,
218 noscript => MISC_SPECIAL_EL,
219 object => MISC_SCOPING_EL,
220 ol => MISC_SPECIAL_EL,
221 optgroup => OPTGROUP_EL,
222 option => OPTION_EL,
223 p => P_EL,
224 param => MISC_SPECIAL_EL,
225 plaintext => MISC_SPECIAL_EL,
226 pre => MISC_SPECIAL_EL,
227 rp => RUBY_COMPONENT_EL,
228 rt => RUBY_COMPONENT_EL,
229 ruby => RUBY_EL,
230 s => FORMATTING_EL,
231 script => MISC_SPECIAL_EL,
232 select => SELECT_EL,
233 section => MISC_SPECIAL_EL,
234 small => FORMATTING_EL,
235 spacer => MISC_SPECIAL_EL,
236 strike => FORMATTING_EL,
237 strong => FORMATTING_EL,
238 style => MISC_SPECIAL_EL,
239 table => TABLE_EL,
240 tbody => TABLE_ROW_GROUP_EL,
241 td => TABLE_CELL_EL,
242 textarea => MISC_SPECIAL_EL,
243 tfoot => TABLE_ROW_GROUP_EL,
244 th => TABLE_CELL_EL,
245 thead => TABLE_ROW_GROUP_EL,
246 title => MISC_SPECIAL_EL,
247 tr => TABLE_ROW_EL,
248 tt => FORMATTING_EL,
249 u => FORMATTING_EL,
250 ul => MISC_SPECIAL_EL,
251 wbr => MISC_SPECIAL_EL,
252 xmp => MISC_SPECIAL_EL,
253 };
254
255 my $el_category_f = {
256 $MML_NS => {
257 'annotation-xml' => MML_AXML_EL,
258 mi => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
259 mo => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
260 mn => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
261 ms => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
262 mtext => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
263 },
264 $SVG_NS => {
265 foreignObject => SCOPING_EL | FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
266 desc => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
267 title => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
268 },
269 ## NOTE: In addition, FOREIGN_EL is set to non-HTML elements.
270 };
271
272 my $svg_attr_name = {
273 attributename => 'attributeName',
274 attributetype => 'attributeType',
275 basefrequency => 'baseFrequency',
276 baseprofile => 'baseProfile',
277 calcmode => 'calcMode',
278 clippathunits => 'clipPathUnits',
279 contentscripttype => 'contentScriptType',
280 contentstyletype => 'contentStyleType',
281 diffuseconstant => 'diffuseConstant',
282 edgemode => 'edgeMode',
283 externalresourcesrequired => 'externalResourcesRequired',
284 filterres => 'filterRes',
285 filterunits => 'filterUnits',
286 glyphref => 'glyphRef',
287 gradienttransform => 'gradientTransform',
288 gradientunits => 'gradientUnits',
289 kernelmatrix => 'kernelMatrix',
290 kernelunitlength => 'kernelUnitLength',
291 keypoints => 'keyPoints',
292 keysplines => 'keySplines',
293 keytimes => 'keyTimes',
294 lengthadjust => 'lengthAdjust',
295 limitingconeangle => 'limitingConeAngle',
296 markerheight => 'markerHeight',
297 markerunits => 'markerUnits',
298 markerwidth => 'markerWidth',
299 maskcontentunits => 'maskContentUnits',
300 maskunits => 'maskUnits',
301 numoctaves => 'numOctaves',
302 pathlength => 'pathLength',
303 patterncontentunits => 'patternContentUnits',
304 patterntransform => 'patternTransform',
305 patternunits => 'patternUnits',
306 pointsatx => 'pointsAtX',
307 pointsaty => 'pointsAtY',
308 pointsatz => 'pointsAtZ',
309 preservealpha => 'preserveAlpha',
310 preserveaspectratio => 'preserveAspectRatio',
311 primitiveunits => 'primitiveUnits',
312 refx => 'refX',
313 refy => 'refY',
314 repeatcount => 'repeatCount',
315 repeatdur => 'repeatDur',
316 requiredextensions => 'requiredExtensions',
317 requiredfeatures => 'requiredFeatures',
318 specularconstant => 'specularConstant',
319 specularexponent => 'specularExponent',
320 spreadmethod => 'spreadMethod',
321 startoffset => 'startOffset',
322 stddeviation => 'stdDeviation',
323 stitchtiles => 'stitchTiles',
324 surfacescale => 'surfaceScale',
325 systemlanguage => 'systemLanguage',
326 tablevalues => 'tableValues',
327 targetx => 'targetX',
328 targety => 'targetY',
329 textlength => 'textLength',
330 viewbox => 'viewBox',
331 viewtarget => 'viewTarget',
332 xchannelselector => 'xChannelSelector',
333 ychannelselector => 'yChannelSelector',
334 zoomandpan => 'zoomAndPan',
335 };
336
337 my $foreign_attr_xname = {
338 'xlink:actuate' => [$XLINK_NS, ['xlink', 'actuate']],
339 'xlink:arcrole' => [$XLINK_NS, ['xlink', 'arcrole']],
340 'xlink:href' => [$XLINK_NS, ['xlink', 'href']],
341 'xlink:role' => [$XLINK_NS, ['xlink', 'role']],
342 'xlink:show' => [$XLINK_NS, ['xlink', 'show']],
343 'xlink:title' => [$XLINK_NS, ['xlink', 'title']],
344 'xlink:type' => [$XLINK_NS, ['xlink', 'type']],
345 'xml:base' => [$XML_NS, ['xml', 'base']],
346 'xml:lang' => [$XML_NS, ['xml', 'lang']],
347 'xml:space' => [$XML_NS, ['xml', 'space']],
348 'xmlns' => [$XMLNS_NS, [undef, 'xmlns']],
349 'xmlns:xlink' => [$XMLNS_NS, ['xmlns', 'xlink']],
350 };
351
352 ## ISSUE: xmlns:xlink="non-xlink-ns" is not an error.
353
354 ## TODO: Invoke the reset algorithm when a resettable element is
355 ## created (cf. HTML5 revision 2259).
356
357 sub parse_byte_string ($$$$;$) {
358 my $self = shift;
359 my $charset_name = shift;
360 open my $input, '<', ref $_[0] ? $_[0] : \($_[0]);
361 return $self->parse_byte_stream ($charset_name, $input, @_[1..$#_]);
362 } # parse_byte_string
363
364 sub parse_byte_stream ($$$$;$$) {
365 # my ($self, $charset_name, $byte_stream, $doc, $onerror, $get_wrapper) = @_;
366 my $self = ref $_[0] ? shift : shift->new;
367 my $charset_name = shift;
368 my $byte_stream = $_[0];
369
370 my $onerror = $_[2] || sub {
371 my (%opt) = @_;
372 warn "Parse error ($opt{type})\n";
373 };
374 $self->{parse_error} = $onerror; # updated later by parse_char_string
375
376 my $get_wrapper = $_[3] || sub ($) {
377 return $_[0]; # $_[0] = byte stream handle, returned = arg to char handle
378 };
379
380 ## HTML5 encoding sniffing algorithm
381 require Message::Charset::Info;
382 my $charset;
383 my $buffer;
384 my ($char_stream, $e_status);
385
386 SNIFFING: {
387 ## NOTE: By setting |allow_fallback| option true when the
388 ## |get_decode_handle| method is invoked, we ignore what the HTML5
389 ## spec requires, i.e. unsupported encoding should be ignored.
390 ## TODO: We should not do this unless the parser is invoked
391 ## in the conformance checking mode, in which this behavior
392 ## would be useful.
393
394 ## Step 1
395 if (defined $charset_name) {
396 $charset = Message::Charset::Info->get_by_html_name ($charset_name);
397 ## TODO: Is this ok? Transfer protocol's parameter should be
398 ## interpreted in its semantics?
399
400 ($char_stream, $e_status) = $charset->get_decode_handle
401 ($byte_stream, allow_error_reporting => 1,
402 allow_fallback => 1);
403 if ($char_stream) {
404 $self->{confident} = 1;
405 last SNIFFING;
406 } else {
407 !!!parse-error (type => 'charset:not supported',
408 layer => 'encode',
409 line => 1, column => 1,
410 value => $charset_name,
411 level => $self->{level}->{uncertain});
412 }
413 }
414
415 ## Step 2
416 my $byte_buffer = '';
417 for (1..1024) {
418 my $char = $byte_stream->getc;
419 last unless defined $char;
420 $byte_buffer .= $char;
421 } ## TODO: timeout
422
423 ## Step 3
424 if ($byte_buffer =~ /^\xFE\xFF/) {
425 $charset = Message::Charset::Info->get_by_html_name ('utf-16be');
426 ($char_stream, $e_status) = $charset->get_decode_handle
427 ($byte_stream, allow_error_reporting => 1,
428 allow_fallback => 1, byte_buffer => \$byte_buffer);
429 $self->{confident} = 1;
430 last SNIFFING;
431 } elsif ($byte_buffer =~ /^\xFF\xFE/) {
432 $charset = Message::Charset::Info->get_by_html_name ('utf-16le');
433 ($char_stream, $e_status) = $charset->get_decode_handle
434 ($byte_stream, allow_error_reporting => 1,
435 allow_fallback => 1, byte_buffer => \$byte_buffer);
436 $self->{confident} = 1;
437 last SNIFFING;
438 } elsif ($byte_buffer =~ /^\xEF\xBB\xBF/) {
439 $charset = Message::Charset::Info->get_by_html_name ('utf-8');
440 ($char_stream, $e_status) = $charset->get_decode_handle
441 ($byte_stream, allow_error_reporting => 1,
442 allow_fallback => 1, byte_buffer => \$byte_buffer);
443 $self->{confident} = 1;
444 last SNIFFING;
445 }
446
447 ## Step 4
448 ## TODO: <meta charset>
449
450 ## Step 5
451 ## TODO: from history
452
453 ## Step 6
454 require Whatpm::Charset::UniversalCharDet;
455 $charset_name = Whatpm::Charset::UniversalCharDet->detect_byte_string
456 ($byte_buffer);
457 if (defined $charset_name) {
458 $charset = Message::Charset::Info->get_by_html_name ($charset_name);
459
460 require Whatpm::Charset::DecodeHandle;
461 $buffer = Whatpm::Charset::DecodeHandle::ByteBuffer->new
462 ($byte_stream);
463 ($char_stream, $e_status) = $charset->get_decode_handle
464 ($buffer, allow_error_reporting => 1,
465 allow_fallback => 1, byte_buffer => \$byte_buffer);
466 if ($char_stream) {
467 $buffer->{buffer} = $byte_buffer;
468 !!!parse-error (type => 'sniffing:chardet',
469 text => $charset_name,
470 level => $self->{level}->{info},
471 layer => 'encode',
472 line => 1, column => 1);
473 $self->{confident} = 0;
474 last SNIFFING;
475 }
476 }
477
478 ## Step 7: default
479 ## TODO: Make this configurable.
480 $charset = Message::Charset::Info->get_by_html_name ('windows-1252');
481 ## NOTE: We choose |windows-1252| here, since |utf-8| should be
482 ## detectable in the step 6.
483 require Whatpm::Charset::DecodeHandle;
484 $buffer = Whatpm::Charset::DecodeHandle::ByteBuffer->new
485 ($byte_stream);
486 ($char_stream, $e_status)
487 = $charset->get_decode_handle ($buffer,
488 allow_error_reporting => 1,
489 allow_fallback => 1,
490 byte_buffer => \$byte_buffer);
491 $buffer->{buffer} = $byte_buffer;
492 !!!parse-error (type => 'sniffing:default',
493 text => 'windows-1252',
494 level => $self->{level}->{info},
495 line => 1, column => 1,
496 layer => 'encode');
497 $self->{confident} = 0;
498 } # SNIFFING
499
500 if ($e_status & Message::Charset::Info::FALLBACK_ENCODING_IMPL ()) {
501 $self->{input_encoding} = $charset->get_iana_name; ## TODO: Should we set actual charset decoder's encoding name?
502 !!!parse-error (type => 'chardecode:fallback',
503 #text => $self->{input_encoding},
504 level => $self->{level}->{uncertain},
505 line => 1, column => 1,
506 layer => 'encode');
507 } elsif (not ($e_status &
508 Message::Charset::Info::ERROR_REPORTING_ENCODING_IMPL ())) {
509 $self->{input_encoding} = $charset->get_iana_name;
510 !!!parse-error (type => 'chardecode:no error',
511 text => $self->{input_encoding},
512 level => $self->{level}->{uncertain},
513 line => 1, column => 1,
514 layer => 'encode');
515 } else {
516 $self->{input_encoding} = $charset->get_iana_name;
517 }
518
519 $self->{change_encoding} = sub {
520 my $self = shift;
521 $charset_name = shift;
522 my $token = shift;
523
524 $charset = Message::Charset::Info->get_by_html_name ($charset_name);
525 ($char_stream, $e_status) = $charset->get_decode_handle
526 ($byte_stream, allow_error_reporting => 1, allow_fallback => 1,
527 byte_buffer => \ $buffer->{buffer});
528
529 if ($char_stream) { # if supported
530 ## "Change the encoding" algorithm:
531
532 ## Step 1
533 if (defined $self->{input_encoding} and
534 $self->{input_encoding} eq $charset_name) {
535 !!!parse-error (type => 'charset label:matching',
536 text => $charset_name,
537 level => $self->{level}->{info});
538 $self->{confident} = 1;
539 return;
540 }
541
542 ## Step 2 (HTML5 revision 3205)
543 if (defined $self->{input_encoding} and
544 Message::Charset::Info->get_by_html_name ($self->{input_encoding})
545 ->{category} & Message::Charset::Info::CHARSET_CATEGORY_UTF16 ()) {
546 $self->{confident} = 1;
547 return;
548 }
549
550 ## Step 3
551 if ($charset->{category} &
552 Message::Charset::Info::CHARSET_CATEGORY_UTF16 ()) {
553 $charset = Message::Charset::Info->get_by_html_name ('utf-8');
554 ($char_stream, $e_status) = $charset->get_decode_handle
555 ($byte_stream,
556 byte_buffer => \ $buffer->{buffer});
557 }
558 $charset_name = $charset->get_iana_name;
559
560 !!!parse-error (type => 'charset label detected',
561 text => $self->{input_encoding},
562 value => $charset_name,
563 level => $self->{level}->{warn},
564 token => $token);
565
566 ## Step 4
567 # if (can) {
568 ## change the encoding on the fly.
569 #$self->{confident} = 1;
570 #return;
571 # }
572
573 ## Step 5
574 throw Whatpm::HTML::RestartParser ();
575 }
576 }; # $self->{change_encoding}
577
578 my $char_onerror = sub {
579 my (undef, $type, %opt) = @_;
580 !!!parse-error (layer => 'encode',
581 line => $self->{line}, column => $self->{column} + 1,
582 %opt, type => $type);
583 if ($opt{octets}) {
584 ${$opt{octets}} = "\x{FFFD}"; # relacement character
585 }
586 };
587
588 my $wrapped_char_stream = $get_wrapper->($char_stream);
589 $wrapped_char_stream->onerror ($char_onerror);
590
591 my @args = ($_[1], $_[2]); # $doc, $onerror - $get_wrapper = undef;
592 my $return;
593 try {
594 $return = $self->parse_char_stream ($wrapped_char_stream, @args);
595 } catch Whatpm::HTML::RestartParser with {
596 ## NOTE: Invoked after {change_encoding}.
597
598 if ($e_status & Message::Charset::Info::FALLBACK_ENCODING_IMPL ()) {
599 $self->{input_encoding} = $charset->get_iana_name; ## TODO: Should we set actual charset decoder's encoding name?
600 !!!parse-error (type => 'chardecode:fallback',
601 level => $self->{level}->{uncertain},
602 #text => $self->{input_encoding},
603 line => 1, column => 1,
604 layer => 'encode');
605 } elsif (not ($e_status &
606 Message::Charset::Info::ERROR_REPORTING_ENCODING_IMPL ())) {
607 $self->{input_encoding} = $charset->get_iana_name;
608 !!!parse-error (type => 'chardecode:no error',
609 text => $self->{input_encoding},
610 level => $self->{level}->{uncertain},
611 line => 1, column => 1,
612 layer => 'encode');
613 } else {
614 $self->{input_encoding} = $charset->get_iana_name;
615 }
616 $self->{confident} = 1;
617
618 $wrapped_char_stream = $get_wrapper->($char_stream);
619 $wrapped_char_stream->onerror ($char_onerror);
620
621 $return = $self->parse_char_stream ($wrapped_char_stream, @args);
622 };
623 return $return;
624 } # parse_byte_stream
625
626 ## NOTE: HTML5 spec says that the encoding layer MUST NOT strip BOM
627 ## and the HTML layer MUST ignore it. However, we does strip BOM in
628 ## the encoding layer and the HTML layer does not ignore any U+FEFF,
629 ## because the core part of our HTML parser expects a string of character,
630 ## not a string of bytes or code units or anything which might contain a BOM.
631 ## Therefore, any parser interface that accepts a string of bytes,
632 ## such as |parse_byte_string| in this module, must ensure that it does
633 ## strip the BOM and never strip any ZWNBSP.
634
635 sub parse_char_string ($$$;$$) {
636 #my ($self, $s, $doc, $onerror, $get_wrapper) = @_;
637 my $self = shift;
638 my $s = ref $_[0] ? $_[0] : \($_[0]);
639 require Whatpm::Charset::DecodeHandle;
640 my $input = Whatpm::Charset::DecodeHandle::CharString->new ($s);
641 return $self->parse_char_stream ($input, @_[1..$#_]);
642 } # parse_char_string
643 *parse_string = \&parse_char_string; ## NOTE: Alias for backward compatibility.
644
645 sub parse_char_stream ($$$;$$) {
646 my $self = ref $_[0] ? shift : shift->new;
647 my $input = $_[0];
648 $self->{document} = $_[1];
649 @{$self->{document}->child_nodes} = ();
650
651 ## NOTE: |set_inner_html| copies most of this method's code
652
653 ## Confidence: irrelevant.
654 $self->{confident} = 1 unless exists $self->{confident};
655
656 $self->{document}->input_encoding ($self->{input_encoding})
657 if defined $self->{input_encoding};
658 ## TODO: |{input_encoding}| is needless?
659
660 $self->{line_prev} = $self->{line} = 1;
661 $self->{column_prev} = -1;
662 $self->{column} = 0;
663 $self->{set_nc} = sub {
664 my $self = shift;
665
666 my $char = '';
667 if (defined $self->{next_nc}) {
668 $char = $self->{next_nc};
669 delete $self->{next_nc};
670 $self->{nc} = ord $char;
671 } else {
672 $self->{char_buffer} = '';
673 $self->{char_buffer_pos} = 0;
674
675 my $count = $input->manakai_read_until
676 ($self->{char_buffer}, qr/[^\x00\x0A\x0D]/, $self->{char_buffer_pos});
677 if ($count) {
678 $self->{line_prev} = $self->{line};
679 $self->{column_prev} = $self->{column};
680 $self->{column}++;
681 $self->{nc}
682 = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
683 return;
684 }
685
686 if ($input->read ($char, 1)) {
687 $self->{nc} = ord $char;
688 } else {
689 $self->{nc} = -1;
690 return;
691 }
692 }
693
694 ($self->{line_prev}, $self->{column_prev})
695 = ($self->{line}, $self->{column});
696 $self->{column}++;
697
698 if ($self->{nc} == 0x000A) { # LF
699 !!!cp ('j1');
700 $self->{line}++;
701 $self->{column} = 0;
702 } elsif ($self->{nc} == 0x000D) { # CR
703 !!!cp ('j2');
704 ## TODO: support for abort/streaming
705 my $next = '';
706 if ($input->read ($next, 1) and $next ne "\x0A") {
707 $self->{next_nc} = $next;
708 }
709 $self->{nc} = 0x000A; # LF # MUST
710 $self->{line}++;
711 $self->{column} = 0;
712 } elsif ($self->{nc} == 0x0000) { # NULL
713 !!!cp ('j4');
714 !!!parse-error (type => 'NULL');
715 $self->{nc} = 0xFFFD; # REPLACEMENT CHARACTER # MUST
716 }
717 };
718
719 $self->{read_until} = sub {
720 #my ($scalar, $specials_range, $offset) = @_;
721 return 0 if defined $self->{next_nc};
722
723 my $pattern = qr/[^$_[1]\x00\x0A\x0D]/;
724 my $offset = $_[2] || 0;
725
726 if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
727 pos ($self->{char_buffer}) = $self->{char_buffer_pos};
728 if ($self->{char_buffer} =~ /\G(?>$pattern)+/) {
729 substr ($_[0], $offset)
730 = substr ($self->{char_buffer}, $-[0], $+[0] - $-[0]);
731 my $count = $+[0] - $-[0];
732 if ($count) {
733 $self->{column} += $count;
734 $self->{char_buffer_pos} += $count;
735 $self->{line_prev} = $self->{line};
736 $self->{column_prev} = $self->{column} - 1;
737 $self->{nc} = -1;
738 }
739 return $count;
740 } else {
741 return 0;
742 }
743 } else {
744 my $count = $input->manakai_read_until ($_[0], $pattern, $_[2]);
745 if ($count) {
746 $self->{column} += $count;
747 $self->{line_prev} = $self->{line};
748 $self->{column_prev} = $self->{column} - 1;
749 $self->{nc} = -1;
750 }
751 return $count;
752 }
753 }; # $self->{read_until}
754
755 my $onerror = $_[2] || sub {
756 my (%opt) = @_;
757 my $line = $opt{token} ? $opt{token}->{line} : $opt{line};
758 my $column = $opt{token} ? $opt{token}->{column} : $opt{column};
759 warn "Parse error ($opt{type}) at line $line column $column\n";
760 };
761 $self->{parse_error} = sub {
762 $onerror->(line => $self->{line}, column => $self->{column}, @_);
763 };
764
765 my $char_onerror = sub {
766 my (undef, $type, %opt) = @_;
767 !!!parse-error (layer => 'encode',
768 line => $self->{line}, column => $self->{column} + 1,
769 %opt, type => $type);
770 }; # $char_onerror
771
772 if ($_[3]) {
773 $input = $_[3]->($input);
774 $input->onerror ($char_onerror);
775 } else {
776 $input->onerror ($char_onerror) unless defined $input->onerror;
777 }
778
779 $self->_initialize_tokenizer;
780 $self->_initialize_tree_constructor;
781 $self->_construct_tree;
782 $self->_terminate_tree_constructor;
783
784 delete $self->{parse_error}; # remove loop
785
786 return $self->{document};
787 } # parse_char_stream
788
789 sub new ($) {
790 my $class = shift;
791 my $self = bless {
792 level => {must => 'm',
793 should => 's',
794 warn => 'w',
795 info => 'i',
796 uncertain => 'u'},
797 }, $class;
798 $self->{set_nc} = sub {
799 $self->{nc} = -1;
800 };
801 $self->{parse_error} = sub {
802 #
803 };
804 $self->{change_encoding} = sub {
805 # if ($_[0] is a supported encoding) {
806 # run "change the encoding" algorithm;
807 # throw Whatpm::HTML::RestartParser (charset => $new_encoding);
808 # }
809 };
810 $self->{application_cache_selection} = sub {
811 #
812 };
813 return $self;
814 } # new
815
816 ## Insertion modes
817
818 sub AFTER_HTML_IMS () { 0b100 }
819 sub HEAD_IMS () { 0b1000 }
820 sub BODY_IMS () { 0b10000 }
821 sub BODY_TABLE_IMS () { 0b100000 }
822 sub TABLE_IMS () { 0b1000000 }
823 sub ROW_IMS () { 0b10000000 }
824 sub BODY_AFTER_IMS () { 0b100000000 }
825 sub FRAME_IMS () { 0b1000000000 }
826 sub SELECT_IMS () { 0b10000000000 }
827 #sub IN_FOREIGN_CONTENT_IM () { 0b100000000000 } # see Whatpm::HTML::Tokenizer
828 ## NOTE: "in foreign content" insertion mode is special; it is combined
829 ## with the secondary insertion mode. In this parser, they are stored
830 ## together in the bit-or'ed form.
831 sub IN_CDATA_RCDATA_IM () { 0b1000000000000 }
832 ## NOTE: "in CDATA/RCDATA" insertion mode is also special; it is
833 ## combined with the original insertion mode. In thie parser,
834 ## they are stored together in the bit-or'ed form.
835
836 sub IM_MASK () { 0b11111111111 }
837
838 ## NOTE: "initial" and "before html" insertion modes have no constants.
839
840 ## NOTE: "after after body" insertion mode.
841 sub AFTER_HTML_BODY_IM () { AFTER_HTML_IMS | BODY_AFTER_IMS }
842
843 ## NOTE: "after after frameset" insertion mode.
844 sub AFTER_HTML_FRAMESET_IM () { AFTER_HTML_IMS | FRAME_IMS }
845
846 sub IN_HEAD_IM () { HEAD_IMS | 0b00 }
847 sub IN_HEAD_NOSCRIPT_IM () { HEAD_IMS | 0b01 }
848 sub AFTER_HEAD_IM () { HEAD_IMS | 0b10 }
849 sub BEFORE_HEAD_IM () { HEAD_IMS | 0b11 }
850 sub IN_BODY_IM () { BODY_IMS }
851 sub IN_CELL_IM () { BODY_IMS | BODY_TABLE_IMS | 0b01 }
852 sub IN_CAPTION_IM () { BODY_IMS | BODY_TABLE_IMS | 0b10 }
853 sub IN_ROW_IM () { TABLE_IMS | ROW_IMS | 0b01 }
854 sub IN_TABLE_BODY_IM () { TABLE_IMS | ROW_IMS | 0b10 }
855 sub IN_TABLE_IM () { TABLE_IMS }
856 sub AFTER_BODY_IM () { BODY_AFTER_IMS }
857 sub IN_FRAMESET_IM () { FRAME_IMS | 0b01 }
858 sub AFTER_FRAMESET_IM () { FRAME_IMS | 0b10 }
859 sub IN_SELECT_IM () { SELECT_IMS | 0b01 }
860 sub IN_SELECT_IN_TABLE_IM () { SELECT_IMS | 0b10 }
861 sub IN_COLUMN_GROUP_IM () { 0b10 }
862
863 sub _initialize_tree_constructor ($) {
864 my $self = shift;
865 ## NOTE: $self->{document} MUST be specified before this method is called
866 $self->{document}->strict_error_checking (0);
867 ## TODO: Turn mutation events off # MUST
868 ## TODO: Turn loose Document option (manakai extension) on
869 $self->{document}->manakai_is_html (1); # MUST
870 $self->{document}->set_user_data (manakai_source_line => 1);
871 $self->{document}->set_user_data (manakai_source_column => 1);
872 } # _initialize_tree_constructor
873
874 sub _terminate_tree_constructor ($) {
875 my $self = shift;
876 $self->{document}->strict_error_checking (1);
877 ## TODO: Turn mutation events on
878 } # _terminate_tree_constructor
879
880 ## ISSUE: Should append_child (for example) in script executed in tree construction stage fire mutation events?
881
882 { # tree construction stage
883 my $token;
884
885 sub _construct_tree ($) {
886 my ($self) = @_;
887
888 ## When an interactive UA render the $self->{document} available
889 ## to the user, or when it begin accepting user input, are
890 ## not defined.
891
892 !!!next-token;
893
894 undef $self->{form_element};
895 undef $self->{head_element};
896 undef $self->{head_element_inserted};
897 $self->{open_elements} = [];
898 undef $self->{inner_html_node};
899 undef $self->{ignore_newline};
900
901 ## NOTE: The "initial" insertion mode.
902 $self->_tree_construction_initial; # MUST
903
904 ## NOTE: The "before html" insertion mode.
905 $self->_tree_construction_root_element;
906 $self->{insertion_mode} = BEFORE_HEAD_IM;
907
908 ## NOTE: The "before head" insertion mode and so on.
909 $self->_tree_construction_main;
910 } # _construct_tree
911
912 sub _tree_construction_initial ($) {
913 my $self = shift;
914
915 ## NOTE: "initial" insertion mode
916
917 INITIAL: {
918 if ($token->{type} == DOCTYPE_TOKEN) {
919 ## NOTE: Conformance checkers MAY, instead of reporting "not
920 ## HTML5" error, switch to a conformance checking mode for
921 ## another language. (We don't support such mode switchings; it
922 ## is nonsense to do anything different from what browsers do.)
923 my $doctype_name = $token->{name};
924 $doctype_name = '' unless defined $doctype_name;
925 my $doctype = $self->{document}->create_document_type_definition
926 ($doctype_name);
927
928 $doctype_name =~ tr/A-Z/a-z/; # ASCII case-insensitive
929 if ($doctype_name ne 'html') {
930 !!!cp ('t1');
931 !!!parse-error (type => 'not HTML5', token => $token);
932 } elsif (defined $token->{pubid}) {
933 !!!cp ('t2');
934 ## XXX Obsolete permitted DOCTYPEs
935 !!!parse-error (type => 'not HTML5', token => $token);
936 } elsif (defined $token->{sysid}) {
937 if ($token->{sysid} eq 'about:legacy-compat') {
938 !!!cp ('t1.2'); ## <!DOCTYPE HTML SYSTEM "about:legacy-compat">
939 !!!parse-error (type => 'XSLT-compat', token => $token,
940 level => $self->{level}->{should});
941 } else {
942 !!!parse-error (type => 'not HTML5', token => $token);
943 }
944 } else { ## <!DOCTYPE HTML>
945 !!!cp ('t3');
946 #
947 }
948
949 ## NOTE: Default value for both |public_id| and |system_id| attributes
950 ## are empty strings, so that we don't set any value in missing cases.
951 $doctype->public_id ($token->{pubid}) if defined $token->{pubid};
952 $doctype->system_id ($token->{sysid}) if defined $token->{sysid};
953
954 ## NOTE: Other DocumentType attributes are null or empty lists.
955 ## In Firefox3, |internalSubset| attribute is set to the empty
956 ## string, while |null| is an allowed value for the attribute
957 ## according to DOM3 Core.
958 $self->{document}->append_child ($doctype);
959
960 if ($token->{quirks} or $doctype_name ne 'html') {
961 !!!cp ('t4');
962 $self->{document}->manakai_compat_mode ('quirks');
963 } elsif (defined $token->{pubid}) {
964 my $pubid = $token->{pubid};
965 $pubid =~ tr/a-z/A-z/;
966 my $prefix = [
967 "+//SILMARIL//DTD HTML PRO V0R11 19970101//",
968 "-//ADVASOFT LTD//DTD HTML 3.0 ASWEDIT + EXTENSIONS//",
969 "-//AS//DTD HTML 3.0 ASWEDIT + EXTENSIONS//",
970 "-//IETF//DTD HTML 2.0 LEVEL 1//",
971 "-//IETF//DTD HTML 2.0 LEVEL 2//",
972 "-//IETF//DTD HTML 2.0 STRICT LEVEL 1//",
973 "-//IETF//DTD HTML 2.0 STRICT LEVEL 2//",
974 "-//IETF//DTD HTML 2.0 STRICT//",
975 "-//IETF//DTD HTML 2.0//",
976 "-//IETF//DTD HTML 2.1E//",
977 "-//IETF//DTD HTML 3.0//",
978 "-//IETF//DTD HTML 3.2 FINAL//",
979 "-//IETF//DTD HTML 3.2//",
980 "-//IETF//DTD HTML 3//",
981 "-//IETF//DTD HTML LEVEL 0//",
982 "-//IETF//DTD HTML LEVEL 1//",
983 "-//IETF//DTD HTML LEVEL 2//",
984 "-//IETF//DTD HTML LEVEL 3//",
985 "-//IETF//DTD HTML STRICT LEVEL 0//",
986 "-//IETF//DTD HTML STRICT LEVEL 1//",
987 "-//IETF//DTD HTML STRICT LEVEL 2//",
988 "-//IETF//DTD HTML STRICT LEVEL 3//",
989 "-//IETF//DTD HTML STRICT//",
990 "-//IETF//DTD HTML//",
991 "-//METRIUS//DTD METRIUS PRESENTATIONAL//",
992 "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML STRICT//",
993 "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML//",
994 "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 TABLES//",
995 "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML STRICT//",
996 "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML//",
997 "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 TABLES//",
998 "-//NETSCAPE COMM. CORP.//DTD HTML//",
999 "-//NETSCAPE COMM. CORP.//DTD STRICT HTML//",
1000 "-//O'REILLY AND ASSOCIATES//DTD HTML 2.0//",
1001 "-//O'REILLY AND ASSOCIATES//DTD HTML EXTENDED 1.0//",
1002 "-//O'REILLY AND ASSOCIATES//DTD HTML EXTENDED RELAXED 1.0//",
1003 "-//SOFTQUAD SOFTWARE//DTD HOTMETAL PRO 6.0::19990601::EXTENSIONS TO HTML 4.0//",
1004 "-//SOFTQUAD//DTD HOTMETAL PRO 4.0::19971010::EXTENSIONS TO HTML 4.0//",
1005 "-//SPYGLASS//DTD HTML 2.0 EXTENDED//",
1006 "-//SQ//DTD HTML 2.0 HOTMETAL + EXTENSIONS//",
1007 "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA HTML//",
1008 "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA STRICT HTML//",
1009 "-//W3C//DTD HTML 3 1995-03-24//",
1010 "-//W3C//DTD HTML 3.2 DRAFT//",
1011 "-//W3C//DTD HTML 3.2 FINAL//",
1012 "-//W3C//DTD HTML 3.2//",
1013 "-//W3C//DTD HTML 3.2S DRAFT//",
1014 "-//W3C//DTD HTML 4.0 FRAMESET//",
1015 "-//W3C//DTD HTML 4.0 TRANSITIONAL//",
1016 "-//W3C//DTD HTML EXPERIMETNAL 19960712//",
1017 "-//W3C//DTD HTML EXPERIMENTAL 970421//",
1018 "-//W3C//DTD W3 HTML//",
1019 "-//W3O//DTD W3 HTML 3.0//",
1020 "-//WEBTECHS//DTD MOZILLA HTML 2.0//",
1021 "-//WEBTECHS//DTD MOZILLA HTML//",
1022 ]; # $prefix
1023 my $match;
1024 for (@$prefix) {
1025 if (substr ($prefix, 0, length $_) eq $_) {
1026 $match = 1;
1027 last;
1028 }
1029 }
1030 if ($match or
1031 $pubid eq "-//W3O//DTD W3 HTML STRICT 3.0//EN//" or
1032 $pubid eq "-/W3C/DTD HTML 4.0 TRANSITIONAL/EN" or
1033 $pubid eq "HTML") {
1034 !!!cp ('t5');
1035 $self->{document}->manakai_compat_mode ('quirks');
1036 } elsif ($pubid =~ m[^-//W3C//DTD HTML 4.01 FRAMESET//] or
1037 $pubid =~ m[^-//W3C//DTD HTML 4.01 TRANSITIONAL//]) {
1038 if (defined $token->{sysid}) {
1039 !!!cp ('t6');
1040 $self->{document}->manakai_compat_mode ('quirks');
1041 } else {
1042 !!!cp ('t7');
1043 $self->{document}->manakai_compat_mode ('limited quirks');
1044 }
1045 } elsif ($pubid =~ m[^-//W3C//DTD XHTML 1.0 FRAMESET//] or
1046 $pubid =~ m[^-//W3C//DTD XHTML 1.0 TRANSITIONAL//]) {
1047 !!!cp ('t8');
1048 $self->{document}->manakai_compat_mode ('limited quirks');
1049 } else {
1050 !!!cp ('t9');
1051 }
1052 } else {
1053 !!!cp ('t10');
1054 }
1055 if (defined $token->{sysid}) {
1056 my $sysid = $token->{sysid};
1057 $sysid =~ tr/A-Z/a-z/;
1058 if ($sysid eq "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd") {
1059 ## NOTE: Ensure that |PUBLIC "(limited quirks)" "(quirks)"| is
1060 ## marked as quirks.
1061 $self->{document}->manakai_compat_mode ('quirks');
1062 !!!cp ('t11');
1063 } else {
1064 !!!cp ('t12');
1065 }
1066 } else {
1067 !!!cp ('t13');
1068 }
1069
1070 ## Go to the "before html" insertion mode.
1071 !!!next-token;
1072 return;
1073 } elsif ({
1074 START_TAG_TOKEN, 1,
1075 END_TAG_TOKEN, 1,
1076 END_OF_FILE_TOKEN, 1,
1077 }->{$token->{type}}) {
1078 !!!cp ('t14');
1079 !!!parse-error (type => 'no DOCTYPE', token => $token);
1080 $self->{document}->manakai_compat_mode ('quirks');
1081 ## Go to the "before html" insertion mode.
1082 ## reprocess
1083 !!!ack-later;
1084 return;
1085 } elsif ($token->{type} == CHARACTER_TOKEN) {
1086 if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
1087 ## Ignore the token
1088
1089 unless (length $token->{data}) {
1090 !!!cp ('t15');
1091 ## Stay in the insertion mode.
1092 !!!next-token;
1093 redo INITIAL;
1094 } else {
1095 !!!cp ('t16');
1096 }
1097 } else {
1098 !!!cp ('t17');
1099 }
1100
1101 !!!parse-error (type => 'no DOCTYPE', token => $token);
1102 $self->{document}->manakai_compat_mode ('quirks');
1103 ## Go to the "before html" insertion mode.
1104 ## reprocess
1105 return;
1106 } elsif ($token->{type} == COMMENT_TOKEN) {
1107 !!!cp ('t18');
1108 my $comment = $self->{document}->create_comment ($token->{data});
1109 $self->{document}->append_child ($comment);
1110
1111 ## Stay in the insertion mode.
1112 !!!next-token;
1113 redo INITIAL;
1114 } else {
1115 die "$0: $token->{type}: Unknown token type";
1116 }
1117 } # INITIAL
1118
1119 die "$0: _tree_construction_initial: This should be never reached";
1120 } # _tree_construction_initial
1121
1122 sub _tree_construction_root_element ($) {
1123 my $self = shift;
1124
1125 ## NOTE: "before html" insertion mode.
1126
1127 B: {
1128 if ($token->{type} == DOCTYPE_TOKEN) {
1129 !!!cp ('t19');
1130 !!!parse-error (type => 'in html:#DOCTYPE', token => $token);
1131 ## Ignore the token
1132 ## Stay in the insertion mode.
1133 !!!next-token;
1134 redo B;
1135 } elsif ($token->{type} == COMMENT_TOKEN) {
1136 !!!cp ('t20');
1137 my $comment = $self->{document}->create_comment ($token->{data});
1138 $self->{document}->append_child ($comment);
1139 ## Stay in the insertion mode.
1140 !!!next-token;
1141 redo B;
1142 } elsif ($token->{type} == CHARACTER_TOKEN) {
1143 if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
1144 ## Ignore the token.
1145
1146 unless (length $token->{data}) {
1147 !!!cp ('t21');
1148 ## Stay in the insertion mode.
1149 !!!next-token;
1150 redo B;
1151 } else {
1152 !!!cp ('t22');
1153 }
1154 } else {
1155 !!!cp ('t23');
1156 }
1157
1158 $self->{application_cache_selection}->(undef);
1159
1160 #
1161 } elsif ($token->{type} == START_TAG_TOKEN) {
1162 if ($token->{tag_name} eq 'html') {
1163 my $root_element;
1164 !!!create-element ($root_element, $HTML_NS, $token->{tag_name}, $token->{attributes}, $token);
1165 $self->{document}->append_child ($root_element);
1166 push @{$self->{open_elements}},
1167 [$root_element, $el_category->{html}];
1168
1169 if ($token->{attributes}->{manifest}) {
1170 !!!cp ('t24');
1171 $self->{application_cache_selection}
1172 ->($token->{attributes}->{manifest}->{value});
1173 ## ISSUE: Spec is unclear on relative references.
1174 ## According to Hixie (#whatwg 2008-03-19), it should be
1175 ## resolved against the base URI of the document in HTML
1176 ## or xml:base of the element in XHTML.
1177 } else {
1178 !!!cp ('t25');
1179 $self->{application_cache_selection}->(undef);
1180 }
1181
1182 !!!nack ('t25c');
1183
1184 !!!next-token;
1185 return; ## Go to the "before head" insertion mode.
1186 } else {
1187 !!!cp ('t25.1');
1188 #
1189 }
1190 } elsif ({
1191 END_TAG_TOKEN, 1,
1192 END_OF_FILE_TOKEN, 1,
1193 }->{$token->{type}}) {
1194 !!!cp ('t26');
1195 #
1196 } else {
1197 die "$0: $token->{type}: Unknown token type";
1198 }
1199
1200 my $root_element;
1201 !!!create-element ($root_element, $HTML_NS, 'html',, $token);
1202 $self->{document}->append_child ($root_element);
1203 push @{$self->{open_elements}}, [$root_element, $el_category->{html}];
1204
1205 $self->{application_cache_selection}->(undef);
1206
1207 ## NOTE: Reprocess the token.
1208 !!!ack-later;
1209 return; ## Go to the "before head" insertion mode.
1210 } # B
1211
1212 die "$0: _tree_construction_root_element: This should never be reached";
1213 } # _tree_construction_root_element
1214
1215 sub _reset_insertion_mode ($) {
1216 my $self = shift;
1217
1218 ## Step 1
1219 my $last;
1220
1221 ## Step 2
1222 my $i = -1;
1223 my $node = $self->{open_elements}->[$i];
1224
1225 ## Step 3
1226 S3: {
1227 if ($self->{open_elements}->[0]->[0] eq $node->[0]) {
1228 $last = 1;
1229 if (defined $self->{inner_html_node}) {
1230 !!!cp ('t28');
1231 $node = $self->{inner_html_node};
1232 } else {
1233 die "_reset_insertion_mode: t27";
1234 }
1235 }
1236
1237 ## Step 4..14
1238 my $new_mode;
1239 if ($node->[1] & FOREIGN_EL) {
1240 !!!cp ('t28.1');
1241 ## NOTE: Strictly spaking, the line below only applies to MathML and
1242 ## SVG elements. Currently the HTML syntax supports only MathML and
1243 ## SVG elements as foreigners.
1244 $new_mode = IN_BODY_IM | IN_FOREIGN_CONTENT_IM;
1245 } elsif ($node->[1] == TABLE_CELL_EL) {
1246 if ($last) {
1247 !!!cp ('t28.2');
1248 #
1249 } else {
1250 !!!cp ('t28.3');
1251 $new_mode = IN_CELL_IM;
1252 }
1253 } else {
1254 !!!cp ('t28.4');
1255 $new_mode = {
1256 select => IN_SELECT_IM,
1257 ## NOTE: |option| and |optgroup| do not set
1258 ## insertion mode to "in select" by themselves.
1259 tr => IN_ROW_IM,
1260 tbody => IN_TABLE_BODY_IM,
1261 thead => IN_TABLE_BODY_IM,
1262 tfoot => IN_TABLE_BODY_IM,
1263 caption => IN_CAPTION_IM,
1264 colgroup => IN_COLUMN_GROUP_IM,
1265 table => IN_TABLE_IM,
1266 head => IN_BODY_IM, # not in head!
1267 body => IN_BODY_IM,
1268 frameset => IN_FRAMESET_IM,
1269 }->{$node->[0]->manakai_local_name};
1270 }
1271 $self->{insertion_mode} = $new_mode and return if defined $new_mode;
1272
1273 ## Step 15
1274 if ($node->[1] == HTML_EL) {
1275 unless (defined $self->{head_element}) {
1276 !!!cp ('t29');
1277 $self->{insertion_mode} = BEFORE_HEAD_IM;
1278 } else {
1279 ## ISSUE: Can this state be reached?
1280 !!!cp ('t30');
1281 $self->{insertion_mode} = AFTER_HEAD_IM;
1282 }
1283 return;
1284 } else {
1285 !!!cp ('t31');
1286 }
1287
1288 ## Step 16
1289 $self->{insertion_mode} = IN_BODY_IM and return if $last;
1290
1291 ## Step 17
1292 $i--;
1293 $node = $self->{open_elements}->[$i];
1294
1295 ## Step 18
1296 redo S3;
1297 } # S3
1298
1299 die "$0: _reset_insertion_mode: This line should never be reached";
1300 } # _reset_insertion_mode
1301
1302 sub _tree_construction_main ($) {
1303 my $self = shift;
1304
1305 my $active_formatting_elements = [];
1306
1307 my $reconstruct_active_formatting_elements = sub { # MUST
1308 my $insert = shift;
1309
1310 ## Step 1
1311 return unless @$active_formatting_elements;
1312
1313 ## Step 3
1314 my $i = -1;
1315 my $entry = $active_formatting_elements->[$i];
1316
1317 ## Step 2
1318 return if $entry->[0] eq '#marker';
1319 for (@{$self->{open_elements}}) {
1320 if ($entry->[0] eq $_->[0]) {
1321 !!!cp ('t32');
1322 return;
1323 }
1324 }
1325
1326 S4: {
1327 ## Step 4
1328 last S4 if $active_formatting_elements->[0]->[0] eq $entry->[0];
1329
1330 ## Step 5
1331 $i--;
1332 $entry = $active_formatting_elements->[$i];
1333
1334 ## Step 6
1335 if ($entry->[0] eq '#marker') {
1336 !!!cp ('t33_1');
1337 #
1338 } else {
1339 my $in_open_elements;
1340 OE: for (@{$self->{open_elements}}) {
1341 if ($entry->[0] eq $_->[0]) {
1342 !!!cp ('t33');
1343 $in_open_elements = 1;
1344 last OE;
1345 }
1346 }
1347 if ($in_open_elements) {
1348 !!!cp ('t34');
1349 #
1350 } else {
1351 ## NOTE: <!DOCTYPE HTML><p><b><i><u></p> <p>X
1352 !!!cp ('t35');
1353 redo S4;
1354 }
1355 }
1356
1357 ## Step 7
1358 $i++;
1359 $entry = $active_formatting_elements->[$i];
1360 } # S4
1361
1362 S7: {
1363 ## Step 8
1364 my $clone = [$entry->[0]->clone_node (0), $entry->[1]];
1365
1366 ## Step 9
1367 $insert->($clone->[0]);
1368 push @{$self->{open_elements}}, $clone;
1369
1370 ## Step 10
1371 $active_formatting_elements->[$i] = $self->{open_elements}->[-1];
1372
1373 ## Step 11
1374 unless ($clone->[0] eq $active_formatting_elements->[-1]->[0]) {
1375 !!!cp ('t36');
1376 ## Step 7'
1377 $i++;
1378 $entry = $active_formatting_elements->[$i];
1379
1380 redo S7;
1381 }
1382
1383 !!!cp ('t37');
1384 } # S7
1385 }; # $reconstruct_active_formatting_elements
1386
1387 my $clear_up_to_marker = sub {
1388 for (reverse 0..$#$active_formatting_elements) {
1389 if ($active_formatting_elements->[$_]->[0] eq '#marker') {
1390 !!!cp ('t38');
1391 splice @$active_formatting_elements, $_;
1392 return;
1393 }
1394 }
1395
1396 !!!cp ('t39');
1397 }; # $clear_up_to_marker
1398
1399 my $insert;
1400
1401 my $parse_rcdata = sub ($) {
1402 my ($content_model_flag) = @_;
1403
1404 ## Step 1
1405 my $start_tag_name = $token->{tag_name};
1406 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
1407
1408 ## Step 2
1409 $self->{content_model} = $content_model_flag; # CDATA or RCDATA
1410 delete $self->{escape}; # MUST
1411
1412 ## Step 3, 4
1413 $self->{insertion_mode} |= IN_CDATA_RCDATA_IM;
1414
1415 !!!nack ('t40.1');
1416 !!!next-token;
1417 }; # $parse_rcdata
1418
1419 my $script_start_tag = sub () {
1420 ## Step 1
1421 my $script_el;
1422 !!!create-element ($script_el, $HTML_NS, 'script', $token->{attributes}, $token);
1423
1424 ## Step 2
1425 ## TODO: mark as "parser-inserted"
1426
1427 ## Step 3
1428 ## TODO: Mark as "already executed", if ...
1429
1430 ## Step 4 (HTML5 revision 2702)
1431 $insert->($script_el);
1432 push @{$self->{open_elements}}, [$script_el, $el_category->{script}];
1433
1434 ## Step 5
1435 $self->{content_model} = CDATA_CONTENT_MODEL;
1436 delete $self->{escape}; # MUST
1437
1438 ## Step 6-7
1439 $self->{insertion_mode} |= IN_CDATA_RCDATA_IM;
1440
1441 !!!nack ('t40.2');
1442 !!!next-token;
1443 }; # $script_start_tag
1444
1445 ## NOTE: $open_tables->[-1]->[0] is the "current table" element node.
1446 ## NOTE: $open_tables->[-1]->[1] is the "tainted" flag (OBSOLETE; unused).
1447 ## NOTE: $open_tables->[-1]->[2] is set false when non-Text node inserted.
1448 my $open_tables = [[$self->{open_elements}->[0]->[0]]];
1449
1450 my $formatting_end_tag = sub {
1451 my $end_tag_token = shift;
1452 my $tag_name = $end_tag_token->{tag_name};
1453
1454 ## NOTE: The adoption agency algorithm (AAA).
1455
1456 FET: {
1457 ## Step 1
1458 my $formatting_element;
1459 my $formatting_element_i_in_active;
1460 AFE: for (reverse 0..$#$active_formatting_elements) {
1461 if ($active_formatting_elements->[$_]->[0] eq '#marker') {
1462 !!!cp ('t52');
1463 last AFE;
1464 } elsif ($active_formatting_elements->[$_]->[0]->manakai_local_name
1465 eq $tag_name) {
1466 !!!cp ('t51');
1467 $formatting_element = $active_formatting_elements->[$_];
1468 $formatting_element_i_in_active = $_;
1469 last AFE;
1470 }
1471 } # AFE
1472 unless (defined $formatting_element) {
1473 !!!cp ('t53');
1474 !!!parse-error (type => 'unmatched end tag', text => $tag_name, token => $end_tag_token);
1475 ## Ignore the token
1476 !!!next-token;
1477 return;
1478 }
1479 ## has an element in scope
1480 my $in_scope = 1;
1481 my $formatting_element_i_in_open;
1482 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
1483 my $node = $self->{open_elements}->[$_];
1484 if ($node->[0] eq $formatting_element->[0]) {
1485 if ($in_scope) {
1486 !!!cp ('t54');
1487 $formatting_element_i_in_open = $_;
1488 last INSCOPE;
1489 } else { # in open elements but not in scope
1490 !!!cp ('t55');
1491 !!!parse-error (type => 'unmatched end tag',
1492 text => $token->{tag_name},
1493 token => $end_tag_token);
1494 ## Ignore the token
1495 !!!next-token;
1496 return;
1497 }
1498 } elsif ($node->[1] & SCOPING_EL) {
1499 !!!cp ('t56');
1500 $in_scope = 0;
1501 }
1502 } # INSCOPE
1503 unless (defined $formatting_element_i_in_open) {
1504 !!!cp ('t57');
1505 !!!parse-error (type => 'unmatched end tag',
1506 text => $token->{tag_name},
1507 token => $end_tag_token);
1508 pop @$active_formatting_elements; # $formatting_element
1509 !!!next-token; ## TODO: ok?
1510 return;
1511 }
1512 if (not $self->{open_elements}->[-1]->[0] eq $formatting_element->[0]) {
1513 !!!cp ('t58');
1514 !!!parse-error (type => 'not closed',
1515 text => $self->{open_elements}->[-1]->[0]
1516 ->manakai_local_name,
1517 token => $end_tag_token);
1518 }
1519
1520 ## Step 2
1521 my $furthest_block;
1522 my $furthest_block_i_in_open;
1523 OE: for (reverse 0..$#{$self->{open_elements}}) {
1524 my $node = $self->{open_elements}->[$_];
1525 if (not ($node->[1] & FORMATTING_EL) and
1526 #not $phrasing_category->{$node->[1]} and
1527 ($node->[1] & SPECIAL_EL or
1528 $node->[1] & SCOPING_EL)) { ## Scoping is redundant, maybe
1529 !!!cp ('t59');
1530 $furthest_block = $node;
1531 $furthest_block_i_in_open = $_;
1532 ## NOTE: The topmost (eldest) node.
1533 } elsif ($node->[0] eq $formatting_element->[0]) {
1534 !!!cp ('t60');
1535 last OE;
1536 }
1537 } # OE
1538
1539 ## Step 3
1540 unless (defined $furthest_block) { # MUST
1541 !!!cp ('t61');
1542 splice @{$self->{open_elements}}, $formatting_element_i_in_open;
1543 splice @$active_formatting_elements, $formatting_element_i_in_active, 1;
1544 !!!next-token;
1545 return;
1546 }
1547
1548 ## Step 4
1549 my $common_ancestor_node = $self->{open_elements}->[$formatting_element_i_in_open - 1];
1550
1551 ## Step 5
1552 my $furthest_block_parent = $furthest_block->[0]->parent_node;
1553 if (defined $furthest_block_parent) {
1554 !!!cp ('t62');
1555 $furthest_block_parent->remove_child ($furthest_block->[0]);
1556 }
1557
1558 ## Step 6
1559 my $bookmark_prev_el
1560 = $active_formatting_elements->[$formatting_element_i_in_active - 1]
1561 ->[0];
1562
1563 ## Step 7
1564 my $node = $furthest_block;
1565 my $node_i_in_open = $furthest_block_i_in_open;
1566 my $last_node = $furthest_block;
1567 S7: {
1568 ## Step 1
1569 $node_i_in_open--;
1570 $node = $self->{open_elements}->[$node_i_in_open];
1571
1572 ## Step 2
1573 my $node_i_in_active;
1574 S7S2: {
1575 for (reverse 0..$#$active_formatting_elements) {
1576 if ($active_formatting_elements->[$_]->[0] eq $node->[0]) {
1577 !!!cp ('t63');
1578 $node_i_in_active = $_;
1579 last S7S2;
1580 }
1581 }
1582 splice @{$self->{open_elements}}, $node_i_in_open, 1;
1583 redo S7;
1584 } # S7S2
1585
1586 ## Step 3
1587 last S7 if $node->[0] eq $formatting_element->[0];
1588
1589 ## Step 4
1590 if ($last_node->[0] eq $furthest_block->[0]) {
1591 !!!cp ('t64');
1592 $bookmark_prev_el = $node->[0];
1593 }
1594
1595 ## Step 5
1596 if ($node->[0]->has_child_nodes ()) {
1597 !!!cp ('t65');
1598 my $clone = [$node->[0]->clone_node (0), $node->[1]];
1599 $active_formatting_elements->[$node_i_in_active] = $clone;
1600 $self->{open_elements}->[$node_i_in_open] = $clone;
1601 $node = $clone;
1602 }
1603
1604 ## Step 6
1605 $node->[0]->append_child ($last_node->[0]);
1606
1607 ## Step 7
1608 $last_node = $node;
1609
1610 ## Step 8
1611 redo S7;
1612 } # S7
1613
1614 ## Step 8
1615 if ($common_ancestor_node->[1] & TABLE_ROWS_EL) {
1616 ## Foster parenting.
1617 my $foster_parent_element;
1618 my $next_sibling;
1619 OE: for (reverse 0..$#{$self->{open_elements}}) {
1620 if ($self->{open_elements}->[$_]->[1] == TABLE_EL) {
1621 !!!cp ('t65.2');
1622 $foster_parent_element = $self->{open_elements}->[$_ - 1]->[0];
1623 $next_sibling = $self->{open_elements}->[$_]->[0];
1624 undef $next_sibling
1625 unless $next_sibling->parent_node eq $foster_parent_element;
1626 last OE;
1627 }
1628 } # OE
1629 $foster_parent_element ||= $self->{open_elements}->[0]->[0];
1630
1631 $foster_parent_element->insert_before ($last_node->[0], $next_sibling);
1632 $open_tables->[-1]->[1] = 1; # tainted
1633 } else {
1634 !!!cp ('t65.3');
1635 $common_ancestor_node->[0]->append_child ($last_node->[0]);
1636 }
1637
1638 ## Step 9
1639 my $clone = [$formatting_element->[0]->clone_node (0),
1640 $formatting_element->[1]];
1641
1642 ## Step 10
1643 my @cn = @{$furthest_block->[0]->child_nodes};
1644 $clone->[0]->append_child ($_) for @cn;
1645
1646 ## Step 11
1647 $furthest_block->[0]->append_child ($clone->[0]);
1648
1649 ## Step 12
1650 my $i;
1651 AFE: for (reverse 0..$#$active_formatting_elements) {
1652 if ($active_formatting_elements->[$_]->[0] eq $formatting_element->[0]) {
1653 !!!cp ('t66');
1654 splice @$active_formatting_elements, $_, 1;
1655 $i-- and last AFE if defined $i;
1656 } elsif ($active_formatting_elements->[$_]->[0] eq $bookmark_prev_el) {
1657 !!!cp ('t67');
1658 $i = $_;
1659 }
1660 } # AFE
1661 splice @$active_formatting_elements, $i + 1, 0, $clone;
1662
1663 ## Step 13
1664 undef $i;
1665 OE: for (reverse 0..$#{$self->{open_elements}}) {
1666 if ($self->{open_elements}->[$_]->[0] eq $formatting_element->[0]) {
1667 !!!cp ('t68');
1668 splice @{$self->{open_elements}}, $_, 1;
1669 $i-- and last OE if defined $i;
1670 } elsif ($self->{open_elements}->[$_]->[0] eq $furthest_block->[0]) {
1671 !!!cp ('t69');
1672 $i = $_;
1673 }
1674 } # OE
1675 splice @{$self->{open_elements}}, $i + 1, 0, $clone;
1676
1677 ## Step 14
1678 redo FET;
1679 } # FET
1680 }; # $formatting_end_tag
1681
1682 $insert = my $insert_to_current = sub {
1683 $self->{open_elements}->[-1]->[0]->append_child ($_[0]);
1684 }; # $insert_to_current
1685
1686 ## Foster parenting. Note that there are three "foster parenting"
1687 ## code in the parser: for elements (this one), for texts, and for
1688 ## elements in the AAA code.
1689 my $insert_to_foster = sub {
1690 my $child = shift;
1691 if ($self->{open_elements}->[-1]->[1] & TABLE_ROWS_EL) {
1692 # MUST
1693 my $foster_parent_element;
1694 my $next_sibling;
1695 OE: for (reverse 0..$#{$self->{open_elements}}) {
1696 if ($self->{open_elements}->[$_]->[1] == TABLE_EL) {
1697 !!!cp ('t71');
1698 $foster_parent_element = $self->{open_elements}->[$_ - 1]->[0];
1699 $next_sibling = $self->{open_elements}->[$_]->[0];
1700 undef $next_sibling
1701 unless $next_sibling->parent_node eq $foster_parent_element;
1702 last OE;
1703 }
1704 } # OE
1705 $foster_parent_element ||= $self->{open_elements}->[0]->[0];
1706
1707 $foster_parent_element->insert_before ($child, $next_sibling);
1708 $open_tables->[-1]->[1] = 1; # tainted
1709 } else {
1710 !!!cp ('t72');
1711 $self->{open_elements}->[-1]->[0]->append_child ($child);
1712 }
1713 }; # $insert_to_foster
1714
1715 ## NOTE: Insert a character (MUST): When a character is inserted, if
1716 ## the last node that was inserted by the parser is a Text node and
1717 ## the character has to be inserted after that node, then the
1718 ## character is appended to the Text node. However, if any other
1719 ## node is inserted by the parser, then a new Text node is created
1720 ## and the character is appended as that Text node. If I'm not
1721 ## wrong, for a parser with scripting disabled, there are only two
1722 ## cases where this occurs. One is the case where an element node
1723 ## is inserted to the |head| element. This is covered by using the
1724 ## |$self->{head_element_inserted}| flag. Another is the case where
1725 ## an element or comment is inserted into the |table| subtree while
1726 ## foster parenting happens. This is covered by using the [2] flag
1727 ## of the |$open_tables| structure. All other cases are handled
1728 ## simply by calling |manakai_append_text| method.
1729
1730 ## TODO: |<body><script>document.write("a<br>");
1731 ## document.body.removeChild (document.body.lastChild);
1732 ## document.write ("b")</script>|
1733
1734 B: while (1) {
1735
1736 ## The "in table text" insertion mode.
1737 if ($self->{insertion_mode} & TABLE_IMS and
1738 not $self->{insertion_mode} & IN_FOREIGN_CONTENT_IM and
1739 not $self->{insertion_mode} & IN_CDATA_RCDATA_IM) {
1740 C: {
1741 my $s;
1742 if ($token->{type} == CHARACTER_TOKEN) {
1743 !!!cp ('t194');
1744 $self->{pending_chars} ||= [];
1745 push @{$self->{pending_chars}}, $token;
1746 !!!next-token;
1747 next B;
1748 } else {
1749 if ($self->{pending_chars}) {
1750 $s = join '', map { $_->{data} } @{$self->{pending_chars}};
1751 delete $self->{pending_chars};
1752 if ($s =~ /[^\x09\x0A\x0C\x0D\x20]/) {
1753 !!!cp ('t195');
1754 #
1755 } else {
1756 !!!cp ('t195.1');
1757 #$self->{open_elements}->[-1]->[0]->manakai_append_text ($s);
1758 $self->{open_elements}->[-1]->[0]->append_child
1759 ($self->{document}->create_text_node ($s));
1760 last C;
1761 }
1762 } else {
1763 !!!cp ('t195.2');
1764 last C;
1765 }
1766 }
1767
1768 ## Foster parenting.
1769 !!!parse-error (type => 'in table:#text', token => $token);
1770
1771 ## NOTE: As if in body, but insert into the foster parent element.
1772 $reconstruct_active_formatting_elements->($insert_to_foster);
1773
1774 if ($self->{open_elements}->[-1]->[1] & TABLE_ROWS_EL) {
1775 # MUST
1776 my $foster_parent_element;
1777 my $next_sibling;
1778 OE: for (reverse 0..$#{$self->{open_elements}}) {
1779 if ($self->{open_elements}->[$_]->[1] == TABLE_EL) {
1780 !!!cp ('t197');
1781 $foster_parent_element = $self->{open_elements}->[$_ - 1]->[0];
1782 $next_sibling = $self->{open_elements}->[$_]->[0];
1783 undef $next_sibling
1784 unless $next_sibling->parent_node eq $foster_parent_element;
1785 last OE;
1786 }
1787 } # OE
1788 $foster_parent_element ||= $self->{open_elements}->[0]->[0];
1789
1790 !!!cp ('t199');
1791 $foster_parent_element->insert_before
1792 ($self->{document}->create_text_node ($s), $next_sibling);
1793
1794 $open_tables->[-1]->[1] = 1; # tainted
1795 $open_tables->[-1]->[2] = 1; # ~node inserted
1796 } else {
1797 ## NOTE: Fragment case or in a foster parent'ed element
1798 ## (e.g. |<table><span>a|). In fragment case, whether the
1799 ## character is appended to existing node or a new node is
1800 ## created is irrelevant, since the foster parent'ed nodes
1801 ## are discarded and fragment parsing does not invoke any
1802 ## script.
1803 !!!cp ('t200');
1804 $self->{open_elements}->[-1]->[0]->manakai_append_text ($s);
1805 }
1806 } # C
1807 } # TABLE_IMS
1808
1809 if ($token->{type} == DOCTYPE_TOKEN) {
1810 !!!cp ('t73');
1811 !!!parse-error (type => 'in html:#DOCTYPE', token => $token);
1812 ## Ignore the token
1813 ## Stay in the phase
1814 !!!next-token;
1815 next B;
1816 } elsif ($token->{type} == START_TAG_TOKEN and
1817 $token->{tag_name} eq 'html') {
1818 if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
1819 !!!cp ('t79');
1820 !!!parse-error (type => 'after html', text => 'html', token => $token);
1821 $self->{insertion_mode} = AFTER_BODY_IM;
1822 } elsif ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
1823 !!!cp ('t80');
1824 !!!parse-error (type => 'after html', text => 'html', token => $token);
1825 $self->{insertion_mode} = AFTER_FRAMESET_IM;
1826 } else {
1827 !!!cp ('t81');
1828 }
1829
1830 !!!cp ('t82');
1831 !!!parse-error (type => 'not first start tag', token => $token);
1832 my $top_el = $self->{open_elements}->[0]->[0];
1833 for my $attr_name (keys %{$token->{attributes}}) {
1834 unless ($top_el->has_attribute_ns (undef, $attr_name)) {
1835 !!!cp ('t84');
1836 $top_el->set_attribute_ns
1837 (undef, [undef, $attr_name],
1838 $token->{attributes}->{$attr_name}->{value});
1839 }
1840 }
1841 !!!nack ('t84.1');
1842 !!!next-token;
1843 next B;
1844 } elsif ($token->{type} == COMMENT_TOKEN) {
1845 my $comment = $self->{document}->create_comment ($token->{data});
1846 if ($self->{insertion_mode} & AFTER_HTML_IMS) {
1847 !!!cp ('t85');
1848 $self->{document}->append_child ($comment);
1849 } elsif ($self->{insertion_mode} == AFTER_BODY_IM) {
1850 !!!cp ('t86');
1851 $self->{open_elements}->[0]->[0]->append_child ($comment);
1852 } else {
1853 !!!cp ('t87');
1854 $self->{open_elements}->[-1]->[0]->append_child ($comment);
1855 $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
1856 }
1857 !!!next-token;
1858 next B;
1859 } elsif ($self->{insertion_mode} & IN_CDATA_RCDATA_IM) {
1860 if ($token->{type} == CHARACTER_TOKEN) {
1861 $token->{data} =~ s/^\x0A// if $self->{ignore_newline};
1862 delete $self->{ignore_newline};
1863
1864 if (length $token->{data}) {
1865 !!!cp ('t43');
1866 $self->{open_elements}->[-1]->[0]->manakai_append_text
1867 ($token->{data});
1868 } else {
1869 !!!cp ('t43.1');
1870 }
1871 !!!next-token;
1872 next B;
1873 } elsif ($token->{type} == END_TAG_TOKEN) {
1874 delete $self->{ignore_newline};
1875
1876 if ($token->{tag_name} eq 'script') {
1877 !!!cp ('t50');
1878
1879 ## Para 1-2
1880 my $script = pop @{$self->{open_elements}};
1881
1882 ## Para 3
1883 $self->{insertion_mode} &= ~ IN_CDATA_RCDATA_IM;
1884
1885 ## Para 4
1886 ## TODO: $old_insertion_point = $current_insertion_point;
1887 ## TODO: $current_insertion_point = just before $self->{nc};
1888
1889 ## Para 5
1890 ## TODO: Run the $script->[0].
1891
1892 ## Para 6
1893 ## TODO: $current_insertion_point = $old_insertion_point;
1894
1895 ## Para 7
1896 ## TODO: if ($pending_external_script) {
1897 ## TODO: ...
1898 ## TODO: }
1899
1900 !!!next-token;
1901 next B;
1902 } else {
1903 !!!cp ('t42');
1904
1905 pop @{$self->{open_elements}};
1906
1907 $self->{insertion_mode} &= ~ IN_CDATA_RCDATA_IM;
1908 !!!next-token;
1909 next B;
1910 }
1911 } elsif ($token->{type} == END_OF_FILE_TOKEN) {
1912 delete $self->{ignore_newline};
1913
1914 !!!cp ('t44');
1915 !!!parse-error (type => 'not closed',
1916 text => $self->{open_elements}->[-1]->[0]
1917 ->manakai_local_name,
1918 token => $token);
1919
1920 #if ($self->{open_elements}->[-1]->[1] == SCRIPT_EL) {
1921 # ## TODO: Mark as "already executed"
1922 #}
1923
1924 pop @{$self->{open_elements}};
1925
1926 $self->{insertion_mode} &= ~ IN_CDATA_RCDATA_IM;
1927 ## Reprocess.
1928 next B;
1929 } else {
1930 die "$0: $token->{type}: In CDATA/RCDATA: Unknown token type";
1931 }
1932 } elsif ($self->{insertion_mode} & IN_FOREIGN_CONTENT_IM) {
1933 if ($token->{type} == CHARACTER_TOKEN) {
1934 !!!cp ('t87.1');
1935 $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});
1936 !!!next-token;
1937 next B;
1938 } elsif ($token->{type} == START_TAG_TOKEN) {
1939 if ((not {mglyph => 1, malignmark => 1}->{$token->{tag_name}} and
1940 $self->{open_elements}->[-1]->[1] & FOREIGN_FLOW_CONTENT_EL) or
1941 not ($self->{open_elements}->[-1]->[1] & FOREIGN_EL) or
1942 ($token->{tag_name} eq 'svg' and
1943 $self->{open_elements}->[-1]->[1] == MML_AXML_EL)) {
1944 ## NOTE: "using the rules for secondary insertion mode"then"continue"
1945 !!!cp ('t87.2');
1946 #
1947 } elsif ({
1948 b => 1, big => 1, blockquote => 1, body => 1, br => 1,
1949 center => 1, code => 1, dd => 1, div => 1, dl => 1, dt => 1,
1950 em => 1, embed => 1, h1 => 1, h2 => 1, h3 => 1,
1951 h4 => 1, h5 => 1, h6 => 1, head => 1, hr => 1, i => 1,
1952 img => 1, li => 1, listing => 1, menu => 1, meta => 1,
1953 nobr => 1, ol => 1, p => 1, pre => 1, ruby => 1, s => 1,
1954 small => 1, span => 1, strong => 1, strike => 1, sub => 1,
1955 sup => 1, table => 1, tt => 1, u => 1, ul => 1, var => 1,
1956 }->{$token->{tag_name}} or
1957 ($token->{tag_name} eq 'font' and
1958 ($token->{attributes}->{color} or
1959 $token->{attributes}->{face} or
1960 $token->{attributes}->{size}))) {
1961 !!!cp ('t87.2');
1962 !!!parse-error (type => 'not closed',
1963 text => $self->{open_elements}->[-1]->[0]
1964 ->manakai_local_name,
1965 token => $token);
1966
1967 pop @{$self->{open_elements}}
1968 while $self->{open_elements}->[-1]->[1] & FOREIGN_EL;
1969
1970 $self->{insertion_mode} &= ~ IN_FOREIGN_CONTENT_IM;
1971 ## Reprocess.
1972 next B;
1973 } else {
1974 my $nsuri = $self->{open_elements}->[-1]->[0]->namespace_uri;
1975 my $tag_name = $token->{tag_name};
1976 if ($nsuri eq $SVG_NS) {
1977 $tag_name = {
1978 altglyph => 'altGlyph',
1979 altglyphdef => 'altGlyphDef',
1980 altglyphitem => 'altGlyphItem',
1981 animatecolor => 'animateColor',
1982 animatemotion => 'animateMotion',
1983 animatetransform => 'animateTransform',
1984 clippath => 'clipPath',
1985 feblend => 'feBlend',
1986 fecolormatrix => 'feColorMatrix',
1987 fecomponenttransfer => 'feComponentTransfer',
1988 fecomposite => 'feComposite',
1989 feconvolvematrix => 'feConvolveMatrix',
1990 fediffuselighting => 'feDiffuseLighting',
1991 fedisplacementmap => 'feDisplacementMap',
1992 fedistantlight => 'feDistantLight',
1993 feflood => 'feFlood',
1994 fefunca => 'feFuncA',
1995 fefuncb => 'feFuncB',
1996 fefuncg => 'feFuncG',
1997 fefuncr => 'feFuncR',
1998 fegaussianblur => 'feGaussianBlur',
1999 feimage => 'feImage',
2000 femerge => 'feMerge',
2001 femergenode => 'feMergeNode',
2002 femorphology => 'feMorphology',
2003 feoffset => 'feOffset',
2004 fepointlight => 'fePointLight',
2005 fespecularlighting => 'feSpecularLighting',
2006 fespotlight => 'feSpotLight',
2007 fetile => 'feTile',
2008 feturbulence => 'feTurbulence',
2009 foreignobject => 'foreignObject',
2010 glyphref => 'glyphRef',
2011 lineargradient => 'linearGradient',
2012 radialgradient => 'radialGradient',
2013 #solidcolor => 'solidColor', ## NOTE: Commented in spec (SVG1.2)
2014 textpath => 'textPath',
2015 }->{$tag_name} || $tag_name;
2016 }
2017
2018 ## "adjust SVG attributes" (SVG only) - done in insert-element-f
2019
2020 ## "adjust foreign attributes" - done in insert-element-f
2021
2022 !!!insert-element-f ($nsuri, $tag_name, $token->{attributes}, $token);
2023
2024 if ($self->{self_closing}) {
2025 pop @{$self->{open_elements}};
2026 !!!ack ('t87.3');
2027 } else {
2028 !!!cp ('t87.4');
2029 }
2030
2031 !!!next-token;
2032 next B;
2033 }
2034 } elsif ($token->{type} == END_TAG_TOKEN) {
2035 ## NOTE: "using the rules for secondary insertion mode" then "continue"
2036 if ($token->{tag_name} eq 'script') {
2037 !!!cp ('t87.41');
2038 #
2039 ## XXXscript: Execute script here.
2040 } else {
2041 !!!cp ('t87.5');
2042 #
2043 }
2044 } elsif ($token->{type} == END_OF_FILE_TOKEN) {
2045 !!!cp ('t87.6');
2046 !!!parse-error (type => 'not closed',
2047 text => $self->{open_elements}->[-1]->[0]
2048 ->manakai_local_name,
2049 token => $token);
2050
2051 pop @{$self->{open_elements}}
2052 while $self->{open_elements}->[-1]->[1] & FOREIGN_EL;
2053
2054 ## NOTE: |<span><svg>| ... two parse errors, |<svg>| ... a parse error.
2055
2056 $self->{insertion_mode} &= ~ IN_FOREIGN_CONTENT_IM;
2057 ## Reprocess.
2058 next B;
2059 } else {
2060 die "$0: $token->{type}: Unknown token type";
2061 }
2062 }
2063
2064 if ($self->{insertion_mode} & HEAD_IMS) {
2065 if ($token->{type} == CHARACTER_TOKEN) {
2066 if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
2067 unless ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2068 if ($self->{head_element_inserted}) {
2069 !!!cp ('t88.3');
2070 $self->{open_elements}->[-1]->[0]->append_child
2071 ($self->{document}->create_text_node ($1));
2072 delete $self->{head_element_inserted};
2073 ## NOTE: |</head> <link> |
2074 #
2075 } else {
2076 !!!cp ('t88.2');
2077 $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
2078 ## NOTE: |</head> &#x20;|
2079 #
2080 }
2081 } else {
2082 !!!cp ('t88.1');
2083 ## Ignore the token.
2084 #
2085 }
2086 unless (length $token->{data}) {
2087 !!!cp ('t88');
2088 !!!next-token;
2089 next B;
2090 }
2091 ## TODO: set $token->{column} appropriately
2092 }
2093
2094 if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2095 !!!cp ('t89');
2096 ## As if <head>
2097 !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token);
2098 $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2099 push @{$self->{open_elements}},
2100 [$self->{head_element}, $el_category->{head}];
2101
2102 ## Reprocess in the "in head" insertion mode...
2103 pop @{$self->{open_elements}};
2104
2105 ## Reprocess in the "after head" insertion mode...
2106 } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2107 !!!cp ('t90');
2108 ## As if </noscript>
2109 pop @{$self->{open_elements}};
2110 !!!parse-error (type => 'in noscript:#text', token => $token);
2111
2112 ## Reprocess in the "in head" insertion mode...
2113 ## As if </head>
2114 pop @{$self->{open_elements}};
2115
2116 ## Reprocess in the "after head" insertion mode...
2117 } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2118 !!!cp ('t91');
2119 pop @{$self->{open_elements}};
2120
2121 ## Reprocess in the "after head" insertion mode...
2122 } else {
2123 !!!cp ('t92');
2124 }
2125
2126 ## "after head" insertion mode
2127 ## As if <body>
2128 !!!insert-element ('body',, $token);
2129 $self->{insertion_mode} = IN_BODY_IM;
2130 ## reprocess
2131 next B;
2132 } elsif ($token->{type} == START_TAG_TOKEN) {
2133 if ($token->{tag_name} eq 'head') {
2134 if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2135 !!!cp ('t93');
2136 !!!create-element ($self->{head_element}, $HTML_NS, $token->{tag_name}, $token->{attributes}, $token);
2137 $self->{open_elements}->[-1]->[0]->append_child
2138 ($self->{head_element});
2139 push @{$self->{open_elements}},
2140 [$self->{head_element}, $el_category->{head}];
2141 $self->{insertion_mode} = IN_HEAD_IM;
2142 !!!nack ('t93.1');
2143 !!!next-token;
2144 next B;
2145 } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2146 !!!cp ('t93.2');
2147 !!!parse-error (type => 'after head', text => 'head',
2148 token => $token);
2149 ## Ignore the token
2150 !!!nack ('t93.3');
2151 !!!next-token;
2152 next B;
2153 } else {
2154 !!!cp ('t95');
2155 !!!parse-error (type => 'in head:head',
2156 token => $token); # or in head noscript
2157 ## Ignore the token
2158 !!!nack ('t95.1');
2159 !!!next-token;
2160 next B;
2161 }
2162 } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2163 !!!cp ('t96');
2164 ## As if <head>
2165 !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token);
2166 $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2167 push @{$self->{open_elements}},
2168 [$self->{head_element}, $el_category->{head}];
2169
2170 $self->{insertion_mode} = IN_HEAD_IM;
2171 ## Reprocess in the "in head" insertion mode...
2172 } else {
2173 !!!cp ('t97');
2174 }
2175
2176 if ($token->{tag_name} eq 'base') {
2177 if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2178 !!!cp ('t98');
2179 ## As if </noscript>
2180 pop @{$self->{open_elements}};
2181 !!!parse-error (type => 'in noscript', text => 'base',
2182 token => $token);
2183
2184 $self->{insertion_mode} = IN_HEAD_IM;
2185 ## Reprocess in the "in head" insertion mode...
2186 } else {
2187 !!!cp ('t99');
2188 }
2189
2190 ## NOTE: There is a "as if in head" code clone.
2191 if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2192 !!!cp ('t100');
2193 !!!parse-error (type => 'after head',
2194 text => $token->{tag_name}, token => $token);
2195 push @{$self->{open_elements}},
2196 [$self->{head_element}, $el_category->{head}];
2197 $self->{head_element_inserted} = 1;
2198 } else {
2199 !!!cp ('t101');
2200 }
2201 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
2202 pop @{$self->{open_elements}};
2203 pop @{$self->{open_elements}} # <head>
2204 if $self->{insertion_mode} == AFTER_HEAD_IM;
2205 !!!nack ('t101.1');
2206 !!!next-token;
2207 next B;
2208 } elsif ($token->{tag_name} eq 'link') {
2209 ## NOTE: There is a "as if in head" code clone.
2210 if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2211 !!!cp ('t102');
2212 !!!parse-error (type => 'after head',
2213 text => $token->{tag_name}, token => $token);
2214 push @{$self->{open_elements}},
2215 [$self->{head_element}, $el_category->{head}];
2216 $self->{head_element_inserted} = 1;
2217 } else {
2218 !!!cp ('t103');
2219 }
2220 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
2221 pop @{$self->{open_elements}};
2222 pop @{$self->{open_elements}} # <head>
2223 if $self->{insertion_mode} == AFTER_HEAD_IM;
2224 !!!ack ('t103.1');
2225 !!!next-token;
2226 next B;
2227 } elsif ($token->{tag_name} eq 'command') {
2228 if ($self->{insertion_mode} == IN_HEAD_IM) {
2229 ## NOTE: If the insertion mode at the time of the emission
2230 ## of the token was "before head", $self->{insertion_mode}
2231 ## is already changed to |IN_HEAD_IM|.
2232
2233 ## NOTE: There is a "as if in head" code clone.
2234 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
2235 pop @{$self->{open_elements}};
2236 pop @{$self->{open_elements}} # <head>
2237 if $self->{insertion_mode} == AFTER_HEAD_IM;
2238 !!!ack ('t103.2');
2239 !!!next-token;
2240 next B;
2241 } else {
2242 ## NOTE: "in head noscript" or "after head" insertion mode
2243 ## - in these cases, these tags are treated as same as
2244 ## normal in-body tags.
2245 !!!cp ('t103.3');
2246 #
2247 }
2248 } elsif ($token->{tag_name} eq 'meta') {
2249 ## NOTE: There is a "as if in head" code clone.
2250 if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2251 !!!cp ('t104');
2252 !!!parse-error (type => 'after head',
2253 text => $token->{tag_name}, token => $token);
2254 push @{$self->{open_elements}},
2255 [$self->{head_element}, $el_category->{head}];
2256 $self->{head_element_inserted} = 1;
2257 } else {
2258 !!!cp ('t105');
2259 }
2260 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
2261 my $meta_el = pop @{$self->{open_elements}};
2262
2263 unless ($self->{confident}) {
2264 if ($token->{attributes}->{charset}) {
2265 !!!cp ('t106');
2266 ## NOTE: Whether the encoding is supported or not is handled
2267 ## in the {change_encoding} callback.
2268 $self->{change_encoding}
2269 ->($self, $token->{attributes}->{charset}->{value},
2270 $token);
2271
2272 $meta_el->[0]->get_attribute_node_ns (undef, 'charset')
2273 ->set_user_data (manakai_has_reference =>
2274 $token->{attributes}->{charset}
2275 ->{has_reference});
2276 } elsif ($token->{attributes}->{content}) {
2277 if ($token->{attributes}->{content}->{value}
2278 =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt]
2279 [\x09\x0A\x0C\x0D\x20]*=
2280 [\x09\x0A\x0C\x0D\x20]*(?>"([^"]*)"|'([^']*)'|
2281 ([^"'\x09\x0A\x0C\x0D\x20]
2282 [^\x09\x0A\x0C\x0D\x20\x3B]*))/x) {
2283 !!!cp ('t107');
2284 ## NOTE: Whether the encoding is supported or not is handled
2285 ## in the {change_encoding} callback.
2286 $self->{change_encoding}
2287 ->($self, defined $1 ? $1 : defined $2 ? $2 : $3,
2288 $token);
2289 $meta_el->[0]->get_attribute_node_ns (undef, 'content')
2290 ->set_user_data (manakai_has_reference =>
2291 $token->{attributes}->{content}
2292 ->{has_reference});
2293 } else {
2294 !!!cp ('t108');
2295 }
2296 }
2297 } else {
2298 if ($token->{attributes}->{charset}) {
2299 !!!cp ('t109');
2300 $meta_el->[0]->get_attribute_node_ns (undef, 'charset')
2301 ->set_user_data (manakai_has_reference =>
2302 $token->{attributes}->{charset}
2303 ->{has_reference});
2304 }
2305 if ($token->{attributes}->{content}) {
2306 !!!cp ('t110');
2307 $meta_el->[0]->get_attribute_node_ns (undef, 'content')
2308 ->set_user_data (manakai_has_reference =>
2309 $token->{attributes}->{content}
2310 ->{has_reference});
2311 }
2312 }
2313
2314 pop @{$self->{open_elements}} # <head>
2315 if $self->{insertion_mode} == AFTER_HEAD_IM;
2316 !!!ack ('t110.1');
2317 !!!next-token;
2318 next B;
2319 } elsif ($token->{tag_name} eq 'title') {
2320 if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2321 !!!cp ('t111');
2322 ## As if </noscript>
2323 pop @{$self->{open_elements}};
2324 !!!parse-error (type => 'in noscript', text => 'title',
2325 token => $token);
2326
2327 $self->{insertion_mode} = IN_HEAD_IM;
2328 ## Reprocess in the "in head" insertion mode...
2329 } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2330 !!!cp ('t112');
2331 !!!parse-error (type => 'after head',
2332 text => $token->{tag_name}, token => $token);
2333 push @{$self->{open_elements}},
2334 [$self->{head_element}, $el_category->{head}];
2335 $self->{head_element_inserted} = 1;
2336 } else {
2337 !!!cp ('t113');
2338 }
2339
2340 ## NOTE: There is a "as if in head" code clone.
2341 $parse_rcdata->(RCDATA_CONTENT_MODEL);
2342
2343 ## NOTE: At this point the stack of open elements contain
2344 ## the |head| element (index == -2) and the |script| element
2345 ## (index == -1). In the "after head" insertion mode the
2346 ## |head| element is inserted only for the purpose of
2347 ## providing the context for the |script| element, and
2348 ## therefore we can now and have to remove the element from
2349 ## the stack.
2350 splice @{$self->{open_elements}}, -2, 1, () # <head>
2351 if ($self->{insertion_mode} & IM_MASK) == AFTER_HEAD_IM;
2352 next B;
2353 } elsif ($token->{tag_name} eq 'style' or
2354 $token->{tag_name} eq 'noframes') {
2355 ## NOTE: Or (scripting is enabled and tag_name eq 'noscript' and
2356 ## insertion mode IN_HEAD_IM)
2357 ## NOTE: There is a "as if in head" code clone.
2358 if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2359 !!!cp ('t114');
2360 !!!parse-error (type => 'after head',
2361 text => $token->{tag_name}, token => $token);
2362 push @{$self->{open_elements}},
2363 [$self->{head_element}, $el_category->{head}];
2364 $self->{head_element_inserted} = 1;
2365 } else {
2366 !!!cp ('t115');
2367 }
2368 $parse_rcdata->(CDATA_CONTENT_MODEL);
2369 ## ISSUE: A spec bug [Bug 6038]
2370 splice @{$self->{open_elements}}, -2, 1, () # <head>
2371 if ($self->{insertion_mode} & IM_MASK) == AFTER_HEAD_IM;
2372 next B;
2373 } elsif ($token->{tag_name} eq 'noscript') {
2374 if ($self->{insertion_mode} == IN_HEAD_IM) {
2375 !!!cp ('t116');
2376 ## NOTE: and scripting is disalbed
2377 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
2378 $self->{insertion_mode} = IN_HEAD_NOSCRIPT_IM;
2379 !!!nack ('t116.1');
2380 !!!next-token;
2381 next B;
2382 } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2383 !!!cp ('t117');
2384 !!!parse-error (type => 'in noscript', text => 'noscript',
2385 token => $token);
2386 ## Ignore the token
2387 !!!nack ('t117.1');
2388 !!!next-token;
2389 next B;
2390 } else {
2391 !!!cp ('t118');
2392 #
2393 }
2394 } elsif ($token->{tag_name} eq 'script') {
2395 if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2396 !!!cp ('t119');
2397 ## As if </noscript>
2398 pop @{$self->{open_elements}};
2399 !!!parse-error (type => 'in noscript', text => 'script',
2400 token => $token);
2401
2402 $self->{insertion_mode} = IN_HEAD_IM;
2403 ## Reprocess in the "in head" insertion mode...
2404 } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2405 !!!cp ('t120');
2406 !!!parse-error (type => 'after head',
2407 text => $token->{tag_name}, token => $token);
2408 push @{$self->{open_elements}},
2409 [$self->{head_element}, $el_category->{head}];
2410 $self->{head_element_inserted} = 1;
2411 } else {
2412 !!!cp ('t121');
2413 }
2414
2415 ## NOTE: There is a "as if in head" code clone.
2416 $script_start_tag->();
2417 ## ISSUE: A spec bug [Bug 6038]
2418 splice @{$self->{open_elements}}, -2, 1 # <head>
2419 if ($self->{insertion_mode} & IM_MASK) == AFTER_HEAD_IM;
2420 next B;
2421 } elsif ($token->{tag_name} eq 'body' or
2422 $token->{tag_name} eq 'frameset') {
2423 if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2424 !!!cp ('t122');
2425 ## As if </noscript>
2426 pop @{$self->{open_elements}};
2427 !!!parse-error (type => 'in noscript',
2428 text => $token->{tag_name}, token => $token);
2429
2430 ## Reprocess in the "in head" insertion mode...
2431 ## As if </head>
2432 pop @{$self->{open_elements}};
2433
2434 ## Reprocess in the "after head" insertion mode...
2435 } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2436 !!!cp ('t124');
2437 pop @{$self->{open_elements}};
2438
2439 ## Reprocess in the "after head" insertion mode...
2440 } else {
2441 !!!cp ('t125');
2442 }
2443
2444 ## "after head" insertion mode
2445 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
2446 if ($token->{tag_name} eq 'body') {
2447 !!!cp ('t126');
2448 $self->{insertion_mode} = IN_BODY_IM;
2449 } elsif ($token->{tag_name} eq 'frameset') {
2450 !!!cp ('t127');
2451 $self->{insertion_mode} = IN_FRAMESET_IM;
2452 } else {
2453 die "$0: tag name: $self->{tag_name}";
2454 }
2455 !!!nack ('t127.1');
2456 !!!next-token;
2457 next B;
2458 } else {
2459 !!!cp ('t128');
2460 #
2461 }
2462
2463 if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2464 !!!cp ('t129');
2465 ## As if </noscript>
2466 pop @{$self->{open_elements}};
2467 !!!parse-error (type => 'in noscript:/',
2468 text => $token->{tag_name}, token => $token);
2469
2470 ## Reprocess in the "in head" insertion mode...
2471 ## As if </head>
2472 pop @{$self->{open_elements}};
2473
2474 ## Reprocess in the "after head" insertion mode...
2475 } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2476 !!!cp ('t130');
2477 ## As if </head>
2478 pop @{$self->{open_elements}};
2479
2480 ## Reprocess in the "after head" insertion mode...
2481 } else {
2482 !!!cp ('t131');
2483 }
2484
2485 ## "after head" insertion mode
2486 ## As if <body>
2487 !!!insert-element ('body',, $token);
2488 $self->{insertion_mode} = IN_BODY_IM;
2489 ## reprocess
2490 !!!ack-later;
2491 next B;
2492 } elsif ($token->{type} == END_TAG_TOKEN) {
2493 ## "Before head", "in head", and "after head" insertion modes
2494 ## ignore most of end tags. Exceptions are "body", "html",
2495 ## and "br" end tags. "Before head" and "in head" insertion
2496 ## modes also recognize "head" end tag. "In head noscript"
2497 ## insertion modes ignore end tags except for "noscript" and
2498 ## "br".
2499
2500 if ($token->{tag_name} eq 'head') {
2501 if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2502 !!!cp ('t132');
2503 ## As if <head>
2504 !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token);
2505 $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2506 push @{$self->{open_elements}},
2507 [$self->{head_element}, $el_category->{head}];
2508
2509 ## Reprocess in the "in head" insertion mode...
2510 pop @{$self->{open_elements}};
2511 $self->{insertion_mode} = AFTER_HEAD_IM;
2512 !!!next-token;
2513 next B;
2514 } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2515 !!!cp ('t133');
2516 #
2517 } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2518 !!!cp ('t134');
2519 pop @{$self->{open_elements}};
2520 $self->{insertion_mode} = AFTER_HEAD_IM;
2521 !!!next-token;
2522 next B;
2523 } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2524 !!!cp ('t134.1');
2525 #
2526 } else {
2527 die "$0: $self->{insertion_mode}: Unknown insertion mode";
2528 }
2529 } elsif ($token->{tag_name} eq 'noscript') {
2530 if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2531 !!!cp ('t136');
2532 pop @{$self->{open_elements}};
2533 $self->{insertion_mode} = IN_HEAD_IM;
2534 !!!next-token;
2535 next B;
2536 } else {
2537 !!!cp ('t138');
2538 #
2539 }
2540 } elsif ({
2541 body => ($self->{insertion_mode} != IN_HEAD_NOSCRIPT_IM),
2542 html => ($self->{insertion_mode} != IN_HEAD_NOSCRIPT_IM),
2543 br => 1,
2544 }->{$token->{tag_name}}) {
2545 if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2546 !!!cp ('t142.2');
2547 ## (before head) as if <head>, (in head) as if </head>
2548 !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token);
2549 $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2550 $self->{insertion_mode} = AFTER_HEAD_IM;
2551
2552 ## Reprocess in the "after head" insertion mode...
2553 } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2554 !!!cp ('t143.2');
2555 ## As if </head>
2556 pop @{$self->{open_elements}};
2557 $self->{insertion_mode} = AFTER_HEAD_IM;
2558
2559 ## Reprocess in the "after head" insertion mode...
2560 } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2561 !!!cp ('t143.3');
2562 ## NOTE: Two parse errors for <head><noscript></br>
2563 !!!parse-error (type => 'unmatched end tag',
2564 text => $token->{tag_name}, token => $token);
2565 ## As if </noscript>
2566 pop @{$self->{open_elements}};
2567 $self->{insertion_mode} = IN_HEAD_IM;
2568
2569 ## Reprocess in the "in head" insertion mode...
2570 ## As if </head>
2571 pop @{$self->{open_elements}};
2572 $self->{insertion_mode} = AFTER_HEAD_IM;
2573
2574 ## Reprocess in the "after head" insertion mode...
2575 } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2576 !!!cp ('t143.4');
2577 #
2578 } else {
2579 die "$0: $self->{insertion_mode}: Unknown insertion mode";
2580 }
2581
2582 ## "after head" insertion mode
2583 ## As if <body>
2584 !!!insert-element ('body',, $token);
2585 $self->{insertion_mode} = IN_BODY_IM;
2586 ## Reprocess.
2587 next B;
2588 }
2589
2590 ## End tags are ignored by default.
2591 !!!cp ('t145');
2592 !!!parse-error (type => 'unmatched end tag',
2593 text => $token->{tag_name}, token => $token);
2594 ## Ignore the token.
2595 !!!next-token;
2596 next B;
2597 } elsif ($token->{type} == END_OF_FILE_TOKEN) {
2598 if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2599 !!!cp ('t149.1');
2600
2601 ## NOTE: As if <head>
2602 !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token);
2603 $self->{open_elements}->[-1]->[0]->append_child
2604 ($self->{head_element});
2605 #push @{$self->{open_elements}},
2606 # [$self->{head_element}, $el_category->{head}];
2607 #$self->{insertion_mode} = IN_HEAD_IM;
2608 ## NOTE: Reprocess.
2609
2610 ## NOTE: As if </head>
2611 #pop @{$self->{open_elements}};
2612 #$self->{insertion_mode} = IN_AFTER_HEAD_IM;
2613 ## NOTE: Reprocess.
2614
2615 #
2616 } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2617 !!!cp ('t149.2');
2618
2619 ## NOTE: As if </head>
2620 pop @{$self->{open_elements}};
2621 #$self->{insertion_mode} = IN_AFTER_HEAD_IM;
2622 ## NOTE: Reprocess.
2623
2624 #
2625 } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2626 !!!cp ('t149.3');
2627
2628 !!!parse-error (type => 'in noscript:#eof', token => $token);
2629
2630 ## As if </noscript>
2631 pop @{$self->{open_elements}};
2632 #$self->{insertion_mode} = IN_HEAD_IM;
2633 ## NOTE: Reprocess.
2634
2635 ## NOTE: As if </head>
2636 pop @{$self->{open_elements}};
2637 #$self->{insertion_mode} = IN_AFTER_HEAD_IM;
2638 ## NOTE: Reprocess.
2639
2640 #
2641 } else {
2642 !!!cp ('t149.4');
2643 #
2644 }
2645
2646 ## NOTE: As if <body>
2647 !!!insert-element ('body',, $token);
2648 $self->{insertion_mode} = IN_BODY_IM;
2649 ## NOTE: Reprocess.
2650 next B;
2651 } else {
2652 die "$0: $token->{type}: Unknown token type";
2653 }
2654 } elsif ($self->{insertion_mode} & BODY_IMS) {
2655 if ($token->{type} == CHARACTER_TOKEN) {
2656 !!!cp ('t150');
2657 ## NOTE: There is a code clone of "character in body".
2658 $reconstruct_active_formatting_elements->($insert_to_current);
2659
2660 $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});
2661
2662 !!!next-token;
2663 next B;
2664 } elsif ($token->{type} == START_TAG_TOKEN) {
2665 if ({
2666 caption => 1, col => 1, colgroup => 1, tbody => 1,
2667 td => 1, tfoot => 1, th => 1, thead => 1, tr => 1,
2668 }->{$token->{tag_name}}) {
2669 if (($self->{insertion_mode} & IM_MASK) == IN_CELL_IM) {
2670 ## have an element in table scope
2671 for (reverse 0..$#{$self->{open_elements}}) {
2672 my $node = $self->{open_elements}->[$_];
2673 if ($node->[1] == TABLE_CELL_EL) {
2674 !!!cp ('t151');
2675
2676 ## Close the cell
2677 !!!back-token; # <x>
2678 $token = {type => END_TAG_TOKEN,
2679 tag_name => $node->[0]->manakai_local_name,
2680 line => $token->{line},
2681 column => $token->{column}};
2682 next B;
2683 } elsif ($node->[1] & TABLE_SCOPING_EL) {
2684 !!!cp ('t152');
2685 ## ISSUE: This case can never be reached, maybe.
2686 last;
2687 }
2688 }
2689
2690 !!!cp ('t153');
2691 !!!parse-error (type => 'start tag not allowed',
2692 text => $token->{tag_name}, token => $token);
2693 ## Ignore the token
2694 !!!nack ('t153.1');
2695 !!!next-token;
2696 next B;
2697 } elsif (($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) {
2698 !!!parse-error (type => 'not closed', text => 'caption',
2699 token => $token);
2700
2701 ## NOTE: As if </caption>.
2702 ## have a table element in table scope
2703 my $i;
2704 INSCOPE: {
2705 for (reverse 0..$#{$self->{open_elements}}) {
2706 my $node = $self->{open_elements}->[$_];
2707 if ($node->[1] == CAPTION_EL) {
2708 !!!cp ('t155');
2709 $i = $_;
2710 last INSCOPE;
2711 } elsif ($node->[1] & TABLE_SCOPING_EL) {
2712 !!!cp ('t156');
2713 last;
2714 }
2715 }
2716
2717 !!!cp ('t157');
2718 !!!parse-error (type => 'start tag not allowed',
2719 text => $token->{tag_name}, token => $token);
2720 ## Ignore the token
2721 !!!nack ('t157.1');
2722 !!!next-token;
2723 next B;
2724 } # INSCOPE
2725
2726 ## generate implied end tags
2727 while ($self->{open_elements}->[-1]->[1]
2728 & END_TAG_OPTIONAL_EL) {
2729 !!!cp ('t158');
2730 pop @{$self->{open_elements}};
2731 }
2732
2733 unless ($self->{open_elements}->[-1]->[1] == CAPTION_EL) {
2734 !!!cp ('t159');
2735 !!!parse-error (type => 'not closed',
2736 text => $self->{open_elements}->[-1]->[0]
2737 ->manakai_local_name,
2738 token => $token);
2739 } else {
2740 !!!cp ('t160');
2741 }
2742
2743 splice @{$self->{open_elements}}, $i;
2744
2745 $clear_up_to_marker->();
2746
2747 $self->{insertion_mode} = IN_TABLE_IM;
2748
2749 ## reprocess
2750 !!!ack-later;
2751 next B;
2752 } else {
2753 !!!cp ('t161');
2754 #
2755 }
2756 } else {
2757 !!!cp ('t162');
2758 #
2759 }
2760 } elsif ($token->{type} == END_TAG_TOKEN) {
2761 if ($token->{tag_name} eq 'td' or $token->{tag_name} eq 'th') {
2762 if (($self->{insertion_mode} & IM_MASK) == IN_CELL_IM) {
2763 ## have an element in table scope
2764 my $i;
2765 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
2766 my $node = $self->{open_elements}->[$_];
2767 if ($node->[0]->manakai_local_name eq $token->{tag_name}) {
2768 !!!cp ('t163');
2769 $i = $_;
2770 last INSCOPE;
2771 } elsif ($node->[1] & TABLE_SCOPING_EL) {
2772 !!!cp ('t164');
2773 last INSCOPE;
2774 }
2775 } # INSCOPE
2776 unless (defined $i) {
2777 !!!cp ('t165');
2778 !!!parse-error (type => 'unmatched end tag',
2779 text => $token->{tag_name},
2780 token => $token);
2781 ## Ignore the token
2782 !!!next-token;
2783 next B;
2784 }
2785
2786 ## generate implied end tags
2787 while ($self->{open_elements}->[-1]->[1]
2788 & END_TAG_OPTIONAL_EL) {
2789 !!!cp ('t166');
2790 pop @{$self->{open_elements}};
2791 }
2792
2793 if ($self->{open_elements}->[-1]->[0]->manakai_local_name
2794 ne $token->{tag_name}) {
2795 !!!cp ('t167');
2796 !!!parse-error (type => 'not closed',
2797 text => $self->{open_elements}->[-1]->[0]
2798 ->manakai_local_name,
2799 token => $token);
2800 } else {
2801 !!!cp ('t168');
2802 }
2803
2804 splice @{$self->{open_elements}}, $i;
2805
2806 $clear_up_to_marker->();
2807
2808 $self->{insertion_mode} = IN_ROW_IM;
2809
2810 !!!next-token;
2811 next B;
2812 } elsif (($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) {
2813 !!!cp ('t169');
2814 !!!parse-error (type => 'unmatched end tag',
2815 text => $token->{tag_name}, token => $token);
2816 ## Ignore the token
2817 !!!next-token;
2818 next B;
2819 } else {
2820 !!!cp ('t170');
2821 #
2822 }
2823 } elsif ($token->{tag_name} eq 'caption') {
2824 if (($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) {
2825 ## have a table element in table scope
2826 my $i;
2827 INSCOPE: {
2828 for (reverse 0..$#{$self->{open_elements}}) {
2829 my $node = $self->{open_elements}->[$_];
2830 if ($node->[1] == CAPTION_EL) {
2831 !!!cp ('t171');
2832 $i = $_;
2833 last INSCOPE;
2834 } elsif ($node->[1] & TABLE_SCOPING_EL) {
2835 !!!cp ('t172');
2836 last;
2837 }
2838 }
2839
2840 !!!cp ('t173');
2841 !!!parse-error (type => 'unmatched end tag',
2842 text => $token->{tag_name}, token => $token);
2843 ## Ignore the token
2844 !!!next-token;
2845 next B;
2846 } # INSCOPE
2847
2848 ## generate implied end tags
2849 while ($self->{open_elements}->[-1]->[1]
2850 & END_TAG_OPTIONAL_EL) {
2851 !!!cp ('t174');
2852 pop @{$self->{open_elements}};
2853 }
2854
2855 unless ($self->{open_elements}->[-1]->[1] == CAPTION_EL) {
2856 !!!cp ('t175');
2857 !!!parse-error (type => 'not closed',
2858 text => $self->{open_elements}->[-1]->[0]
2859 ->manakai_local_name,
2860 token => $token);
2861 } else {
2862 !!!cp ('t176');
2863 }
2864
2865 splice @{$self->{open_elements}}, $i;
2866
2867 $clear_up_to_marker->();
2868
2869 $self->{insertion_mode} = IN_TABLE_IM;
2870
2871 !!!next-token;
2872 next B;
2873 } elsif (($self->{insertion_mode} & IM_MASK) == IN_CELL_IM) {
2874 !!!cp ('t177');
2875 !!!parse-error (type => 'unmatched end tag',
2876 text => $token->{tag_name}, token => $token);
2877 ## Ignore the token
2878 !!!next-token;
2879 next B;
2880 } else {
2881 !!!cp ('t178');
2882 #
2883 }
2884 } elsif ({
2885 table => 1, tbody => 1, tfoot => 1,
2886 thead => 1, tr => 1,
2887 }->{$token->{tag_name}} and
2888 ($self->{insertion_mode} & IM_MASK) == IN_CELL_IM) {
2889 ## have an element in table scope
2890 my $i;
2891 my $tn;
2892 INSCOPE: {
2893 for (reverse 0..$#{$self->{open_elements}}) {
2894 my $node = $self->{open_elements}->[$_];
2895 if ($node->[0]->manakai_local_name eq $token->{tag_name}) {
2896 !!!cp ('t179');
2897 $i = $_;
2898
2899 ## Close the cell
2900 !!!back-token; # </x>
2901 $token = {type => END_TAG_TOKEN, tag_name => $tn,
2902 line => $token->{line},
2903 column => $token->{column}};
2904 next B;
2905 } elsif ($node->[1] == TABLE_CELL_EL) {
2906 !!!cp ('t180');
2907 $tn = $node->[0]->manakai_local_name;
2908 ## NOTE: There is exactly one |td| or |th| element
2909 ## in scope in the stack of open elements by definition.
2910 } elsif ($node->[1] & TABLE_SCOPING_EL) {
2911 ## ISSUE: Can this be reached?
2912 !!!cp ('t181');
2913 last;
2914 }
2915 }
2916
2917 !!!cp ('t182');
2918 !!!parse-error (type => 'unmatched end tag',
2919 text => $token->{tag_name}, token => $token);
2920 ## Ignore the token
2921 !!!next-token;
2922 next B;
2923 } # INSCOPE
2924 } elsif ($token->{tag_name} eq 'table' and
2925 ($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) {
2926 !!!parse-error (type => 'not closed', text => 'caption',
2927 token => $token);
2928
2929 ## As if </caption>
2930 ## have a table element in table scope
2931 my $i;
2932 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
2933 my $node = $self->{open_elements}->[$_];
2934 if ($node->[1] == CAPTION_EL) {
2935 !!!cp ('t184');
2936 $i = $_;
2937 last INSCOPE;
2938 } elsif ($node->[1] & TABLE_SCOPING_EL) {
2939 !!!cp ('t185');
2940 last INSCOPE;
2941 }
2942 } # INSCOPE
2943 unless (defined $i) {
2944 !!!cp ('t186');
2945 ## TODO: Wrong error type?
2946 !!!parse-error (type => 'unmatched end tag',
2947 text => 'caption', token => $token);
2948 ## Ignore the token
2949 !!!next-token;
2950 next B;
2951 }
2952
2953 ## generate implied end tags
2954 while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
2955 !!!cp ('t187');
2956 pop @{$self->{open_elements}};
2957 }
2958
2959 unless ($self->{open_elements}->[-1]->[1] == CAPTION_EL) {
2960 !!!cp ('t188');
2961 !!!parse-error (type => 'not closed',
2962 text => $self->{open_elements}->[-1]->[0]
2963 ->manakai_local_name,
2964 token => $token);
2965 } else {
2966 !!!cp ('t189');
2967 }
2968
2969 splice @{$self->{open_elements}}, $i;
2970
2971 $clear_up_to_marker->();
2972
2973 $self->{insertion_mode} = IN_TABLE_IM;
2974
2975 ## reprocess
2976 next B;
2977 } elsif ({
2978 body => 1, col => 1, colgroup => 1, html => 1,
2979 }->{$token->{tag_name}}) {
2980 if ($self->{insertion_mode} & BODY_TABLE_IMS) {
2981 !!!cp ('t190');
2982 !!!parse-error (type => 'unmatched end tag',
2983 text => $token->{tag_name}, token => $token);
2984 ## Ignore the token
2985 !!!next-token;
2986 next B;
2987 } else {
2988 !!!cp ('t191');
2989 #
2990 }
2991 } elsif ({
2992 tbody => 1, tfoot => 1,
2993 thead => 1, tr => 1,
2994 }->{$token->{tag_name}} and
2995 ($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) {
2996 !!!cp ('t192');
2997 !!!parse-error (type => 'unmatched end tag',
2998 text => $token->{tag_name}, token => $token);
2999 ## Ignore the token
3000 !!!next-token;
3001 next B;
3002 } else {
3003 !!!cp ('t193');
3004 #
3005 }
3006 } elsif ($token->{type} == END_OF_FILE_TOKEN) {
3007 for my $entry (@{$self->{open_elements}}) {
3008 unless ($entry->[1] & ALL_END_TAG_OPTIONAL_EL) {
3009 !!!cp ('t75');
3010 !!!parse-error (type => 'in body:#eof', token => $token);
3011 last;
3012 }
3013 }
3014
3015 ## Stop parsing.
3016 last B;
3017 } else {
3018 die "$0: $token->{type}: Unknown token type";
3019 }
3020
3021 $insert = $insert_to_current;
3022 #
3023 } elsif ($self->{insertion_mode} & TABLE_IMS) {
3024 if ($token->{type} == START_TAG_TOKEN) {
3025 if ({
3026 tr => (($self->{insertion_mode} & IM_MASK) != IN_ROW_IM),
3027 th => 1, td => 1,
3028 }->{$token->{tag_name}}) {
3029 if (($self->{insertion_mode} & IM_MASK) == IN_TABLE_IM) {
3030 ## Clear back to table context
3031 while (not ($self->{open_elements}->[-1]->[1]
3032 & TABLE_SCOPING_EL)) {
3033 !!!cp ('t201');
3034 pop @{$self->{open_elements}};
3035 }
3036
3037 !!!insert-element ('tbody',, $token);
3038 $self->{insertion_mode} = IN_TABLE_BODY_IM;
3039 ## reprocess in the "in table body" insertion mode...
3040 }
3041
3042 if (($self->{insertion_mode} & IM_MASK) == IN_TABLE_BODY_IM) {
3043 unless ($token->{tag_name} eq 'tr') {
3044 !!!cp ('t202');
3045 !!!parse-error (type => 'missing start tag:tr', token => $token);
3046 }
3047
3048 ## Clear back to table body context
3049 while (not ($self->{open_elements}->[-1]->[1]
3050 & TABLE_ROWS_SCOPING_EL)) {
3051 !!!cp ('t203');
3052 ## ISSUE: Can this case be reached?
3053 pop @{$self->{open_elements}};
3054 }
3055
3056 $self->{insertion_mode} = IN_ROW_IM;
3057 if ($token->{tag_name} eq 'tr') {
3058 !!!cp ('t204');
3059 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3060 $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3061 !!!nack ('t204');
3062 !!!next-token;
3063 next B;
3064 } else {
3065 !!!cp ('t205');
3066 !!!insert-element ('tr',, $token);
3067 ## reprocess in the "in row" insertion mode
3068 }
3069 } else {
3070 !!!cp ('t206');
3071 }
3072
3073 ## Clear back to table row context
3074 while (not ($self->{open_elements}->[-1]->[1]
3075 & TABLE_ROW_SCOPING_EL)) {
3076 !!!cp ('t207');
3077 pop @{$self->{open_elements}};
3078 }
3079
3080 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3081 $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3082 $self->{insertion_mode} = IN_CELL_IM;
3083
3084 push @$active_formatting_elements, ['#marker', ''];
3085
3086 !!!nack ('t207.1');
3087 !!!next-token;
3088 next B;
3089 } elsif ({
3090 caption => 1, col => 1, colgroup => 1,
3091 tbody => 1, tfoot => 1, thead => 1,
3092 tr => 1, # $self->{insertion_mode} == IN_ROW_IM
3093 }->{$token->{tag_name}}) {
3094 if (($self->{insertion_mode} & IM_MASK) == IN_ROW_IM) {
3095 ## As if </tr>
3096 ## have an element in table scope
3097 my $i;
3098 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3099 my $node = $self->{open_elements}->[$_];
3100 if ($node->[1] == TABLE_ROW_EL) {
3101 !!!cp ('t208');
3102 $i = $_;
3103 last INSCOPE;
3104 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3105 !!!cp ('t209');
3106 last INSCOPE;
3107 }
3108 } # INSCOPE
3109 unless (defined $i) {
3110 !!!cp ('t210');
3111 ## TODO: This type is wrong.
3112 !!!parse-error (type => 'unmacthed end tag',
3113 text => $token->{tag_name}, token => $token);
3114 ## Ignore the token
3115 !!!nack ('t210.1');
3116 !!!next-token;
3117 next B;
3118 }
3119
3120 ## Clear back to table row context
3121 while (not ($self->{open_elements}->[-1]->[1]
3122 & TABLE_ROW_SCOPING_EL)) {
3123 !!!cp ('t211');
3124 ## ISSUE: Can this case be reached?
3125 pop @{$self->{open_elements}};
3126 }
3127
3128 pop @{$self->{open_elements}}; # tr
3129 $self->{insertion_mode} = IN_TABLE_BODY_IM;
3130 if ($token->{tag_name} eq 'tr') {
3131 !!!cp ('t212');
3132 ## reprocess
3133 !!!ack-later;
3134 next B;
3135 } else {
3136 !!!cp ('t213');
3137 ## reprocess in the "in table body" insertion mode...
3138 }
3139 }
3140
3141 if (($self->{insertion_mode} & IM_MASK) == IN_TABLE_BODY_IM) {
3142 ## have an element in table scope
3143 my $i;
3144 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3145 my $node = $self->{open_elements}->[$_];
3146 if ($node->[1] == TABLE_ROW_GROUP_EL) {
3147 !!!cp ('t214');
3148 $i = $_;
3149 last INSCOPE;
3150 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3151 !!!cp ('t215');
3152 last INSCOPE;
3153 }
3154 } # INSCOPE
3155 unless (defined $i) {
3156 !!!cp ('t216');
3157 ## TODO: This erorr type is wrong.
3158 !!!parse-error (type => 'unmatched end tag',
3159 text => $token->{tag_name}, token => $token);
3160 ## Ignore the token
3161 !!!nack ('t216.1');
3162 !!!next-token;
3163 next B;
3164 }
3165
3166 ## Clear back to table body context
3167 while (not ($self->{open_elements}->[-1]->[1]
3168 & TABLE_ROWS_SCOPING_EL)) {
3169 !!!cp ('t217');
3170 ## ISSUE: Can this state be reached?
3171 pop @{$self->{open_elements}};
3172 }
3173
3174 ## As if <{current node}>
3175 ## have an element in table scope
3176 ## true by definition
3177
3178 ## Clear back to table body context
3179 ## nop by definition
3180
3181 pop @{$self->{open_elements}};
3182 $self->{insertion_mode} = IN_TABLE_IM;
3183 ## reprocess in "in table" insertion mode...
3184 } else {
3185 !!!cp ('t218');
3186 }
3187
3188 if ($token->{tag_name} eq 'col') {
3189 ## Clear back to table context
3190 while (not ($self->{open_elements}->[-1]->[1]
3191 & TABLE_SCOPING_EL)) {
3192 !!!cp ('t219');
3193 ## ISSUE: Can this state be reached?
3194 pop @{$self->{open_elements}};
3195 }
3196
3197 !!!insert-element ('colgroup',, $token);
3198 $self->{insertion_mode} = IN_COLUMN_GROUP_IM;
3199 ## reprocess
3200 $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3201 !!!ack-later;
3202 next B;
3203 } elsif ({
3204 caption => 1,
3205 colgroup => 1,
3206 tbody => 1, tfoot => 1, thead => 1,
3207 }->{$token->{tag_name}}) {
3208 ## Clear back to table context
3209 while (not ($self->{open_elements}->[-1]->[1]
3210 & TABLE_SCOPING_EL)) {
3211 !!!cp ('t220');
3212 ## ISSUE: Can this state be reached?
3213 pop @{$self->{open_elements}};
3214 }
3215
3216 push @$active_formatting_elements, ['#marker', '']
3217 if $token->{tag_name} eq 'caption';
3218
3219 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3220 $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3221 $self->{insertion_mode} = {
3222 caption => IN_CAPTION_IM,
3223 colgroup => IN_COLUMN_GROUP_IM,
3224 tbody => IN_TABLE_BODY_IM,
3225 tfoot => IN_TABLE_BODY_IM,
3226 thead => IN_TABLE_BODY_IM,
3227 }->{$token->{tag_name}};
3228 !!!next-token;
3229 !!!nack ('t220.1');
3230 next B;
3231 } else {
3232 die "$0: in table: <>: $token->{tag_name}";
3233 }
3234 } elsif ($token->{tag_name} eq 'table') {
3235 !!!parse-error (type => 'not closed',
3236 text => $self->{open_elements}->[-1]->[0]
3237 ->manakai_local_name,
3238 token => $token);
3239
3240 ## As if </table>
3241 ## have a table element in table scope
3242 my $i;
3243 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3244 my $node = $self->{open_elements}->[$_];
3245 if ($node->[1] == TABLE_EL) {
3246 !!!cp ('t221');
3247 $i = $_;
3248 last INSCOPE;
3249 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3250 !!!cp ('t222');
3251 last INSCOPE;
3252 }
3253 } # INSCOPE
3254 unless (defined $i) {
3255 !!!cp ('t223');
3256 ## TODO: The following is wrong, maybe.
3257 !!!parse-error (type => 'unmatched end tag', text => 'table',
3258 token => $token);
3259 ## Ignore tokens </table><table>
3260 !!!nack ('t223.1');
3261 !!!next-token;
3262 next B;
3263 }
3264
3265 ## TODO: Followings are removed from the latest spec.
3266 ## generate implied end tags
3267 while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
3268 !!!cp ('t224');
3269 pop @{$self->{open_elements}};
3270 }
3271
3272 unless ($self->{open_elements}->[-1]->[1] == TABLE_EL) {
3273 !!!cp ('t225');
3274 ## NOTE: |<table><tr><table>|
3275 !!!parse-error (type => 'not closed',
3276 text => $self->{open_elements}->[-1]->[0]
3277 ->manakai_local_name,
3278 token => $token);
3279 } else {
3280 !!!cp ('t226');
3281 }
3282
3283 splice @{$self->{open_elements}}, $i;
3284 pop @{$open_tables};
3285
3286 $self->_reset_insertion_mode;
3287
3288 ## reprocess
3289 !!!ack-later;
3290 next B;
3291 } elsif ($token->{tag_name} eq 'style') {
3292 !!!cp ('t227.8');
3293 ## NOTE: This is a "as if in head" code clone.
3294 $parse_rcdata->(CDATA_CONTENT_MODEL);
3295 $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3296 next B;
3297 } elsif ($token->{tag_name} eq 'script') {
3298 !!!cp ('t227.6');
3299 ## NOTE: This is a "as if in head" code clone.
3300 $script_start_tag->();
3301 $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3302 next B;
3303 } elsif ($token->{tag_name} eq 'input') {
3304 if ($token->{attributes}->{type}) {
3305 my $type = $token->{attributes}->{type}->{value};
3306 $type =~ tr/A-Z/a-z/; ## ASCII case-insensitive.
3307 if ($type eq 'hidden') {
3308 !!!cp ('t227.3');
3309 !!!parse-error (type => 'in table',
3310 text => $token->{tag_name}, token => $token);
3311
3312 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3313 $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3314
3315 ## TODO: form element pointer
3316
3317 pop @{$self->{open_elements}};
3318
3319 !!!next-token;
3320 !!!ack ('t227.2.1');
3321 next B;
3322 } else {
3323 !!!cp ('t227.1');
3324 #
3325 }
3326 } else {
3327 !!!cp ('t227.4');
3328 #
3329 }
3330 } else {
3331 !!!cp ('t227');
3332 #
3333 }
3334
3335 !!!parse-error (type => 'in table', text => $token->{tag_name},
3336 token => $token);
3337
3338 $insert = $insert_to_foster;
3339 #
3340 } elsif ($token->{type} == END_TAG_TOKEN) {
3341 if ($token->{tag_name} eq 'tr' and
3342 ($self->{insertion_mode} & IM_MASK) == IN_ROW_IM) {
3343 ## have an element in table scope
3344 my $i;
3345 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3346 my $node = $self->{open_elements}->[$_];
3347 if ($node->[1] == TABLE_ROW_EL) {
3348 !!!cp ('t228');
3349 $i = $_;
3350 last INSCOPE;
3351 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3352 !!!cp ('t229');
3353 last INSCOPE;
3354 }
3355 } # INSCOPE
3356 unless (defined $i) {
3357 !!!cp ('t230');
3358 !!!parse-error (type => 'unmatched end tag',
3359 text => $token->{tag_name}, token => $token);
3360 ## Ignore the token
3361 !!!nack ('t230.1');
3362 !!!next-token;
3363 next B;
3364 } else {
3365 !!!cp ('t232');
3366 }
3367
3368 ## Clear back to table row context
3369 while (not ($self->{open_elements}->[-1]->[1]
3370 & TABLE_ROW_SCOPING_EL)) {
3371 !!!cp ('t231');
3372 ## ISSUE: Can this state be reached?
3373 pop @{$self->{open_elements}};
3374 }
3375
3376 pop @{$self->{open_elements}}; # tr
3377 $self->{insertion_mode} = IN_TABLE_BODY_IM;
3378 !!!next-token;
3379 !!!nack ('t231.1');
3380 next B;
3381 } elsif ($token->{tag_name} eq 'table') {
3382 if (($self->{insertion_mode} & IM_MASK) == IN_ROW_IM) {
3383 ## As if </tr>
3384 ## have an element in table scope
3385 my $i;
3386 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3387 my $node = $self->{open_elements}->[$_];
3388 if ($node->[1] == TABLE_ROW_EL) {
3389 !!!cp ('t233');
3390 $i = $_;
3391 last INSCOPE;
3392 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3393 !!!cp ('t234');
3394 last INSCOPE;
3395 }
3396 } # INSCOPE
3397 unless (defined $i) {
3398 !!!cp ('t235');
3399 ## TODO: The following is wrong.
3400 !!!parse-error (type => 'unmatched end tag',
3401 text => $token->{type}, token => $token);
3402 ## Ignore the token
3403 !!!nack ('t236.1');
3404 !!!next-token;
3405 next B;
3406 }
3407
3408 ## Clear back to table row context
3409 while (not ($self->{open_elements}->[-1]->[1]
3410 & TABLE_ROW_SCOPING_EL)) {
3411 !!!cp ('t236');
3412 ## ISSUE: Can this state be reached?
3413 pop @{$self->{open_elements}};
3414 }
3415
3416 pop @{$self->{open_elements}}; # tr
3417 $self->{insertion_mode} = IN_TABLE_BODY_IM;
3418 ## reprocess in the "in table body" insertion mode...
3419 }
3420
3421 if (($self->{insertion_mode} & IM_MASK) == IN_TABLE_BODY_IM) {
3422 ## have an element in table scope
3423 my $i;
3424 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3425 my $node = $self->{open_elements}->[$_];
3426 if ($node->[1] == TABLE_ROW_GROUP_EL) {
3427 !!!cp ('t237');
3428 $i = $_;
3429 last INSCOPE;
3430 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3431 !!!cp ('t238');
3432 last INSCOPE;
3433 }
3434 } # INSCOPE
3435 unless (defined $i) {
3436 !!!cp ('t239');
3437 !!!parse-error (type => 'unmatched end tag',
3438 text => $token->{tag_name}, token => $token);
3439 ## Ignore the token
3440 !!!nack ('t239.1');
3441 !!!next-token;
3442 next B;
3443 }
3444
3445 ## Clear back to table body context
3446 while (not ($self->{open_elements}->[-1]->[1]
3447 & TABLE_ROWS_SCOPING_EL)) {
3448 !!!cp ('t240');
3449 pop @{$self->{open_elements}};
3450 }
3451
3452 ## As if <{current node}>
3453 ## have an element in table scope
3454 ## true by definition
3455
3456 ## Clear back to table body context
3457 ## nop by definition
3458
3459 pop @{$self->{open_elements}};
3460 $self->{insertion_mode} = IN_TABLE_IM;
3461 ## reprocess in the "in table" insertion mode...
3462 }
3463
3464 ## NOTE: </table> in the "in table" insertion mode.
3465 ## When you edit the code fragment below, please ensure that
3466 ## the code for <table> in the "in table" insertion mode
3467 ## is synced with it.
3468
3469 ## have a table element in table scope
3470 my $i;
3471 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3472 my $node = $self->{open_elements}->[$_];
3473 if ($node->[1] == TABLE_EL) {
3474 !!!cp ('t241');
3475 $i = $_;
3476 last INSCOPE;
3477 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3478 !!!cp ('t242');
3479 last INSCOPE;
3480 }
3481 } # INSCOPE
3482 unless (defined $i) {
3483 !!!cp ('t243');
3484 !!!parse-error (type => 'unmatched end tag',
3485 text => $token->{tag_name}, token => $token);
3486 ## Ignore the token
3487 !!!nack ('t243.1');
3488 !!!next-token;
3489 next B;
3490 }
3491
3492 splice @{$self->{open_elements}}, $i;
3493 pop @{$open_tables};
3494
3495 $self->_reset_insertion_mode;
3496
3497 !!!next-token;
3498 next B;
3499 } elsif ({
3500 tbody => 1, tfoot => 1, thead => 1,
3501 }->{$token->{tag_name}} and
3502 $self->{insertion_mode} & ROW_IMS) {
3503 if (($self->{insertion_mode} & IM_MASK) == IN_ROW_IM) {
3504 ## have an element in table scope
3505 my $i;
3506 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3507 my $node = $self->{open_elements}->[$_];
3508 if ($node->[0]->manakai_local_name eq $token->{tag_name}) {
3509 !!!cp ('t247');
3510 $i = $_;
3511 last INSCOPE;
3512 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3513 !!!cp ('t248');
3514 last INSCOPE;
3515 }
3516 } # INSCOPE
3517 unless (defined $i) {
3518 !!!cp ('t249');
3519 !!!parse-error (type => 'unmatched end tag',
3520 text => $token->{tag_name}, token => $token);
3521 ## Ignore the token
3522 !!!nack ('t249.1');
3523 !!!next-token;
3524 next B;
3525 }
3526
3527 ## As if </tr>
3528 ## have an element in table scope
3529 my $i;
3530 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3531 my $node = $self->{open_elements}->[$_];
3532 if ($node->[1] == TABLE_ROW_EL) {
3533 !!!cp ('t250');
3534 $i = $_;
3535 last INSCOPE;
3536 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3537 !!!cp ('t251');
3538 last INSCOPE;
3539 }
3540 } # INSCOPE
3541 unless (defined $i) {
3542 !!!cp ('t252');
3543 !!!parse-error (type => 'unmatched end tag',
3544 text => 'tr', token => $token);
3545 ## Ignore the token
3546 !!!nack ('t252.1');
3547 !!!next-token;
3548 next B;
3549 }
3550
3551 ## Clear back to table row context
3552 while (not ($self->{open_elements}->[-1]->[1]
3553 & TABLE_ROW_SCOPING_EL)) {
3554 !!!cp ('t253');
3555 ## ISSUE: Can this case be reached?
3556 pop @{$self->{open_elements}};
3557 }
3558
3559 pop @{$self->{open_elements}}; # tr
3560 $self->{insertion_mode} = IN_TABLE_BODY_IM;
3561 ## reprocess in the "in table body" insertion mode...
3562 }
3563
3564 ## have an element in table scope
3565 my $i;
3566 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3567 my $node = $self->{open_elements}->[$_];
3568 if ($node->[0]->manakai_local_name eq $token->{tag_name}) {
3569 !!!cp ('t254');
3570 $i = $_;
3571 last INSCOPE;
3572 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3573 !!!cp ('t255');
3574 last INSCOPE;
3575 }
3576 } # INSCOPE
3577 unless (defined $i) {
3578 !!!cp ('t256');
3579 !!!parse-error (type => 'unmatched end tag',
3580 text => $token->{tag_name}, token => $token);
3581 ## Ignore the token
3582 !!!nack ('t256.1');
3583 !!!next-token;
3584 next B;
3585 }
3586
3587 ## Clear back to table body context
3588 while (not ($self->{open_elements}->[-1]->[1]
3589 & TABLE_ROWS_SCOPING_EL)) {
3590 !!!cp ('t257');
3591 ## ISSUE: Can this case be reached?
3592 pop @{$self->{open_elements}};
3593 }
3594
3595 pop @{$self->{open_elements}};
3596 $self->{insertion_mode} = IN_TABLE_IM;
3597 !!!nack ('t257.1');
3598 !!!next-token;
3599 next B;
3600 } elsif ({
3601 body => 1, caption => 1, col => 1, colgroup => 1,
3602 html => 1, td => 1, th => 1,
3603 tr => 1, # $self->{insertion_mode} == IN_ROW_IM
3604 tbody => 1, tfoot => 1, thead => 1, # $self->{insertion_mode} == IN_TABLE_IM
3605 }->{$token->{tag_name}}) {
3606 !!!cp ('t258');
3607 !!!parse-error (type => 'unmatched end tag',
3608 text => $token->{tag_name}, token => $token);
3609 ## Ignore the token
3610 !!!nack ('t258.1');
3611 !!!next-token;
3612 next B;
3613 } else {
3614 !!!cp ('t259');
3615 !!!parse-error (type => 'in table:/',
3616 text => $token->{tag_name}, token => $token);
3617
3618 $insert = $insert_to_foster;
3619 #
3620 }
3621 } elsif ($token->{type} == END_OF_FILE_TOKEN) {
3622 unless ($self->{open_elements}->[-1]->[1] == HTML_EL and
3623 @{$self->{open_elements}} == 1) { # redundant, maybe
3624 !!!parse-error (type => 'in body:#eof', token => $token);
3625 !!!cp ('t259.1');
3626 #
3627 } else {
3628 !!!cp ('t259.2');
3629 #
3630 }
3631
3632 ## Stop parsing
3633 last B;
3634 } else {
3635 die "$0: $token->{type}: Unknown token type";
3636 }
3637 } elsif (($self->{insertion_mode} & IM_MASK) == IN_COLUMN_GROUP_IM) {
3638 if ($token->{type} == CHARACTER_TOKEN) {
3639 if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
3640 $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
3641 unless (length $token->{data}) {
3642 !!!cp ('t260');
3643 !!!next-token;
3644 next B;
3645 }
3646 }
3647
3648 !!!cp ('t261');
3649 #
3650 } elsif ($token->{type} == START_TAG_TOKEN) {
3651 if ($token->{tag_name} eq 'col') {
3652 !!!cp ('t262');
3653 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3654 pop @{$self->{open_elements}};
3655 !!!ack ('t262.1');
3656 !!!next-token;
3657 next B;
3658 } else {
3659 !!!cp ('t263');
3660 #
3661 }
3662 } elsif ($token->{type} == END_TAG_TOKEN) {
3663 if ($token->{tag_name} eq 'colgroup') {
3664 if ($self->{open_elements}->[-1]->[1] == HTML_EL) {
3665 !!!cp ('t264');
3666 !!!parse-error (type => 'unmatched end tag',
3667 text => 'colgroup', token => $token);
3668 ## Ignore the token
3669 !!!next-token;
3670 next B;
3671 } else {
3672 !!!cp ('t265');
3673 pop @{$self->{open_elements}}; # colgroup
3674 $self->{insertion_mode} = IN_TABLE_IM;
3675 !!!next-token;
3676 next B;
3677 }
3678 } elsif ($token->{tag_name} eq 'col') {
3679 !!!cp ('t266');
3680 !!!parse-error (type => 'unmatched end tag',
3681 text => 'col', token => $token);
3682 ## Ignore the token
3683 !!!next-token;
3684 next B;
3685 } else {
3686 !!!cp ('t267');
3687 #
3688 }
3689 } elsif ($token->{type} == END_OF_FILE_TOKEN) {
3690 if ($self->{open_elements}->[-1]->[1] == HTML_EL and
3691 @{$self->{open_elements}} == 1) { # redundant, maybe
3692 !!!cp ('t270.2');
3693 ## Stop parsing.
3694 last B;
3695 } else {
3696 ## NOTE: As if </colgroup>.
3697 !!!cp ('t270.1');
3698 pop @{$self->{open_elements}}; # colgroup
3699 $self->{insertion_mode} = IN_TABLE_IM;
3700 ## Reprocess.
3701 next B;
3702 }
3703 } else {
3704 die "$0: $token->{type}: Unknown token type";
3705 }
3706
3707 ## As if </colgroup>
3708 if ($self->{open_elements}->[-1]->[1] == HTML_EL) {
3709 !!!cp ('t269');
3710 ## TODO: Wrong error type?
3711 !!!parse-error (type => 'unmatched end tag',
3712 text => 'colgroup', token => $token);
3713 ## Ignore the token
3714 !!!nack ('t269.1');
3715 !!!next-token;
3716 next B;
3717 } else {
3718 !!!cp ('t270');
3719 pop @{$self->{open_elements}}; # colgroup
3720 $self->{insertion_mode} = IN_TABLE_IM;
3721 !!!ack-later;
3722 ## reprocess
3723 next B;
3724 }
3725 } elsif ($self->{insertion_mode} & SELECT_IMS) {
3726 if ($token->{type} == CHARACTER_TOKEN) {
3727 !!!cp ('t271');
3728 $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});
3729 !!!next-token;
3730 next B;
3731 } elsif ($token->{type} == START_TAG_TOKEN) {
3732 if ($token->{tag_name} eq 'option') {
3733 if ($self->{open_elements}->[-1]->[1] == OPTION_EL) {
3734 !!!cp ('t272');
3735 ## As if </option>
3736 pop @{$self->{open_elements}};
3737 } else {
3738 !!!cp ('t273');
3739 }
3740
3741 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3742 !!!nack ('t273.1');
3743 !!!next-token;
3744 next B;
3745 } elsif ($token->{tag_name} eq 'optgroup') {
3746 if ($self->{open_elements}->[-1]->[1] == OPTION_EL) {
3747 !!!cp ('t274');
3748 ## As if </option>
3749 pop @{$self->{open_elements}};
3750 } else {
3751 !!!cp ('t275');
3752 }
3753
3754 if ($self->{open_elements}->[-1]->[1] == OPTGROUP_EL) {
3755 !!!cp ('t276');
3756 ## As if </optgroup>
3757 pop @{$self->{open_elements}};
3758 } else {
3759 !!!cp ('t277');
3760 }
3761
3762 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3763 !!!nack ('t277.1');
3764 !!!next-token;
3765 next B;
3766 } elsif ({
3767 select => 1, input => 1, textarea => 1, keygen => 1,
3768 }->{$token->{tag_name}} or
3769 (($self->{insertion_mode} & IM_MASK)
3770 == IN_SELECT_IN_TABLE_IM and
3771 {
3772 caption => 1, table => 1,
3773 tbody => 1, tfoot => 1, thead => 1,
3774 tr => 1, td => 1, th => 1,
3775 }->{$token->{tag_name}})) {
3776
3777 ## 1. Parse error.
3778 if ($token->{tag_name} eq 'select') {
3779 !!!parse-error (type => 'select in select', ## XXX: documentation
3780 token => $token);
3781 } else {
3782 !!!parse-error (type => 'not closed', text => 'select',
3783 token => $token);
3784 }
3785
3786 ## 2./<select>-1. Unless "have an element in table scope" (select):
3787 my $i;
3788 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3789 my $node = $self->{open_elements}->[$_];
3790 if ($node->[1] == SELECT_EL) {
3791 !!!cp ('t278');
3792 $i = $_;
3793 last INSCOPE;
3794 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3795 !!!cp ('t279');
3796 last INSCOPE;
3797 }
3798 } # INSCOPE
3799 unless (defined $i) {
3800 !!!cp ('t280');
3801 if ($token->{tag_name} eq 'select') {
3802 ## NOTE: This error would be raised when
3803 ## |select.innerHTML = '<select>'| is executed; in this
3804 ## case two errors, "select in select" and "unmatched
3805 ## end tags" are reported to the user, the latter might
3806 ## be confusing but this is what the spec requires.
3807 !!!parse-error (type => 'unmatched end tag',
3808 text => 'select',
3809 token => $token);
3810 }
3811 ## Ignore the token.
3812 !!!nack ('t280.1');
3813 !!!next-token;
3814 next B;
3815 }
3816
3817 ## 3. Otherwise, as if there were <select>:
3818
3819 !!!cp ('t281');
3820 splice @{$self->{open_elements}}, $i;
3821
3822 $self->_reset_insertion_mode;
3823
3824 if ($token->{tag_name} eq 'select') {
3825 !!!nack ('t281.2');
3826 !!!next-token;
3827 next B;
3828 } else {
3829 !!!cp ('t281.1');
3830 !!!ack-later;
3831 ## Reprocess the token.
3832 next B;
3833 }
3834 } elsif ($token->{tag_name} eq 'script') {
3835 !!!cp ('t281.3');
3836 ## NOTE: This is an "as if in head" code clone
3837 $script_start_tag->();
3838 next B;
3839 } else {
3840 !!!cp ('t282');
3841 !!!parse-error (type => 'in select',
3842 text => $token->{tag_name}, token => $token);
3843 ## Ignore the token
3844 !!!nack ('t282.1');
3845 !!!next-token;
3846 next B;
3847 }
3848 } elsif ($token->{type} == END_TAG_TOKEN) {
3849 if ($token->{tag_name} eq 'optgroup') {
3850 if ($self->{open_elements}->[-1]->[1] == OPTION_EL and
3851 $self->{open_elements}->[-2]->[1] == OPTGROUP_EL) {
3852 !!!cp ('t283');
3853 ## As if </option>
3854 splice @{$self->{open_elements}}, -2;
3855 } elsif ($self->{open_elements}->[-1]->[1] == OPTGROUP_EL) {
3856 !!!cp ('t284');
3857 pop @{$self->{open_elements}};
3858 } else {
3859 !!!cp ('t285');
3860 !!!parse-error (type => 'unmatched end tag',
3861 text => $token->{tag_name}, token => $token);
3862 ## Ignore the token
3863 }
3864 !!!nack ('t285.1');
3865 !!!next-token;
3866 next B;
3867 } elsif ($token->{tag_name} eq 'option') {
3868 if ($self->{open_elements}->[-1]->[1] == OPTION_EL) {
3869 !!!cp ('t286');
3870 pop @{$self->{open_elements}};
3871 } else {
3872 !!!cp ('t287');
3873 !!!parse-error (type => 'unmatched end tag',
3874 text => $token->{tag_name}, token => $token);
3875 ## Ignore the token
3876 }
3877 !!!nack ('t287.1');
3878 !!!next-token;
3879 next B;
3880 } elsif ($token->{tag_name} eq 'select') {
3881 ## have an element in table scope
3882 my $i;
3883 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3884 my $node = $self->{open_elements}->[$_];
3885 if ($node->[1] == SELECT_EL) {
3886 !!!cp ('t288');
3887 $i = $_;
3888 last INSCOPE;
3889 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3890 !!!cp ('t289');
3891 last INSCOPE;
3892 }
3893 } # INSCOPE
3894 unless (defined $i) {
3895 !!!cp ('t290');
3896 !!!parse-error (type => 'unmatched end tag',
3897 text => $token->{tag_name}, token => $token);
3898 ## Ignore the token
3899 !!!nack ('t290.1');
3900 !!!next-token;
3901 next B;
3902 }
3903
3904 !!!cp ('t291');
3905 splice @{$self->{open_elements}}, $i;
3906
3907 $self->_reset_insertion_mode;
3908
3909 !!!nack ('t291.1');
3910 !!!next-token;
3911 next B;
3912 } elsif (($self->{insertion_mode} & IM_MASK)
3913 == IN_SELECT_IN_TABLE_IM and
3914 {
3915 caption => 1, table => 1, tbody => 1,
3916 tfoot => 1, thead => 1, tr => 1, td => 1, th => 1,
3917 }->{$token->{tag_name}}) {
3918 ## TODO: The following is wrong?
3919 !!!parse-error (type => 'unmatched end tag',
3920 text => $token->{tag_name}, token => $token);
3921
3922 ## have an element in table scope
3923 my $i;
3924 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3925 my $node = $self->{open_elements}->[$_];
3926 if ($node->[0]->manakai_local_name eq $token->{tag_name}) {
3927 !!!cp ('t292');
3928 $i = $_;
3929 last INSCOPE;
3930 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3931 !!!cp ('t293');
3932 last INSCOPE;
3933 }
3934 } # INSCOPE
3935 unless (defined $i) {
3936 !!!cp ('t294');
3937 ## Ignore the token
3938 !!!nack ('t294.1');
3939 !!!next-token;
3940 next B;
3941 }
3942
3943 ## As if </select>
3944 ## have an element in table scope
3945 undef $i;
3946 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3947 my $node = $self->{open_elements}->[$_];
3948 if ($node->[1] == SELECT_EL) {
3949 !!!cp ('t295');
3950 $i = $_;
3951 last INSCOPE;
3952 } elsif ($node->[1] & TABLE_SCOPING_EL) {
3953 ## ISSUE: Can this state be reached?
3954 !!!cp ('t296');
3955 last INSCOPE;
3956 }
3957 } # INSCOPE
3958 unless (defined $i) {
3959 !!!cp ('t297');
3960 ## TODO: The following error type is correct?
3961 !!!parse-error (type => 'unmatched end tag',
3962 text => 'select', token => $token);
3963 ## Ignore the </select> token
3964 !!!nack ('t297.1');
3965 !!!next-token; ## TODO: ok?
3966 next B;
3967 }
3968
3969 !!!cp ('t298');
3970 splice @{$self->{open_elements}}, $i;
3971
3972 $self->_reset_insertion_mode;
3973
3974 !!!ack-later;
3975 ## reprocess
3976 next B;
3977 } else {
3978 !!!cp ('t299');
3979 !!!parse-error (type => 'in select:/',
3980 text => $token->{tag_name}, token => $token);
3981 ## Ignore the token
3982 !!!nack ('t299.3');
3983 !!!next-token;
3984 next B;
3985 }
3986 } elsif ($token->{type} == END_OF_FILE_TOKEN) {
3987 unless ($self->{open_elements}->[-1]->[1] == HTML_EL and
3988 @{$self->{open_elements}} == 1) { # redundant, maybe
3989 !!!cp ('t299.1');
3990 !!!parse-error (type => 'in body:#eof', token => $token);
3991 } else {
3992 !!!cp ('t299.2');
3993 }
3994
3995 ## Stop parsing.
3996 last B;
3997 } else {
3998 die "$0: $token->{type}: Unknown token type";
3999 }
4000 } elsif ($self->{insertion_mode} & BODY_AFTER_IMS) {
4001 if ($token->{type} == CHARACTER_TOKEN) {
4002 if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
4003 my $data = $1;
4004 ## As if in body
4005 $reconstruct_active_formatting_elements->($insert_to_current);
4006
4007 $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
4008
4009 unless (length $token->{data}) {
4010 !!!cp ('t300');
4011 !!!next-token;
4012 next B;
4013 }
4014 }
4015
4016 if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4017 !!!cp ('t301');
4018 !!!parse-error (type => 'after html:#text', token => $token);
4019 #
4020 } else {
4021 !!!cp ('t302');
4022 ## "after body" insertion mode
4023 !!!parse-error (type => 'after body:#text', token => $token);
4024 #
4025 }
4026
4027 $self->{insertion_mode} = IN_BODY_IM;
4028 ## reprocess
4029 next B;
4030 } elsif ($token->{type} == START_TAG_TOKEN) {
4031 if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4032 !!!cp ('t303');
4033 !!!parse-error (type => 'after html',
4034 text => $token->{tag_name}, token => $token);
4035 #
4036 } else {
4037 !!!cp ('t304');
4038 ## "after body" insertion mode
4039 !!!parse-error (type => 'after body',
4040 text => $token->{tag_name}, token => $token);
4041 #
4042 }
4043
4044 $self->{insertion_mode} = IN_BODY_IM;
4045 !!!ack-later;
4046 ## reprocess
4047 next B;
4048 } elsif ($token->{type} == END_TAG_TOKEN) {
4049 if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4050 !!!cp ('t305');
4051 !!!parse-error (type => 'after html:/',
4052 text => $token->{tag_name}, token => $token);
4053
4054 $self->{insertion_mode} = IN_BODY_IM;
4055 ## Reprocess.
4056 next B;
4057 } else {
4058 !!!cp ('t306');
4059 }
4060
4061 ## "after body" insertion mode
4062 if ($token->{tag_name} eq 'html') {
4063 if (defined $self->{inner_html_node}) {
4064 !!!cp ('t307');
4065 !!!parse-error (type => 'unmatched end tag',
4066 text => 'html', token => $token);
4067 ## Ignore the token
4068 !!!next-token;
4069 next B;
4070 } else {
4071 !!!cp ('t308');
4072 $self->{insertion_mode} = AFTER_HTML_BODY_IM;
4073 !!!next-token;
4074 next B;
4075 }
4076 } else {
4077 !!!cp ('t309');
4078 !!!parse-error (type => 'after body:/',
4079 text => $token->{tag_name}, token => $token);
4080
4081 $self->{insertion_mode} = IN_BODY_IM;
4082 ## reprocess
4083 next B;
4084 }
4085 } elsif ($token->{type} == END_OF_FILE_TOKEN) {
4086 !!!cp ('t309.2');
4087 ## Stop parsing
4088 last B;
4089 } else {
4090 die "$0: $token->{type}: Unknown token type";
4091 }
4092 } elsif ($self->{insertion_mode} & FRAME_IMS) {
4093 if ($token->{type} == CHARACTER_TOKEN) {
4094 if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
4095 $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
4096
4097 unless (length $token->{data}) {
4098 !!!cp ('t310');
4099 !!!next-token;
4100 next B;
4101 }
4102 }
4103
4104 if ($token->{data} =~ s/^[^\x09\x0A\x0C\x20]+//) {
4105 if ($self->{insertion_mode} == IN_FRAMESET_IM) {
4106 !!!cp ('t311');
4107 !!!parse-error (type => 'in frameset:#text', token => $token);
4108 } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) {
4109 !!!cp ('t312');
4110 !!!parse-error (type => 'after frameset:#text', token => $token);
4111 } else { # "after after frameset"
4112 !!!cp ('t313');
4113 !!!parse-error (type => 'after html:#text', token => $token);
4114 }
4115
4116 ## Ignore the token.
4117 if (length $token->{data}) {
4118 !!!cp ('t314');
4119 ## reprocess the rest of characters
4120 } else {
4121 !!!cp ('t315');
4122 !!!next-token;
4123 }
4124 next B;
4125 }
4126
4127 die qq[$0: Character "$token->{data}"];
4128 } elsif ($token->{type} == START_TAG_TOKEN) {
4129 if ($token->{tag_name} eq 'frameset' and
4130 $self->{insertion_mode} == IN_FRAMESET_IM) {
4131 !!!cp ('t318');
4132 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
4133 !!!nack ('t318.1');
4134 !!!next-token;
4135 next B;
4136 } elsif ($token->{tag_name} eq 'frame' and
4137 $self->{insertion_mode} == IN_FRAMESET_IM) {
4138 !!!cp ('t319');
4139 !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
4140 pop @{$self->{open_elements}};
4141 !!!ack ('t319.1');
4142 !!!next-token;
4143 next B;
4144 } elsif ($token->{tag_name} eq 'noframes') {
4145 !!!cp ('t320');
4146 ## NOTE: As if in head.
4147 $parse_rcdata->(CDATA_CONTENT_MODEL);
4148 next B;
4149
4150 ## NOTE: |<!DOCTYPE HTML><frameset></frameset></html><noframes></noframes>|
4151 ## has no parse error.
4152 } else {
4153 if ($self->{insertion_mode} == IN_FRAMESET_IM) {
4154 !!!cp ('t321');
4155 !!!parse-error (type => 'in frameset',
4156 text => $token->{tag_name}, token => $token);
4157 } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) {
4158 !!!cp ('t322');
4159 !!!parse-error (type => 'after frameset',
4160 text => $token->{tag_name}, token => $token);
4161 } else { # "after after frameset"
4162 !!!cp ('t322.2');
4163 !!!parse-error (type => 'after after frameset',
4164 text => $token->{tag_name}, token => $token);
4165 }
4166 ## Ignore the token
4167 !!!nack ('t322.1');
4168 !!!next-token;
4169 next B;
4170 }
4171 } elsif ($token->{type} == END_TAG_TOKEN) {
4172 if ($token->{tag_name} eq 'frameset' and
4173 $self->{insertion_mode} == IN_FRAMESET_IM) {
4174 if ($self->{open_elements}->[-1]->[1] == HTML_EL and
4175 @{$self->{open_elements}} == 1) {
4176 !!!cp ('t325');
4177 !!!parse-error (type => 'unmatched end tag',
4178 text => $token->{tag_name}, token => $token);
4179 ## Ignore the token
4180 !!!next-token;
4181 } else {
4182 !!!cp ('t326');
4183 pop @{$self->{open_elements}};
4184 !!!next-token;
4185 }
4186
4187 if (not defined $self->{inner_html_node} and
4188 not ($self->{open_elements}->[-1]->[1] == FRAMESET_EL)) {
4189 !!!cp ('t327');
4190 $self->{insertion_mode} = AFTER_FRAMESET_IM;
4191 } else {
4192 !!!cp ('t328');
4193 }
4194 next B;
4195 } elsif ($token->{tag_name} eq 'html' and
4196 $self->{insertion_mode} == AFTER_FRAMESET_IM) {
4197 !!!cp ('t329');
4198 $self->{insertion_mode} = AFTER_HTML_FRAMESET_IM;
4199 !!!next-token;
4200 next B;
4201 } else {
4202 if ($self->{insertion_mode} == IN_FRAMESET_IM) {
4203 !!!cp ('t330');
4204 !!!parse-error (type => 'in frameset:/',
4205 text => $token->{tag_name}, token => $token);
4206 } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) {
4207 !!!cp ('t330.1');
4208 !!!parse-error (type => 'after frameset:/',
4209 text => $token->{tag_name}, token => $token);
4210 } else { # "after after html"
4211 !!!cp ('t331');
4212 !!!parse-error (type => 'after after frameset:/',
4213 text => $token->{tag_name}, token => $token);
4214 }
4215 ## Ignore the token
4216 !!!next-token;
4217 next B;
4218 }
4219 } elsif ($token->{type} == END_OF_FILE_TOKEN) {
4220 unless ($self->{open_elements}->[-1]->[1] == HTML_EL and
4221 @{$self->{open_elements}} == 1) { # redundant, maybe
4222 !!!cp ('t331.1');
4223 !!!parse-error (type => 'in body:#eof', token => $token);
4224 } else {
4225 !!!cp ('t331.2');
4226 }
4227
4228 ## Stop parsing
4229 last B;
4230 } else {
4231 die "$0: $token->{type}: Unknown token type";
4232 }
4233 } else {
4234 die "$0: $self->{insertion_mode}: Unknown insertion mode";
4235 }
4236
4237 ## "in body" insertion mode
4238 if ($token->{type} == START_TAG_TOKEN) {
4239 if ($token->{tag_name} eq 'script') {
4240 !!!cp ('t332');
4241 ## NOTE: This is an "as if in head" code clone
4242 $script_start_tag->();
4243 next B;
4244 } elsif ($token->{tag_name} eq 'style') {
4245 !!!cp ('t333');
4246 ## NOTE: This is an "as if in head" code clone
4247 $parse_rcdata->(CDATA_CONTENT_MODEL);
4248 next B;
4249 } elsif ({
4250 base => 1, command => 1, link => 1,
4251 }->{$token->{tag_name}}) {
4252 !!!cp ('t334');
4253 ## NOTE: This is an "as if in head" code clone, only "-t" differs
4254 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4255 pop @{$self->{open_elements}};
4256 !!!ack ('t334.1');
4257 !!!next-token;
4258 next B;
4259 } elsif ($token->{tag_name} eq 'meta') {
4260 ## NOTE: This is an "as if in head" code clone, only "-t" differs
4261 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4262 my $meta_el = pop @{$self->{open_elements}};
4263
4264 unless ($self->{confident}) {
4265 if ($token->{attributes}->{charset}) {
4266 !!!cp ('t335');
4267 ## NOTE: Whether the encoding is supported or not is handled
4268 ## in the {change_encoding} callback.
4269 $self->{change_encoding}
4270 ->($self, $token->{attributes}->{charset}->{value}, $token);
4271
4272 $meta_el->[0]->get_attribute_node_ns (undef, 'charset')
4273 ->set_user_data (manakai_has_reference =>
4274 $token->{attributes}->{charset}
4275 ->{has_reference});
4276 } elsif ($token->{attributes}->{content}) {
4277 if ($token->{attributes}->{content}->{value}
4278 =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt]
4279 [\x09\x0A\x0C\x0D\x20]*=
4280 [\x09\x0A\x0C\x0D\x20]*(?>"([^"]*)"|'([^']*)'|
4281 ([^"'\x09\x0A\x0C\x0D\x20][^\x09\x0A\x0C\x0D\x20\x3B]*))
4282 /x) {
4283 !!!cp ('t336');
4284 ## NOTE: Whether the encoding is supported or not is handled
4285 ## in the {change_encoding} callback.
4286 $self->{change_encoding}
4287 ->($self, defined $1 ? $1 : defined $2 ? $2 : $3, $token);
4288 $meta_el->[0]->get_attribute_node_ns (undef, 'content')
4289 ->set_user_data (manakai_has_reference =>
4290 $token->{attributes}->{content}
4291 ->{has_reference});
4292 }
4293 }
4294 } else {
4295 if ($token->{attributes}->{charset}) {
4296 !!!cp ('t337');
4297 $meta_el->[0]->get_attribute_node_ns (undef, 'charset')
4298 ->set_user_data (manakai_has_reference =>
4299 $token->{attributes}->{charset}
4300 ->{has_reference});
4301 }
4302 if ($token->{attributes}->{content}) {
4303 !!!cp ('t338');
4304 $meta_el->[0]->get_attribute_node_ns (undef, 'content')
4305 ->set_user_data (manakai_has_reference =>
4306 $token->{attributes}->{content}
4307 ->{has_reference});
4308 }
4309 }
4310
4311 !!!ack ('t338.1');
4312 !!!next-token;
4313 next B;
4314 } elsif ($token->{tag_name} eq 'title') {
4315 !!!cp ('t341');
4316 ## NOTE: This is an "as if in head" code clone
4317 $parse_rcdata->(RCDATA_CONTENT_MODEL);
4318 next B;
4319 } elsif ($token->{tag_name} eq 'body') {
4320 !!!parse-error (type => 'in body', text => 'body', token => $token);
4321
4322 if (@{$self->{open_elements}} == 1 or
4323 not ($self->{open_elements}->[1]->[1] == BODY_EL)) {
4324 !!!cp ('t342');
4325 ## Ignore the token
4326 } else {
4327 my $body_el = $self->{open_elements}->[1]->[0];
4328 for my $attr_name (keys %{$token->{attributes}}) {
4329 unless ($body_el->has_attribute_ns (undef, $attr_name)) {
4330 !!!cp ('t343');
4331 $body_el->set_attribute_ns
4332 (undef, [undef, $attr_name],
4333 $token->{attributes}->{$attr_name}->{value});
4334 }
4335 }
4336 }
4337 !!!nack ('t343.1');
4338 !!!next-token;
4339 next B;
4340 } elsif ({
4341 ## NOTE: Start tags for non-phrasing flow content elements
4342
4343 ## NOTE: The normal one
4344 address => 1, article => 1, aside => 1, blockquote => 1,
4345 center => 1, datagrid => 1, details => 1, dialog => 1,
4346 dir => 1, div => 1, dl => 1, fieldset => 1, figure => 1,
4347 footer => 1, h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1,
4348 h6 => 1, header => 1, hgroup => 1,
4349 menu => 1, nav => 1, ol => 1, p => 1,
4350 section => 1, ul => 1,
4351 ## NOTE: As normal, but drops leading newline
4352 pre => 1, listing => 1,
4353 ## NOTE: As normal, but interacts with the form element pointer
4354 form => 1,
4355
4356 table => 1,
4357 hr => 1,
4358 }->{$token->{tag_name}}) {
4359
4360 ## 1. When there is an opening |form| element:
4361 if ($token->{tag_name} eq 'form' and defined $self->{form_element}) {
4362 !!!cp ('t350');
4363 !!!parse-error (type => 'in form:form', token => $token);
4364 ## Ignore the token
4365 !!!nack ('t350.1');
4366 !!!next-token;
4367 next B;
4368 }
4369
4370 ## 2. Close the |p| element, if any.
4371 if ($token->{tag_name} ne 'table' or # The Hixie Quirk
4372 $self->{document}->manakai_compat_mode ne 'quirks') {
4373 ## has a p element in scope
4374 INSCOPE: for (reverse @{$self->{open_elements}}) {
4375 if ($_->[1] == P_EL) {
4376 !!!cp ('t344');
4377 !!!back-token; # <form>
4378 $token = {type => END_TAG_TOKEN, tag_name => 'p',
4379 line => $token->{line}, column => $token->{column}};
4380 next B;
4381 } elsif ($_->[1] & SCOPING_EL) {
4382 !!!cp ('t345');
4383 last INSCOPE;
4384 }
4385 } # INSCOPE
4386 }
4387
4388 ## 3. Close the opening <hn> element, if any.
4389 if ({h1 => 1, h2 => 1, h3 => 1,
4390 h4 => 1, h5 => 1, h6 => 1}->{$token->{tag_name}}) {
4391 if ($self->{open_elements}->[-1]->[1] == HEADING_EL) {
4392 !!!parse-error (type => 'not closed',
4393 text => $self->{open_elements}->[-1]->[0]->manakai_local_name,
4394 token => $token);
4395 pop @{$self->{open_elements}};
4396 }
4397 }
4398
4399 ## 4. Insertion.
4400 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4401 if ($token->{tag_name} eq 'pre' or $token->{tag_name} eq 'listing') {
4402 !!!nack ('t346.1');
4403 !!!next-token;
4404 if ($token->{type} == CHARACTER_TOKEN) {
4405 $token->{data} =~ s/^\x0A//;
4406 unless (length $token->{data}) {
4407 !!!cp ('t346');
4408 !!!next-token;
4409 } else {
4410 !!!cp ('t349');
4411 }
4412 } else {
4413 !!!cp ('t348');
4414 }
4415 } elsif ($token->{tag_name} eq 'form') {
4416 !!!cp ('t347.1');
4417 $self->{form_element} = $self->{open_elements}->[-1]->[0];
4418
4419 !!!nack ('t347.2');
4420 !!!next-token;
4421 } elsif ($token->{tag_name} eq 'table') {
4422 !!!cp ('t382');
4423 push @{$open_tables}, [$self->{open_elements}->[-1]->[0]];
4424
4425 $self->{insertion_mode} = IN_TABLE_IM;
4426
4427 !!!nack ('t382.1');
4428 !!!next-token;
4429 } elsif ($token->{tag_name} eq 'hr') {
4430 !!!cp ('t386');
4431 pop @{$self->{open_elements}};
4432
4433 !!!ack ('t386.1');
4434 !!!next-token;
4435 } else {
4436 !!!nack ('t347.1');
4437 !!!next-token;
4438 }
4439 next B;
4440 } elsif ($token->{tag_name} eq 'li') {
4441 ## NOTE: As normal, but imply </li> when there's another <li> ...
4442
4443 ## NOTE: Special, Scope (<li><foo><li> == <li><foo><li/></foo></li>)::
4444 ## Interpreted as <li><foo/></li><li/> (non-conforming):
4445 ## blockquote (O9.27), center (O), dd (Fx3, O, S3.1.2, IE7),
4446 ## dt (Fx, O, S, IE), dl (O), fieldset (O, S, IE), form (Fx, O, S),
4447 ## hn (O), pre (O), applet (O, S), button (O, S), marquee (Fx, O, S),
4448 ## object (Fx)
4449 ## Generate non-tree (non-conforming):
4450 ## basefont (IE7 (where basefont is non-void)), center (IE),
4451 ## form (IE), hn (IE)
4452 ## address, div, p (<li><foo><li> == <li><foo/></li><li/>)::
4453 ## Interpreted as <li><foo><li/></foo></li> (non-conforming):
4454 ## div (Fx, S)
4455
4456 my $non_optional;
4457 my $i = -1;
4458
4459 ## 1.
4460 for my $node (reverse @{$self->{open_elements}}) {
4461 if ($node->[1] == LI_EL) {
4462 ## 2. (a) As if </li>
4463 {
4464 ## If no </li> - not applied
4465 #
4466
4467 ## Otherwise
4468
4469 ## 1. generate implied end tags, except for </li>
4470 #
4471
4472 ## 2. If current node != "li", parse error
4473 if ($non_optional) {
4474 !!!parse-error (type => 'not closed',
4475 text => $non_optional->[0]->manakai_local_name,
4476 token => $token);
4477 !!!cp ('t355');
4478 } else {
4479 !!!cp ('t356');
4480 }
4481
4482 ## 3. Pop
4483 splice @{$self->{open_elements}}, $i;
4484 }
4485
4486 last; ## 2. (b) goto 5.
4487 } elsif (
4488 ## NOTE: not "formatting" and not "phrasing"
4489 ($node->[1] & SPECIAL_EL or
4490 $node->[1] & SCOPING_EL) and
4491 ## NOTE: "li", "dt", and "dd" are in |SPECIAL_EL|.
4492 (not $node->[1] & ADDRESS_DIV_P_EL)
4493 ) {
4494 ## 3.
4495 !!!cp ('t357');
4496 last; ## goto 5.
4497 } elsif ($node->[1] & END_TAG_OPTIONAL_EL) {
4498 !!!cp ('t358');
4499 #
4500 } else {
4501 !!!cp ('t359');
4502 $non_optional ||= $node;
4503 #
4504 }
4505 ## 4.
4506 ## goto 2.
4507 $i--;
4508 }
4509
4510 ## 5. (a) has a |p| element in scope
4511 INSCOPE: for (reverse @{$self->{open_elements}}) {
4512 if ($_->[1] == P_EL) {
4513 !!!cp ('t353');
4514
4515 ## NOTE: |<p><li>|, for example.
4516
4517 !!!back-token; # <x>
4518 $token = {type => END_TAG_TOKEN, tag_name => 'p',
4519 line => $token->{line}, column => $token->{column}};
4520 next B;
4521 } elsif ($_->[1] & SCOPING_EL) {
4522 !!!cp ('t354');
4523 last INSCOPE;
4524 }
4525 } # INSCOPE
4526
4527 ## 5. (b) insert
4528 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4529 !!!nack ('t359.1');
4530 !!!next-token;
4531 next B;
4532 } elsif ($token->{tag_name} eq 'dt' or
4533 $token->{tag_name} eq 'dd') {
4534 ## NOTE: As normal, but imply </dt> or </dd> when ...
4535
4536 my $non_optional;
4537 my $i = -1;
4538
4539 ## 1.
4540 for my $node (reverse @{$self->{open_elements}}) {
4541 if ($node->[1] == DTDD_EL) {
4542 ## 2. (a) As if </li>
4543 {
4544 ## If no </li> - not applied
4545 #
4546
4547 ## Otherwise
4548
4549 ## 1. generate implied end tags, except for </dt> or </dd>
4550 #
4551
4552 ## 2. If current node != "dt"|"dd", parse error
4553 if ($non_optional) {
4554 !!!parse-error (type => 'not closed',
4555 text => $non_optional->[0]->manakai_local_name,
4556 token => $token);
4557 !!!cp ('t355.1');
4558 } else {
4559 !!!cp ('t356.1');
4560 }
4561
4562 ## 3. Pop
4563 splice @{$self->{open_elements}}, $i;
4564 }
4565
4566 last; ## 2. (b) goto 5.
4567 } elsif (
4568 ## NOTE: not "formatting" and not "phrasing"
4569 ($node->[1] & SPECIAL_EL or
4570 $node->[1] & SCOPING_EL) and
4571 ## NOTE: "li", "dt", and "dd" are in |SPECIAL_EL|.
4572
4573 (not $node->[1] & ADDRESS_DIV_P_EL)
4574 ) {
4575 ## 3.
4576 !!!cp ('t357.1');
4577 last; ## goto 5.
4578 } elsif ($node->[1] & END_TAG_OPTIONAL_EL) {
4579 !!!cp ('t358.1');
4580 #
4581 } else {
4582 !!!cp ('t359.1');
4583 $non_optional ||= $node;
4584 #
4585 }
4586 ## 4.
4587 ## goto 2.
4588 $i--;
4589 }
4590
4591 ## 5. (a) has a |p| element in scope
4592 INSCOPE: for (reverse @{$self->{open_elements}}) {
4593 if ($_->[1] == P_EL) {
4594 !!!cp ('t353.1');
4595 !!!back-token; # <x>
4596 $token = {type => END_TAG_TOKEN, tag_name => 'p',
4597 line => $token->{line}, column => $token->{column}};
4598 next B;
4599 } elsif ($_->[1] & SCOPING_EL) {
4600 !!!cp ('t354.1');
4601 last INSCOPE;
4602 }
4603 } # INSCOPE
4604
4605 ## 5. (b) insert
4606 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4607 !!!nack ('t359.2');
4608 !!!next-token;
4609 next B;
4610 } elsif ($token->{tag_name} eq 'plaintext') {
4611 ## NOTE: As normal, but effectively ends parsing
4612
4613 ## has a p element in scope
4614 INSCOPE: for (reverse @{$self->{open_elements}}) {
4615 if ($_->[1] == P_EL) {
4616 !!!cp ('t367');
4617 !!!back-token; # <plaintext>
4618 $token = {type => END_TAG_TOKEN, tag_name => 'p',
4619 line => $token->{line}, column => $token->{column}};
4620 next B;
4621 } elsif ($_->[1] & SCOPING_EL) {
4622 !!!cp ('t368');
4623 last INSCOPE;
4624 }
4625 } # INSCOPE
4626
4627 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4628
4629 $self->{content_model} = PLAINTEXT_CONTENT_MODEL;
4630
4631 !!!nack ('t368.1');
4632 !!!next-token;
4633 next B;
4634 } elsif ($token->{tag_name} eq 'a') {
4635 AFE: for my $i (reverse 0..$#$active_formatting_elements) {
4636 my $node = $active_formatting_elements->[$i];
4637 if ($node->[1] == A_EL) {
4638 !!!cp ('t371');
4639 !!!parse-error (type => 'in a:a', token => $token);
4640
4641 !!!back-token; # <a>
4642 $token = {type => END_TAG_TOKEN, tag_name => 'a',
4643 line => $token->{line}, column => $token->{column}};
4644 $formatting_end_tag->($token);
4645
4646 AFE2: for (reverse 0..$#$active_formatting_elements) {
4647 if ($active_formatting_elements->[$_]->[0] eq $node->[0]) {
4648 !!!cp ('t372');
4649 splice @$active_formatting_elements, $_, 1;
4650 last AFE2;
4651 }
4652 } # AFE2
4653 OE: for (reverse 0..$#{$self->{open_elements}}) {
4654 if ($self->{open_elements}->[$_]->[0] eq $node->[0]) {
4655 !!!cp ('t373');
4656 splice @{$self->{open_elements}}, $_, 1;
4657 last OE;
4658 }
4659 } # OE
4660 last AFE;
4661 } elsif ($node->[0] eq '#marker') {
4662 !!!cp ('t374');
4663 last AFE;
4664 }
4665 } # AFE
4666
4667 $reconstruct_active_formatting_elements->($insert_to_current);
4668
4669 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4670 push @$active_formatting_elements, $self->{open_elements}->[-1];
4671
4672 !!!nack ('t374.1');
4673 !!!next-token;
4674 next B;
4675 } elsif ($token->{tag_name} eq 'nobr') {
4676 $reconstruct_active_formatting_elements->($insert_to_current);
4677
4678 ## has a |nobr| element in scope
4679 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4680 my $node = $self->{open_elements}->[$_];
4681 if ($node->[1] == NOBR_EL) {
4682 !!!cp ('t376');
4683 !!!parse-error (type => 'in nobr:nobr', token => $token);
4684 !!!back-token; # <nobr>
4685 $token = {type => END_TAG_TOKEN, tag_name => 'nobr',
4686 line => $token->{line}, column => $token->{column}};
4687 next B;
4688 } elsif ($node->[1] & SCOPING_EL) {
4689 !!!cp ('t377');
4690 last INSCOPE;
4691 }
4692 } # INSCOPE
4693
4694 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4695 push @$active_formatting_elements, $self->{open_elements}->[-1];
4696
4697 !!!nack ('t377.1');
4698 !!!next-token;
4699 next B;
4700 } elsif ($token->{tag_name} eq 'button') {
4701 ## has a button element in scope
4702 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4703 my $node = $self->{open_elements}->[$_];
4704 if ($node->[1] == BUTTON_EL) {
4705 !!!cp ('t378');
4706 !!!parse-error (type => 'in button:button', token => $token);
4707 !!!back-token; # <button>
4708 $token = {type => END_TAG_TOKEN, tag_name => 'button',
4709 line => $token->{line}, column => $token->{column}};
4710 next B;
4711 } elsif ($node->[1] & SCOPING_EL) {
4712 !!!cp ('t379');
4713 last INSCOPE;
4714 }
4715 } # INSCOPE
4716
4717 $reconstruct_active_formatting_elements->($insert_to_current);
4718
4719 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4720
4721 ## TODO: associate with $self->{form_element} if defined
4722
4723 push @$active_formatting_elements, ['#marker', ''];
4724
4725 !!!nack ('t379.1');
4726 !!!next-token;
4727 next B;
4728 } elsif ({
4729 xmp => 1,
4730 iframe => 1,
4731 noembed => 1,
4732 noframes => 1, ## NOTE: This is an "as if in head" code clone.
4733 noscript => 0, ## TODO: 1 if scripting is enabled
4734 }->{$token->{tag_name}}) {
4735 if ($token->{tag_name} eq 'xmp') {
4736 !!!cp ('t381');
4737 $reconstruct_active_formatting_elements->($insert_to_current);
4738 } else {
4739 !!!cp ('t399');
4740 }
4741 ## NOTE: There is an "as if in body" code clone.
4742 $parse_rcdata->(CDATA_CONTENT_MODEL);
4743 next B;
4744 } elsif ($token->{tag_name} eq 'isindex') {
4745 !!!parse-error (type => 'isindex', token => $token);
4746
4747 if (defined $self->{form_element}) {
4748 !!!cp ('t389');
4749 ## Ignore the token
4750 !!!nack ('t389'); ## NOTE: Not acknowledged.
4751 !!!next-token;
4752 next B;
4753 } else {
4754 !!!ack ('t391.1');
4755
4756 my $at = $token->{attributes};
4757 my $form_attrs;
4758 $form_attrs->{action} = $at->{action} if $at->{action};
4759 my $prompt_attr = $at->{prompt};
4760 $at->{name} = {name => 'name', value => 'isindex'};
4761 delete $at->{action};
4762 delete $at->{prompt};
4763 my @tokens = (
4764 {type => START_TAG_TOKEN, tag_name => 'form',
4765 attributes => $form_attrs,
4766 line => $token->{line}, column => $token->{column}},
4767 {type => START_TAG_TOKEN, tag_name => 'hr',
4768 line => $token->{line}, column => $token->{column}},
4769 {type => START_TAG_TOKEN, tag_name => 'label',
4770 line => $token->{line}, column => $token->{column}},
4771 );
4772 if ($prompt_attr) {
4773 !!!cp ('t390');
4774 push @tokens, {type => CHARACTER_TOKEN, data => $prompt_attr->{value},
4775 #line => $token->{line}, column => $token->{column},
4776 };
4777 } else {
4778 !!!cp ('t391');
4779 push @tokens, {type => CHARACTER_TOKEN,
4780 data => 'This is a searchable index. Insert your search keywords here: ',
4781 #line => $token->{line}, column => $token->{column},
4782 }; # SHOULD
4783 ## TODO: make this configurable
4784 }
4785 push @tokens,
4786 {type => START_TAG_TOKEN, tag_name => 'input', attributes => $at,
4787 line => $token->{line}, column => $token->{column}},
4788 #{type => CHARACTER_TOKEN, data => ''}, # SHOULD
4789 {type => END_TAG_TOKEN, tag_name => 'label',
4790 line => $token->{line}, column => $token->{column}},
4791 {type => START_TAG_TOKEN, tag_name => 'hr',
4792 line => $token->{line}, column => $token->{column}},
4793 {type => END_TAG_TOKEN, tag_name => 'form',
4794 line => $token->{line}, column => $token->{column}};
4795 !!!back-token (@tokens);
4796 !!!next-token;
4797 next B;
4798 }
4799 } elsif ($token->{tag_name} eq 'textarea') {
4800 ## 1. Insert
4801 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4802
4803 ## Step 2 # XXX
4804 ## TODO: $self->{form_element} if defined
4805
4806 ## 2. Drop U+000A LINE FEED
4807 $self->{ignore_newline} = 1;
4808
4809 ## 3. RCDATA
4810 $self->{content_model} = RCDATA_CONTENT_MODEL;
4811 delete $self->{escape}; # MUST
4812
4813 ## 4., 6. Insertion mode
4814 $self->{insertion_mode} |= IN_CDATA_RCDATA_IM;
4815
4816 ## XXX: 5. frameset-ok flag
4817
4818 !!!nack ('t392.1');
4819 !!!next-token;
4820 next B;
4821 } elsif ($token->{tag_name} eq 'optgroup' or
4822 $token->{tag_name} eq 'option') {
4823 ## has an |option| element in scope
4824 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4825 my $node = $self->{open_elements}->[$_];
4826 if ($node->[1] == OPTION_EL) {
4827 !!!cp ('t397.1');
4828 ## NOTE: As if </option>
4829 !!!back-token; # <option> or <optgroup>
4830 $token = {type => END_TAG_TOKEN, tag_name => 'option',
4831 line => $token->{line}, column => $token->{column}};
4832 next B;
4833 } elsif ($node->[1] & SCOPING_EL) {
4834 !!!cp ('t397.2');
4835 last INSCOPE;
4836 }
4837 } # INSCOPE
4838
4839 $reconstruct_active_formatting_elements->($insert_to_current);
4840
4841 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4842
4843 !!!nack ('t397.3');
4844 !!!next-token;
4845 redo B;
4846 } elsif ($token->{tag_name} eq 'rt' or
4847 $token->{tag_name} eq 'rp') {
4848 ## has a |ruby| element in scope
4849 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4850 my $node = $self->{open_elements}->[$_];
4851 if ($node->[1] == RUBY_EL) {
4852 !!!cp ('t398.1');
4853 ## generate implied end tags
4854 while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
4855 !!!cp ('t398.2');
4856 pop @{$self->{open_elements}};
4857 }
4858 unless ($self->{open_elements}->[-1]->[1] == RUBY_EL) {
4859 !!!cp ('t398.3');
4860 !!!parse-error (type => 'not closed',
4861 text => $self->{open_elements}->[-1]->[0]
4862 ->manakai_local_name,
4863 token => $token);
4864 pop @{$self->{open_elements}}
4865 while not $self->{open_elements}->[-1]->[1] == RUBY_EL;
4866 }
4867 last INSCOPE;
4868 } elsif ($node->[1] & SCOPING_EL) {
4869 !!!cp ('t398.4');
4870 last INSCOPE;
4871 }
4872 } # INSCOPE
4873
4874 ## TODO: <non-ruby><rt> is not allowed.
4875
4876 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4877
4878 !!!nack ('t398.5');
4879 !!!next-token;
4880 redo B;
4881 } elsif ($token->{tag_name} eq 'math' or
4882 $token->{tag_name} eq 'svg') {
4883 $reconstruct_active_formatting_elements->($insert_to_current);
4884
4885 ## "Adjust MathML attributes" ('math' only) - done in insert-element-f
4886
4887 ## "adjust SVG attributes" ('svg' only) - done in insert-element-f
4888
4889 ## "adjust foreign attributes" - done in insert-element-f
4890
4891 !!!insert-element-f ($token->{tag_name} eq 'math' ? $MML_NS : $SVG_NS, $token->{tag_name}, $token->{attributes}, $token);
4892
4893 if ($self->{self_closing}) {
4894 pop @{$self->{open_elements}};
4895 !!!ack ('t398.6');
4896 } else {
4897 !!!cp ('t398.7');
4898 $self->{insertion_mode} |= IN_FOREIGN_CONTENT_IM;
4899 ## NOTE: |<body><math><mi><svg>| -> "in foreign content" insertion
4900 ## mode, "in body" (not "in foreign content") secondary insertion
4901 ## mode, maybe.
4902 }
4903
4904 !!!next-token;
4905 next B;
4906 } elsif ({
4907 caption => 1, col => 1, colgroup => 1, frame => 1,
4908 frameset => 1, head => 1,
4909 tbody => 1, td => 1, tfoot => 1, th => 1,
4910 thead => 1, tr => 1,
4911 }->{$token->{tag_name}}) {
4912 !!!cp ('t401');
4913 !!!parse-error (type => 'in body',
4914 text => $token->{tag_name}, token => $token);
4915 ## Ignore the token
4916 !!!nack ('t401.1'); ## NOTE: |<col/>| or |<frame/>| here is an error.
4917 !!!next-token;
4918 next B;
4919 } elsif ($token->{tag_name} eq 'param' or
4920 $token->{tag_name} eq 'source') {
4921 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4922 pop @{$self->{open_elements}};
4923
4924 !!!ack ('t398.5');
4925 !!!next-token;
4926 redo B;
4927 } else {
4928 if ($token->{tag_name} eq 'image') {
4929 !!!cp ('t384');
4930 !!!parse-error (type => 'image', token => $token);
4931 $token->{tag_name} = 'img';
4932 } else {
4933 !!!cp ('t385');
4934 }
4935
4936 ## NOTE: There is an "as if <br>" code clone.
4937 $reconstruct_active_formatting_elements->($insert_to_current);
4938
4939 !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4940
4941 if ({
4942 applet => 1, marquee => 1, object => 1,
4943 }->{$token->{tag_name}}) {
4944 !!!cp ('t380');
4945 push @$active_formatting_elements, ['#marker', ''];
4946 !!!nack ('t380.1');
4947 } elsif ({
4948 b => 1, big => 1, em => 1, font => 1, i => 1,
4949 s => 1, small => 1, strike => 1,
4950 strong => 1, tt => 1, u => 1,
4951 }->{$token->{tag_name}}) {
4952 !!!cp ('t375');
4953 push @$active_formatting_elements, $self->{open_elements}->[-1];
4954 !!!nack ('t375.1');
4955 } elsif ($token->{tag_name} eq 'input') {
4956 !!!cp ('t388');
4957 ## TODO: associate with $self->{form_element} if defined
4958 pop @{$self->{open_elements}};
4959 !!!ack ('t388.2');
4960 } elsif ({
4961 area => 1, basefont => 1, bgsound => 1, br => 1,
4962 embed => 1, img => 1, spacer => 1, wbr => 1,
4963 keygen => 1,
4964 }->{$token->{tag_name}}) {
4965 !!!cp ('t388.1');
4966 pop @{$self->{open_elements}};
4967 !!!ack ('t388.3');
4968 } elsif ($token->{tag_name} eq 'select') {
4969 ## TODO: associate with $self->{form_element} if defined
4970
4971 if ($self->{insertion_mode} & TABLE_IMS or
4972 $self->{insertion_mode} & BODY_TABLE_IMS or
4973 ($self->{insertion_mode} & IM_MASK) == IN_COLUMN_GROUP_IM) {
4974 !!!cp ('t400.1');
4975 $self->{insertion_mode} = IN_SELECT_IN_TABLE_IM;
4976 } else {
4977 !!!cp ('t400.2');
4978 $self->{insertion_mode} = IN_SELECT_IM;
4979 }
4980 !!!nack ('t400.3');
4981 } else {
4982 !!!nack ('t402');
4983 }
4984
4985 !!!next-token;
4986 next B;
4987 }
4988 } elsif ($token->{type} == END_TAG_TOKEN) {
4989 if ($token->{tag_name} eq 'body' or $token->{tag_name} eq 'html') {
4990
4991 ## 1. If not "have an element in scope":
4992 ## "has a |body| element in scope"
4993 my $i;
4994 INSCOPE: {
4995 for (reverse @{$self->{open_elements}}) {
4996 if ($_->[1] == BODY_EL) {
4997 !!!cp ('t405');
4998 $i = $_;
4999 last INSCOPE;
5000 } elsif ($_->[1] & SCOPING_EL) {
5001 !!!cp ('t405.1');
5002 last;
5003 }
5004 }
5005
5006 ## NOTE: |<marquee></body>|, |<svg><foreignobject></body>|,
5007 ## and fragment cases.
5008
5009 !!!parse-error (type => 'unmatched end tag',
5010 text => $token->{tag_name}, token => $token);
5011 ## Ignore the token. (</body> or </html>)
5012 !!!next-token;
5013 next B;
5014 } # INSCOPE
5015
5016 ## 2. If unclosed elements:
5017 for (@{$self->{open_elements}}) {
5018 unless ($_->[1] & ALL_END_TAG_OPTIONAL_EL ||
5019 $_->[1] == OPTGROUP_EL ||
5020 $_->[1] == OPTION_EL ||
5021 $_->[1] == RUBY_COMPONENT_EL) {
5022 !!!cp ('t403');
5023 !!!parse-error (type => 'not closed',
5024 text => $_->[0]->manakai_local_name,
5025 token => $token);
5026 last;
5027 } else {
5028 !!!cp ('t404');
5029 }
5030 }
5031
5032 ## 3. Switch the insertion mode.
5033 $self->{insertion_mode} = AFTER_BODY_IM;
5034 if ($token->{tag_name} eq 'body') {
5035 !!!next-token;
5036 } else { # html
5037 ## Reprocess.
5038 }
5039 next B;
5040 } elsif ({
5041 ## NOTE: End tags for non-phrasing flow content elements
5042
5043 ## NOTE: The normal ones
5044 address => 1, article => 1, aside => 1, blockquote => 1,
5045 center => 1, datagrid => 1, details => 1, dialog => 1,
5046 dir => 1, div => 1, dl => 1, fieldset => 1, figure => 1,
5047 footer => 1, header => 1, hgroup => 1,
5048 listing => 1, menu => 1, nav => 1,
5049 ol => 1, pre => 1, section => 1, ul => 1,
5050
5051 ## NOTE: As normal, but ... optional tags
5052 dd => 1, dt => 1, li => 1,
5053
5054 applet => 1, button => 1, marquee => 1, object => 1,
5055 }->{$token->{tag_name}}) {
5056 ## NOTE: Code for <li> start tags includes "as if </li>" code.
5057 ## Code for <dt> or <dd> start tags includes "as if </dt> or
5058 ## </dd>" code.
5059
5060 ## has an element in scope
5061 my $i;
5062 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5063 my $node = $self->{open_elements}->[$_];
5064 if ($node->[0]->manakai_local_name eq $token->{tag_name}) {
5065 !!!cp ('t410');
5066 $i = $_;
5067 last INSCOPE;
5068 } elsif ($node->[1] & SCOPING_EL) {
5069 !!!cp ('t411');
5070 last INSCOPE;
5071 }
5072 } # INSCOPE
5073
5074 unless (defined $i) { # has an element in scope
5075 !!!cp ('t413');
5076 !!!parse-error (type => 'unmatched end tag',
5077 text => $token->{tag_name}, token => $token);
5078 ## NOTE: Ignore the token.
5079 } else {
5080 ## Step 1. generate implied end tags
5081 while ({
5082 ## END_TAG_OPTIONAL_EL
5083 dd => ($token->{tag_name} ne 'dd'),
5084 dt => ($token->{tag_name} ne 'dt'),
5085 li => ($token->{tag_name} ne 'li'),
5086 option => 1,
5087 optgroup => 1,
5088 p => 1,
5089 rt => 1,
5090 rp => 1,
5091 }->{$self->{open_elements}->[-1]->[0]->manakai_local_name}) {
5092 !!!cp ('t409');
5093 pop @{$self->{open_elements}};
5094 }
5095
5096 ## Step 2.
5097 if ($self->{open_elements}->[-1]->[0]->manakai_local_name
5098 ne $token->{tag_name}) {
5099 !!!cp ('t412');
5100 !!!parse-error (type => 'not closed',
5101 text => $self->{open_elements}->[-1]->[0]
5102 ->manakai_local_name,
5103 token => $token);
5104 } else {
5105 !!!cp ('t414');
5106 }
5107
5108 ## Step 3.
5109 splice @{$self->{open_elements}}, $i;
5110
5111 ## Step 4.
5112 $clear_up_to_marker->()
5113 if {
5114 applet => 1, button => 1, marquee => 1, object => 1,
5115 }->{$token->{tag_name}};
5116 }
5117 !!!next-token;
5118 next B;
5119 } elsif ($token->{tag_name} eq 'form') {
5120 ## NOTE: As normal, but interacts with the form element pointer
5121
5122 undef $self->{form_element};
5123
5124 ## has an element in scope
5125 my $i;
5126 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5127 my $node = $self->{open_elements}->[$_];
5128 if ($node->[1] == FORM_EL) {
5129 !!!cp ('t418');
5130 $i = $_;
5131 last INSCOPE;
5132 } elsif ($node->[1] & SCOPING_EL) {
5133 !!!cp ('t419');
5134 last INSCOPE;
5135 }
5136 } # INSCOPE
5137
5138 unless (defined $i) { # has an element in scope
5139 !!!cp ('t421');
5140 !!!parse-error (type => 'unmatched end tag',
5141 text => $token->{tag_name}, token => $token);
5142 ## NOTE: Ignore the token.
5143 } else {
5144 ## Step 1. generate implied end tags
5145 while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
5146 !!!cp ('t417');
5147 pop @{$self->{open_elements}};
5148 }
5149
5150 ## Step 2.
5151 if ($self->{open_elements}->[-1]->[0]->manakai_local_name
5152 ne $token->{tag_name}) {
5153 !!!cp ('t417.1');
5154 !!!parse-error (type => 'not closed',
5155 text => $self->{open_elements}->[-1]->[0]
5156 ->manakai_local_name,
5157 token => $token);
5158 } else {
5159 !!!cp ('t420');
5160 }
5161
5162 ## Step 3.
5163 splice @{$self->{open_elements}}, $i;
5164 }
5165
5166 !!!next-token;
5167 next B;
5168 } elsif ({
5169 ## NOTE: As normal, except acts as a closer for any ...
5170 h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,
5171 }->{$token->{tag_name}}) {
5172 ## has an element in scope
5173 my $i;
5174 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5175 my $node = $self->{open_elements}->[$_];
5176 if ($node->[1] == HEADING_EL) {
5177 !!!cp ('t423');
5178 $i = $_;
5179 last INSCOPE;
5180 } elsif ($node->[1] & SCOPING_EL) {
5181 !!!cp ('t424');
5182 last INSCOPE;
5183 }
5184 } # INSCOPE
5185
5186 unless (defined $i) { # has an element in scope
5187 !!!cp ('t425.1');
5188 !!!parse-error (type => 'unmatched end tag',
5189 text => $token->{tag_name}, token => $token);
5190 ## NOTE: Ignore the token.
5191 } else {
5192 ## Step 1. generate implied end tags
5193 while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
5194 !!!cp ('t422');
5195 pop @{$self->{open_elements}};
5196 }
5197
5198 ## Step 2.
5199 if ($self->{open_elements}->[-1]->[0]->manakai_local_name
5200 ne $token->{tag_name}) {
5201 !!!cp ('t425');
5202 !!!parse-error (type => 'unmatched end tag',
5203 text => $token->{tag_name}, token => $token);
5204 } else {
5205 !!!cp ('t426');
5206 }
5207
5208 ## Step 3.
5209 splice @{$self->{open_elements}}, $i;
5210 }
5211
5212 !!!next-token;
5213 next B;
5214 } elsif ($token->{tag_name} eq 'p') {
5215 ## NOTE: As normal, except </p> implies <p> and ...
5216
5217 ## has an element in scope
5218 my $non_optional;
5219 my $i;
5220 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5221 my $node = $self->{open_elements}->[$_];
5222 if ($node->[1] == P_EL) {
5223 !!!cp ('t410.1');
5224 $i = $_;
5225 last INSCOPE;
5226 } elsif ($node->[1] & SCOPING_EL) {
5227 !!!cp ('t411.1');
5228 last INSCOPE;
5229 } elsif ($node->[1] & END_TAG_OPTIONAL_EL) {
5230 ## NOTE: |END_TAG_OPTIONAL_EL| includes "p"
5231 !!!cp ('t411.2');
5232 #
5233 } else {
5234 !!!cp ('t411.3');
5235 $non_optional ||= $node;
5236 #
5237 }
5238 } # INSCOPE
5239
5240 if (defined $i) {
5241 ## 1. Generate implied end tags
5242 #
5243
5244 ## 2. If current node != "p", parse error
5245 if ($non_optional) {
5246 !!!cp ('t412.1');
5247 !!!parse-error (type => 'not closed',
5248 text => $non_optional->[0]->manakai_local_name,
5249 token => $token);
5250 } else {
5251 !!!cp ('t414.1');
5252 }
5253
5254 ## 3. Pop
5255 splice @{$self->{open_elements}}, $i;
5256 } else {
5257 !!!cp ('t413.1');
5258 !!!parse-error (type => 'unmatched end tag',
5259 text => $token->{tag_name}, token => $token);
5260
5261 !!!cp ('t415.1');
5262 ## As if <p>, then reprocess the current token
5263 my $el;
5264 !!!create-element ($el, $HTML_NS, 'p',, $token);
5265 $insert->($el);
5266 ## NOTE: Not inserted into |$self->{open_elements}|.
5267 }
5268
5269 !!!next-token;
5270 next B;
5271 } elsif ({
5272 a => 1,
5273 b => 1, big => 1, em => 1, font => 1, i => 1,
5274 nobr => 1, s => 1, small => 1, strike => 1,
5275 strong => 1, tt => 1, u => 1,
5276 }->{$token->{tag_name}}) {
5277 !!!cp ('t427');
5278 $formatting_end_tag->($token);
5279 next B;
5280 } elsif ($token->{tag_name} eq 'br') {
5281 !!!cp ('t428');
5282 !!!parse-error (type => 'unmatched end tag',
5283 text => 'br', token => $token);
5284
5285 ## As if <br>
5286 $reconstruct_active_formatting_elements->($insert_to_current);
5287
5288 my $el;
5289 !!!create-element ($el, $HTML_NS, 'br',, $token);
5290 $insert->($el);
5291
5292 ## Ignore the token.
5293 !!!next-token;
5294 next B;
5295 } else {
5296 if ($token->{tag_name} eq 'sarcasm') {
5297 sleep 0.001; # take a deep breath
5298 }
5299
5300 ## Step 1
5301 my $node_i = -1;
5302 my $node = $self->{open_elements}->[$node_i];
5303
5304 ## Step 2
5305 S2: {
5306 my $node_tag_name = $node->[0]->manakai_local_name;
5307 $node_tag_name =~ tr/A-Z/a-z/; # for SVG camelCase tag names
5308 if ($node_tag_name eq $token->{tag_name}) {
5309 ## Step 1
5310 ## generate implied end tags
5311 while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
5312 !!!cp ('t430');
5313 ## NOTE: |<ruby><rt></ruby>|.
5314 ## ISSUE: <ruby><rt></rt> will also take this code path,
5315 ## which seems wrong.
5316 pop @{$self->{open_elements}};
5317 $node_i++;
5318 }
5319
5320 ## Step 2
5321 my $current_tag_name
5322 = $self->{open_elements}->[-1]->[0]->manakai_local_name;
5323 $current_tag_name =~ tr/A-Z/a-z/;
5324 if ($current_tag_name ne $token->{tag_name}) {
5325 !!!cp ('t431');
5326 ## NOTE: <x><y></x>
5327 !!!parse-error (type => 'not closed',
5328 text => $self->{open_elements}->[-1]->[0]
5329 ->manakai_local_name,
5330 token => $token);
5331 } else {
5332 !!!cp ('t432');
5333 }
5334
5335 ## Step 3
5336 splice @{$self->{open_elements}}, $node_i if $node_i < 0;
5337
5338 !!!next-token;
5339 last S2;
5340 } else {
5341 ## Step 3
5342 if (not ($node->[1] & FORMATTING_EL) and
5343 #not $phrasing_category->{$node->[1]} and
5344 ($node->[1] & SPECIAL_EL or
5345 $node->[1] & SCOPING_EL)) {
5346 !!!cp ('t433');
5347 !!!parse-error (type => 'unmatched end tag',
5348 text => $token->{tag_name}, token => $token);
5349 ## Ignore the token
5350 !!!next-token;
5351 last S2;
5352
5353 ## NOTE: |<span><dd></span>a|: In Safari 3.1.2 and Opera
5354 ## 9.27, "a" is a child of <dd> (conforming). In
5355 ## Firefox 3.0.2, "a" is a child of <body>. In WinIE 7,
5356 ## "a" is a child of both <body> and <dd>.
5357 }
5358
5359 !!!cp ('t434');
5360 }
5361
5362 ## Step 4
5363 $node_i--;
5364 $node = $self->{open_elements}->[$node_i];
5365
5366 ## Step 5;
5367 redo S2;
5368 } # S2
5369 next B;
5370 }
5371 }
5372 next B;
5373 } continue { # B
5374 if ($self->{insertion_mode} & IN_FOREIGN_CONTENT_IM) {
5375 ## NOTE: The code below is executed in cases where it does not have
5376 ## to be, but it it is harmless even in those cases.
5377 ## has an element in scope
5378 INSCOPE: {
5379 for (reverse 0..$#{$self->{open_elements}}) {
5380 my $node = $self->{open_elements}->[$_];
5381 if ($node->[1] & FOREIGN_EL) {
5382 last INSCOPE;
5383 } elsif ($node->[1] & SCOPING_EL) {
5384 last;
5385 }
5386 }
5387
5388 ## NOTE: No foreign element in scope.
5389 $self->{insertion_mode} &= ~ IN_FOREIGN_CONTENT_IM;
5390 } # INSCOPE
5391 }
5392 } # B
5393
5394 ## Stop parsing # MUST
5395
5396 ## TODO: script stuffs
5397 } # _tree_construct_main
5398
5399 ## XXX: How this method is organized is somewhat out of date, although
5400 ## it still does what the current spec documents.
5401 sub set_inner_html ($$$$;$) {
5402 my $class = shift;
5403 my $node = shift; # /context/
5404 #my $s = \$_[0];
5405 my $onerror = $_[1];
5406 my $get_wrapper = $_[2] || sub ($) { return $_[0] };
5407
5408 my $nt = $node->node_type;
5409 if ($nt == 9) { # Document (invoke the algorithm with no /context/ element)
5410 # MUST
5411
5412 ## Step 1 # MUST
5413 ## TODO: If the document has an active parser, ...
5414 ## ISSUE: There is an issue in the spec.
5415
5416 ## Step 2 # MUST
5417 my @cn = @{$node->child_nodes};
5418 for (@cn) {
5419 $node->remove_child ($_);
5420 }
5421
5422 ## Step 3, 4, 5 # MUST
5423 $class->parse_char_string ($_[0] => $node, $onerror, $get_wrapper);
5424 } elsif ($nt == 1) { # Element (invoke the algorithm with /context/ element)
5425 ## TODO: If non-html element
5426
5427 ## NOTE: Most of this code is copied from |parse_string|
5428
5429 ## TODO: Support for $get_wrapper
5430
5431 ## F1. Create an HTML document.
5432 my $this_doc = $node->owner_document;
5433 my $doc = $this_doc->implementation->create_document;
5434 $doc->manakai_is_html (1);
5435
5436 ## F2. Propagate quirkness flag
5437 my $node_doc = $node->owner_document;
5438 $doc->manakai_compat_mode ($node_doc->manakai_compat_mode);
5439
5440 ## F3. Create an HTML parser
5441 my $p = $class->new;
5442 $p->{document} = $doc;
5443
5444 ## Step 8 # MUST
5445 my $i = 0;
5446 $p->{line_prev} = $p->{line} = 1;
5447 $p->{column_prev} = $p->{column} = 0;
5448 require Whatpm::Charset::DecodeHandle;
5449 my $input = Whatpm::Charset::DecodeHandle::CharString->new (\($_[0]));
5450 $input = $get_wrapper->($input);
5451 $p->{set_nc} = sub {
5452 my $self = shift;
5453
5454 my $char = '';
5455 if (defined $self->{next_nc}) {
5456 $char = $self->{next_nc};
5457 delete $self->{next_nc};
5458 $self->{nc} = ord $char;
5459 } else {
5460 $self->{char_buffer} = '';
5461 $self->{char_buffer_pos} = 0;
5462
5463 my $count = $input->manakai_read_until
5464 ($self->{char_buffer}, qr/[^\x00\x0A\x0D]/,
5465 $self->{char_buffer_pos});
5466 if ($count) {
5467 $self->{line_prev} = $self->{line};
5468 $self->{column_prev} = $self->{column};
5469 $self->{column}++;
5470 $self->{nc}
5471 = ord substr ($self->{char_buffer},
5472 $self->{char_buffer_pos}++, 1);
5473 return;
5474 }
5475
5476 if ($input->read ($char, 1)) {
5477 $self->{nc} = ord $char;
5478 } else {
5479 $self->{nc} = -1;
5480 return;
5481 }
5482 }
5483
5484 ($p->{line_prev}, $p->{column_prev}) = ($p->{line}, $p->{column});
5485 $p->{column}++;
5486
5487 if ($self->{nc} == 0x000A) { # LF
5488 $p->{line}++;
5489 $p->{column} = 0;
5490 !!!cp ('i1');
5491 } elsif ($self->{nc} == 0x000D) { # CR
5492 ## TODO: support for abort/streaming
5493 my $next = '';
5494 if ($input->read ($next, 1) and $next ne "\x0A") {
5495 $self->{next_nc} = $next;
5496 }
5497 $self->{nc} = 0x000A; # LF # MUST
5498 $p->{line}++;
5499 $p->{column} = 0;
5500 !!!cp ('i2');
5501 } elsif ($self->{nc} == 0x0000) { # NULL
5502 !!!cp ('i4');
5503 !!!parse-error (type => 'NULL');
5504 $self->{nc} = 0xFFFD; # REPLACEMENT CHARACTER # MUST
5505 }
5506 };
5507
5508 $p->{read_until} = sub {
5509 #my ($scalar, $specials_range, $offset) = @_;
5510 return 0 if defined $p->{next_nc};
5511
5512 my $pattern = qr/[^$_[1]\x00\x0A\x0D]/;
5513 my $offset = $_[2] || 0;
5514
5515 if ($p->{char_buffer_pos} < length $p->{char_buffer}) {
5516 pos ($p->{char_buffer}) = $p->{char_buffer_pos};
5517 if ($p->{char_buffer} =~ /\G(?>$pattern)+/) {
5518 substr ($_[0], $offset)
5519 = substr ($p->{char_buffer}, $-[0], $+[0] - $-[0]);
5520 my $count = $+[0] - $-[0];
5521 if ($count) {
5522 $p->{column} += $count;
5523 $p->{char_buffer_pos} += $count;
5524 $p->{line_prev} = $p->{line};
5525 $p->{column_prev} = $p->{column} - 1;
5526 $p->{nc} = -1;
5527 }
5528 return $count;
5529 } else {
5530 return 0;
5531 }
5532 } else {
5533 my $count = $input->manakai_read_until ($_[0], $pattern, $_[2]);
5534 if ($count) {
5535 $p->{column} += $count;
5536 $p->{column_prev} += $count;
5537 $p->{nc} = -1;
5538 }
5539 return $count;
5540 }
5541 }; # $p->{read_until}
5542
5543 my $ponerror = $onerror || sub {
5544 my (%opt) = @_;
5545 my $line = $opt{line};
5546 my $column = $opt{column};
5547 if (defined $opt{token} and defined $opt{token}->{line}) {
5548 $line = $opt{token}->{line};
5549 $column = $opt{token}->{column};
5550 }
5551 warn "Parse error ($opt{type}) at line $line column $column\n";
5552 };
5553 $p->{parse_error} = sub {
5554 $ponerror->(line => $p->{line}, column => $p->{column}, @_);
5555 };
5556
5557 my $char_onerror = sub {
5558 my (undef, $type, %opt) = @_;
5559 $ponerror->(layer => 'encode',
5560 line => $p->{line}, column => $p->{column} + 1,
5561 %opt, type => $type);
5562 }; # $char_onerror
5563 $input->onerror ($char_onerror);
5564
5565 $p->_initialize_tokenizer;
5566 $p->_initialize_tree_constructor;
5567
5568 ## F4. If /context/ is not undef...
5569
5570 ## F4.1. content model flag
5571 my $node_ln = $node->manakai_local_name;
5572 $p->{content_model} = {
5573 title => RCDATA_CONTENT_MODEL,
5574 textarea => RCDATA_CONTENT_MODEL,
5575 style => CDATA_CONTENT_MODEL,
5576 script => CDATA_CONTENT_MODEL,
5577 xmp => CDATA_CONTENT_MODEL,
5578 iframe => CDATA_CONTENT_MODEL,
5579 noembed => CDATA_CONTENT_MODEL,
5580 noframes => CDATA_CONTENT_MODEL,
5581 noscript => CDATA_CONTENT_MODEL,
5582 plaintext => PLAINTEXT_CONTENT_MODEL,
5583 }->{$node_ln};
5584 $p->{content_model} = PCDATA_CONTENT_MODEL
5585 unless defined $p->{content_model};
5586
5587 $p->{inner_html_node} = [$node, $el_category->{$node_ln}];
5588 ## TODO: Foreign element OK?
5589
5590 ## F4.2. Root |html| element
5591 my $root = $doc->create_element_ns
5592 ('http://www.w3.org/1999/xhtml', [undef, 'html']);
5593
5594 ## F4.3.
5595 $doc->append_child ($root);
5596
5597 ## F4.4.
5598 push @{$p->{open_elements}}, [$root, $el_category->{html}];
5599
5600 undef $p->{head_element};
5601 undef $p->{head_element_inserted};
5602
5603 ## F4.5.
5604 $p->_reset_insertion_mode;
5605
5606 ## F4.6.
5607 my $anode = $node;
5608 AN: while (defined $anode) {
5609 if ($anode->node_type == 1) {
5610 my $nsuri = $anode->namespace_uri;
5611 if (defined $nsuri and $nsuri eq 'http://www.w3.org/1999/xhtml') {
5612 if ($anode->manakai_local_name eq 'form') {
5613 !!!cp ('i5');
5614 $p->{form_element} = $anode;
5615 last AN;
5616 }
5617 }
5618 }
5619 $anode = $anode->parent_node;
5620 } # AN
5621
5622 ## F.5. Set the input stream.
5623 $p->{confident} = 1; ## Confident: irrelevant.
5624
5625 ## F.6. Start the parser.
5626 {
5627 my $self = $p;
5628 !!!next-token;
5629 }
5630 $p->_tree_construction_main;
5631
5632 ## F.7.
5633 my @cn = @{$node->child_nodes};
5634 for (@cn) {
5635 $node->remove_child ($_);
5636 }
5637 ## ISSUE: mutation events? read-only?
5638
5639 ## Step 11 # MUST
5640 @cn = @{$root->child_nodes};
5641 for (@cn) {
5642 $this_doc->adopt_node ($_);
5643 $node->append_child ($_);
5644 }
5645 ## ISSUE: mutation events?
5646
5647 $p->_terminate_tree_constructor;
5648
5649 delete $p->{parse_error}; # delete loop
5650 } else {
5651 die "$0: |set_inner_html| is not defined for node of type $nt";
5652 }
5653 } # set_inner_html
5654
5655 } # tree construction stage
5656
5657 package Whatpm::HTML::RestartParser;
5658 push our @ISA, 'Error';
5659
5660 1;
5661 # $Date: 2009/09/06 10:17:38 $
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.24