/[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.234 - (show annotations) (download) (as text)
Sun Sep 6 02:20:52 2009 UTC (17 years, 1 month ago) by wakaba
Branch: MAIN
Changes since 1.233: +39 -62 lines
File MIME type: application/x-wais-source 
++ whatpm/Whatpm/ChangeLog	6 Sep 2009 02:20:24 -0000
	* HTML.pm.src: Simplified foster parenting (HTML5 revision 2732).

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