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

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

Parent Directory Parent Directory | Revision Log Revision Log

Revision 1.90 - (hide annotations) (download)
Sat Mar 8 02:54:45 2008 UTC (18 years, 5 months ago) by wakaba
Branch: MAIN
Changes since 1.89: +2 -10 lines 
++ whatpm/Whatpm/ChangeLog	8 Mar 2008 02:51:41 -0000
	* HTML.pm.src: A "generate implied end tags" code (t409.1)
	could not be reached so that it is now removed (HTML5 revision
	1320).

2008-03-08  Wakaba  <wakaba@suika.fam.cx>
1 wakaba 1.2 package Whatpm::HTML;
2 wakaba 1.1 use strict;
3 wakaba 1.90 our $VERSION=do{my @r=(q$Revision: 1.89 $=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
4 wakaba 1.65 use Error qw(:try);
5 wakaba 1.1
6 wakaba 1.18 ## ISSUE:
7     ## var doc = implementation.createDocument (null, null, null);
8     ## doc.write ('');
9     ## alert (doc.compatMode);
10 wakaba 1.1
11 wakaba 1.71 ## TODO: Control charcters and noncharacters are not allowed (HTML5 revision 1263)
12     ## TODO: 1252 parse error (revision 1264)
13     ## TODO: 8859-11 = 874 (revision 1271)
14 wakaba 1.31
15 wakaba 1.1 my $permitted_slash_tag_name = {
16     base => 1,
17     link => 1,
18     meta => 1,
19     hr => 1,
20     br => 1,
21 wakaba 1.71 img => 1,
22 wakaba 1.1 embed => 1,
23     param => 1,
24     area => 1,
25     col => 1,
26     input => 1,
27     };
28    
29 wakaba 1.4 my $c1_entity_char = {
30 wakaba 1.9 0x80 => 0x20AC,
31     0x81 => 0xFFFD,
32     0x82 => 0x201A,
33     0x83 => 0x0192,
34     0x84 => 0x201E,
35     0x85 => 0x2026,
36     0x86 => 0x2020,
37     0x87 => 0x2021,
38     0x88 => 0x02C6,
39     0x89 => 0x2030,
40     0x8A => 0x0160,
41     0x8B => 0x2039,
42     0x8C => 0x0152,
43     0x8D => 0xFFFD,
44     0x8E => 0x017D,
45     0x8F => 0xFFFD,
46     0x90 => 0xFFFD,
47     0x91 => 0x2018,
48     0x92 => 0x2019,
49     0x93 => 0x201C,
50     0x94 => 0x201D,
51     0x95 => 0x2022,
52     0x96 => 0x2013,
53     0x97 => 0x2014,
54     0x98 => 0x02DC,
55     0x99 => 0x2122,
56     0x9A => 0x0161,
57     0x9B => 0x203A,
58     0x9C => 0x0153,
59     0x9D => 0xFFFD,
60     0x9E => 0x017E,
61     0x9F => 0x0178,
62 wakaba 1.4 }; # $c1_entity_char
63 wakaba 1.1
64     my $special_category = {
65     address => 1, area => 1, base => 1, basefont => 1, bgsound => 1,
66     blockquote => 1, body => 1, br => 1, center => 1, col => 1, colgroup => 1,
67     dd => 1, dir => 1, div => 1, dl => 1, dt => 1, embed => 1, fieldset => 1,
68     form => 1, frame => 1, frameset => 1, h1 => 1, h2 => 1, h3 => 1,
69     h4 => 1, h5 => 1, h6 => 1, head => 1, hr => 1, iframe => 1, image => 1,
70     img => 1, input => 1, isindex => 1, li => 1, link => 1, listing => 1,
71     menu => 1, meta => 1, noembed => 1, noframes => 1, noscript => 1,
72     ol => 1, optgroup => 1, option => 1, p => 1, param => 1, plaintext => 1,
73     pre => 1, script => 1, select => 1, spacer => 1, style => 1, tbody => 1,
74     textarea => 1, tfoot => 1, thead => 1, title => 1, tr => 1, ul => 1, wbr => 1,
75     };
76     my $scoping_category = {
77     button => 1, caption => 1, html => 1, marquee => 1, object => 1,
78     table => 1, td => 1, th => 1,
79     };
80     my $formatting_category = {
81     a => 1, b => 1, big => 1, em => 1, font => 1, i => 1, nobr => 1,
82     s => 1, small => 1, strile => 1, strong => 1, tt => 1, u => 1,
83     };
84     # $phrasing_category: all other elements
85    
86 wakaba 1.65 sub parse_byte_string ($$$$;$) {
87     my $self = ref $_[0] ? shift : shift->new;
88     my $charset = shift;
89     my $bytes_s = ref $_[0] ? $_[0] : \($_[0]);
90     my $s;
91    
92     if (defined $charset) {
93 wakaba 1.66 require Encode; ## TODO: decode(utf8) don't delete BOM
94 wakaba 1.65 $s = \ (Encode::decode ($charset, $$bytes_s));
95 wakaba 1.66 $self->{input_encoding} = lc $charset; ## TODO: normalize name
96 wakaba 1.65 $self->{confident} = 1;
97     } else {
98 wakaba 1.67 ## TODO: Implement HTML5 detection algorithm
99     require Whatpm::Charset::UniversalCharDet;
100     $charset = Whatpm::Charset::UniversalCharDet->detect_byte_string
101     (substr ($$bytes_s, 0, 1024));
102     $charset ||= 'windows-1252';
103 wakaba 1.66 $s = \ (Encode::decode ($charset, $$bytes_s));
104     $self->{input_encoding} = $charset;
105 wakaba 1.65 $self->{confident} = 0;
106     }
107    
108     $self->{change_encoding} = sub {
109     my $self = shift;
110     my $charset = lc shift;
111     ## TODO: if $charset is supported
112     ## TODO: normalize charset name
113    
114     ## "Change the encoding" algorithm:
115    
116     ## Step 1
117     if ($charset eq 'utf-16') { ## ISSUE: UTF-16BE -> UTF-8? UTF-16LE -> UTF-8?
118     $charset = 'utf-8';
119     }
120    
121     ## Step 2
122     if (defined $self->{input_encoding} and
123     $self->{input_encoding} eq $charset) {
124     $self->{confident} = 1;
125     return;
126     }
127    
128 wakaba 1.66 $self->{parse_error}-> (type => 'charset label detected:'.$self->{input_encoding}.
129     ':'.$charset, level => 'w');
130 wakaba 1.65
131     ## Step 3
132     # if (can) {
133     ## change the encoding on the fly.
134     #$self->{confident} = 1;
135     #return;
136     # }
137    
138     ## Step 4
139     throw Whatpm::HTML::RestartParser (charset => $charset);
140     }; # $self->{change_encoding}
141    
142     my @args = @_; shift @args; # $s
143     my $return;
144     try {
145     $return = $self->parse_char_string ($s, @args);
146     } catch Whatpm::HTML::RestartParser with {
147     my $charset = shift->{charset};
148     $s = \ (Encode::decode ($charset, $$bytes_s));
149 wakaba 1.66 $self->{input_encoding} = $charset; ## TODO: normalize
150 wakaba 1.65 $self->{confident} = 1;
151     $return = $self->parse_char_string ($s, @args);
152     };
153     return $return;
154     } # parse_byte_string
155    
156 wakaba 1.71 ## NOTE: HTML5 spec says that the encoding layer MUST NOT strip BOM
157     ## and the HTML layer MUST ignore it. However, we does strip BOM in
158     ## the encoding layer and the HTML layer does not ignore any U+FEFF,
159     ## because the core part of our HTML parser expects a string of character,
160     ## not a string of bytes or code units or anything which might contain a BOM.
161     ## Therefore, any parser interface that accepts a string of bytes,
162     ## such as |parse_byte_string| in this module, must ensure that it does
163     ## strip the BOM and never strip any ZWNBSP.
164    
165 wakaba 1.65 *parse_char_string = \&parse_string;
166    
167 wakaba 1.1 sub parse_string ($$$;$) {
168 wakaba 1.65 my $self = ref $_[0] ? shift : shift->new;
169     my $s = ref $_[0] ? $_[0] : \($_[0]);
170 wakaba 1.1 $self->{document} = $_[1];
171 wakaba 1.65 @{$self->{document}->child_nodes} = ();
172 wakaba 1.1
173 wakaba 1.3 ## NOTE: |set_inner_html| copies most of this method's code
174    
175 wakaba 1.65 $self->{confident} = 1 unless exists $self->{confident};
176 wakaba 1.66 $self->{document}->input_encoding ($self->{input_encoding})
177     if defined $self->{input_encoding};
178 wakaba 1.65
179 wakaba 1.1 my $i = 0;
180 wakaba 1.3 my $line = 1;
181     my $column = 0;
182 wakaba 1.76 $self->{set_next_char} = sub {
183 wakaba 1.1 my $self = shift;
184 wakaba 1.13
185 wakaba 1.76 pop @{$self->{prev_char}};
186     unshift @{$self->{prev_char}}, $self->{next_char};
187 wakaba 1.13
188 wakaba 1.76 $self->{next_char} = -1 and return if $i >= length $$s;
189     $self->{next_char} = ord substr $$s, $i++, 1;
190 wakaba 1.3 $column++;
191 wakaba 1.1
192 wakaba 1.76 if ($self->{next_char} == 0x000A) { # LF
193 wakaba 1.4 $line++;
194     $column = 0;
195 wakaba 1.76 } elsif ($self->{next_char} == 0x000D) { # CR
196 wakaba 1.15 $i++ if substr ($$s, $i, 1) eq "\x0A";
197 wakaba 1.76 $self->{next_char} = 0x000A; # LF # MUST
198 wakaba 1.3 $line++;
199 wakaba 1.4 $column = 0;
200 wakaba 1.76 } elsif ($self->{next_char} > 0x10FFFF) {
201     $self->{next_char} = 0xFFFD; # REPLACEMENT CHARACTER # MUST
202     } elsif ($self->{next_char} == 0x0000) { # NULL
203 wakaba 1.8 $self->{parse_error}-> (type => 'NULL');
204 wakaba 1.76 $self->{next_char} = 0xFFFD; # REPLACEMENT CHARACTER # MUST
205 wakaba 1.1 }
206     };
207 wakaba 1.76 $self->{prev_char} = [-1, -1, -1];
208     $self->{next_char} = -1;
209 wakaba 1.1
210 wakaba 1.3 my $onerror = $_[2] || sub {
211     my (%opt) = @_;
212     warn "Parse error ($opt{type}) at line $opt{line} column $opt{column}\n";
213     };
214     $self->{parse_error} = sub {
215     $onerror->(@_, line => $line, column => $column);
216 wakaba 1.1 };
217    
218     $self->_initialize_tokenizer;
219     $self->_initialize_tree_constructor;
220     $self->_construct_tree;
221     $self->_terminate_tree_constructor;
222    
223     return $self->{document};
224     } # parse_string
225    
226     sub new ($) {
227     my $class = shift;
228     my $self = bless {}, $class;
229 wakaba 1.76 $self->{set_next_char} = sub {
230     $self->{next_char} = -1;
231 wakaba 1.1 };
232     $self->{parse_error} = sub {
233     #
234     };
235 wakaba 1.65 $self->{change_encoding} = sub {
236     # if ($_[0] is a supported encoding) {
237     # run "change the encoding" algorithm;
238     # throw Whatpm::HTML::RestartParser (charset => $new_encoding);
239     # }
240     };
241 wakaba 1.63 $self->{application_cache_selection} = sub {
242     #
243     };
244 wakaba 1.1 return $self;
245     } # new
246    
247 wakaba 1.41 sub CM_ENTITY () { 0b001 } # & markup in data
248     sub CM_LIMITED_MARKUP () { 0b010 } # < markup in data (limited)
249     sub CM_FULL_MARKUP () { 0b100 } # < markup in data (any)
250    
251     sub PLAINTEXT_CONTENT_MODEL () { 0 }
252     sub CDATA_CONTENT_MODEL () { CM_LIMITED_MARKUP }
253     sub RCDATA_CONTENT_MODEL () { CM_ENTITY | CM_LIMITED_MARKUP }
254     sub PCDATA_CONTENT_MODEL () { CM_ENTITY | CM_FULL_MARKUP }
255    
256 wakaba 1.59 sub DATA_STATE () { 0 }
257     sub ENTITY_DATA_STATE () { 1 }
258     sub TAG_OPEN_STATE () { 2 }
259     sub CLOSE_TAG_OPEN_STATE () { 3 }
260     sub TAG_NAME_STATE () { 4 }
261     sub BEFORE_ATTRIBUTE_NAME_STATE () { 5 }
262     sub ATTRIBUTE_NAME_STATE () { 6 }
263     sub AFTER_ATTRIBUTE_NAME_STATE () { 7 }
264     sub BEFORE_ATTRIBUTE_VALUE_STATE () { 8 }
265     sub ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE () { 9 }
266     sub ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE () { 10 }
267     sub ATTRIBUTE_VALUE_UNQUOTED_STATE () { 11 }
268     sub ENTITY_IN_ATTRIBUTE_VALUE_STATE () { 12 }
269     sub MARKUP_DECLARATION_OPEN_STATE () { 13 }
270     sub COMMENT_START_STATE () { 14 }
271     sub COMMENT_START_DASH_STATE () { 15 }
272     sub COMMENT_STATE () { 16 }
273     sub COMMENT_END_STATE () { 17 }
274     sub COMMENT_END_DASH_STATE () { 18 }
275     sub BOGUS_COMMENT_STATE () { 19 }
276     sub DOCTYPE_STATE () { 20 }
277     sub BEFORE_DOCTYPE_NAME_STATE () { 21 }
278     sub DOCTYPE_NAME_STATE () { 22 }
279     sub AFTER_DOCTYPE_NAME_STATE () { 23 }
280     sub BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE () { 24 }
281     sub DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE () { 25 }
282     sub DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE () { 26 }
283     sub AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE () { 27 }
284     sub BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE () { 28 }
285     sub DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE () { 29 }
286     sub DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE () { 30 }
287     sub AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE () { 31 }
288     sub BOGUS_DOCTYPE_STATE () { 32 }
289 wakaba 1.72 sub AFTER_ATTRIBUTE_VALUE_QUOTED_STATE () { 33 }
290 wakaba 1.59
291 wakaba 1.57 sub DOCTYPE_TOKEN () { 1 }
292     sub COMMENT_TOKEN () { 2 }
293     sub START_TAG_TOKEN () { 3 }
294     sub END_TAG_TOKEN () { 4 }
295     sub END_OF_FILE_TOKEN () { 5 }
296     sub CHARACTER_TOKEN () { 6 }
297    
298 wakaba 1.56 sub AFTER_HTML_IMS () { 0b100 }
299     sub HEAD_IMS () { 0b1000 }
300     sub BODY_IMS () { 0b10000 }
301 wakaba 1.58 sub BODY_TABLE_IMS () { 0b100000 }
302 wakaba 1.56 sub TABLE_IMS () { 0b1000000 }
303 wakaba 1.58 sub ROW_IMS () { 0b10000000 }
304 wakaba 1.56 sub BODY_AFTER_IMS () { 0b100000000 }
305     sub FRAME_IMS () { 0b1000000000 }
306    
307 wakaba 1.85 ## NOTE: "initial" and "before html" insertion modes have no constants.
308 wakaba 1.84
309     ## NOTE: "after after body" insertion mode.
310 wakaba 1.56 sub AFTER_HTML_BODY_IM () { AFTER_HTML_IMS | BODY_AFTER_IMS }
311 wakaba 1.84
312     ## NOTE: "after after frameset" insertion mode.
313 wakaba 1.56 sub AFTER_HTML_FRAMESET_IM () { AFTER_HTML_IMS | FRAME_IMS }
314 wakaba 1.84
315 wakaba 1.56 sub IN_HEAD_IM () { HEAD_IMS | 0b00 }
316     sub IN_HEAD_NOSCRIPT_IM () { HEAD_IMS | 0b01 }
317     sub AFTER_HEAD_IM () { HEAD_IMS | 0b10 }
318     sub BEFORE_HEAD_IM () { HEAD_IMS | 0b11 }
319     sub IN_BODY_IM () { BODY_IMS }
320 wakaba 1.58 sub IN_CELL_IM () { BODY_IMS | BODY_TABLE_IMS | 0b01 }
321     sub IN_CAPTION_IM () { BODY_IMS | BODY_TABLE_IMS | 0b10 }
322     sub IN_ROW_IM () { TABLE_IMS | ROW_IMS | 0b01 }
323     sub IN_TABLE_BODY_IM () { TABLE_IMS | ROW_IMS | 0b10 }
324 wakaba 1.56 sub IN_TABLE_IM () { TABLE_IMS }
325     sub AFTER_BODY_IM () { BODY_AFTER_IMS }
326     sub IN_FRAMESET_IM () { FRAME_IMS | 0b01 }
327     sub AFTER_FRAMESET_IM () { FRAME_IMS | 0b10 }
328     sub IN_SELECT_IM () { 0b01 }
329     sub IN_COLUMN_GROUP_IM () { 0b10 }
330    
331 wakaba 1.1 ## Implementations MUST act as if state machine in the spec
332    
333     sub _initialize_tokenizer ($) {
334     my $self = shift;
335 wakaba 1.59 $self->{state} = DATA_STATE; # MUST
336 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # be
337 wakaba 1.1 undef $self->{current_token}; # start tag, end tag, comment, or DOCTYPE
338     undef $self->{current_attribute};
339     undef $self->{last_emitted_start_tag_name};
340     undef $self->{last_attribute_value_state};
341     $self->{char} = [];
342 wakaba 1.76 # $self->{next_char}
343 wakaba 1.1
344     if (@{$self->{char}}) {
345 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
346 wakaba 1.1 } else {
347 wakaba 1.76 $self->{set_next_char}->($self);
348 wakaba 1.1 }
349    
350     $self->{token} = [];
351 wakaba 1.18 # $self->{escape}
352 wakaba 1.1 } # _initialize_tokenizer
353    
354     ## A token has:
355 wakaba 1.57 ## ->{type} == DOCTYPE_TOKEN, START_TAG_TOKEN, END_TAG_TOKEN, COMMENT_TOKEN,
356     ## CHARACTER_TOKEN, or END_OF_FILE_TOKEN
357     ## ->{name} (DOCTYPE_TOKEN)
358     ## ->{tag_name} (START_TAG_TOKEN, END_TAG_TOKEN)
359     ## ->{public_identifier} (DOCTYPE_TOKEN)
360     ## ->{system_identifier} (DOCTYPE_TOKEN)
361 wakaba 1.75 ## ->{quirks} == 1 or 0 (DOCTYPE_TOKEN): "force-quirks" flag
362 wakaba 1.57 ## ->{attributes} isa HASH (START_TAG_TOKEN, END_TAG_TOKEN)
363 wakaba 1.68 ## ->{name}
364     ## ->{value}
365     ## ->{has_reference} == 1 or 0
366 wakaba 1.57 ## ->{data} (COMMENT_TOKEN, CHARACTER_TOKEN)
367 wakaba 1.1
368     ## Emitted token MUST immediately be handled by the tree construction state.
369    
370     ## Before each step, UA MAY check to see if either one of the scripts in
371     ## "list of scripts that will execute as soon as possible" or the first
372     ## script in the "list of scripts that will execute asynchronously",
373     ## has completed loading. If one has, then it MUST be executed
374     ## and removed from the list.
375    
376 wakaba 1.61 ## NOTE: HTML5 "Writing HTML documents" section, applied to
377     ## documents and not to user agents and conformance checkers,
378     ## contains some requirements that are not detected by the
379     ## parsing algorithm:
380     ## - Some requirements on character encoding declarations. ## TODO
381     ## - "Elements MUST NOT contain content that their content model disallows."
382     ## ... Some are parse error, some are not (will be reported by c.c.).
383     ## - Polytheistic slash SHOULD NOT be used. (Applied only to atheists.) ## TODO
384     ## - Text (in elements, attributes, and comments) SHOULD NOT contain
385     ## control characters other than space characters. ## TODO: (what is control character? C0, C1 and DEL? Unicode control character?)
386    
387     ## TODO: HTML5 poses authors two SHOULD-level requirements that cannot
388     ## be detected by the HTML5 parsing algorithm:
389     ## - Text,
390    
391 wakaba 1.1 sub _get_next_token ($) {
392     my $self = shift;
393     if (@{$self->{token}}) {
394     return shift @{$self->{token}};
395     }
396    
397     A: {
398 wakaba 1.59 if ($self->{state} == DATA_STATE) {
399 wakaba 1.76 if ($self->{next_char} == 0x0026) { # &
400 wakaba 1.72 if ($self->{content_model} & CM_ENTITY and # PCDATA | RCDATA
401     not $self->{escape}) {
402 wakaba 1.77
403 wakaba 1.59 $self->{state} = ENTITY_DATA_STATE;
404 wakaba 1.1
405     if (@{$self->{char}}) {
406 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
407 wakaba 1.1 } else {
408 wakaba 1.76 $self->{set_next_char}->($self);
409 wakaba 1.1 }
410    
411     redo A;
412     } else {
413 wakaba 1.77
414 wakaba 1.1 #
415     }
416 wakaba 1.76 } elsif ($self->{next_char} == 0x002D) { # -
417 wakaba 1.41 if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
418 wakaba 1.13 unless ($self->{escape}) {
419 wakaba 1.76 if ($self->{prev_char}->[0] == 0x002D and # -
420     $self->{prev_char}->[1] == 0x0021 and # !
421     $self->{prev_char}->[2] == 0x003C) { # <
422 wakaba 1.77
423 wakaba 1.13 $self->{escape} = 1;
424 wakaba 1.77 } else {
425    
426 wakaba 1.13 }
427 wakaba 1.77 } else {
428    
429 wakaba 1.13 }
430     }
431    
432     #
433 wakaba 1.76 } elsif ($self->{next_char} == 0x003C) { # <
434 wakaba 1.41 if ($self->{content_model} & CM_FULL_MARKUP or # PCDATA
435     (($self->{content_model} & CM_LIMITED_MARKUP) and # CDATA | RCDATA
436 wakaba 1.13 not $self->{escape})) {
437 wakaba 1.77
438 wakaba 1.59 $self->{state} = TAG_OPEN_STATE;
439 wakaba 1.1
440     if (@{$self->{char}}) {
441 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
442 wakaba 1.1 } else {
443 wakaba 1.76 $self->{set_next_char}->($self);
444 wakaba 1.1 }
445    
446     redo A;
447     } else {
448 wakaba 1.77
449 wakaba 1.1 #
450     }
451 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
452 wakaba 1.13 if ($self->{escape} and
453 wakaba 1.41 ($self->{content_model} & CM_LIMITED_MARKUP)) { # RCDATA | CDATA
454 wakaba 1.76 if ($self->{prev_char}->[0] == 0x002D and # -
455     $self->{prev_char}->[1] == 0x002D) { # -
456 wakaba 1.77
457 wakaba 1.13 delete $self->{escape};
458 wakaba 1.77 } else {
459    
460 wakaba 1.13 }
461 wakaba 1.77 } else {
462    
463 wakaba 1.13 }
464    
465     #
466 wakaba 1.76 } elsif ($self->{next_char} == -1) {
467 wakaba 1.77
468 wakaba 1.57 return ({type => END_OF_FILE_TOKEN});
469 wakaba 1.1 last A; ## TODO: ok?
470 wakaba 1.77 } else {
471    
472 wakaba 1.1 }
473     # Anything else
474 wakaba 1.57 my $token = {type => CHARACTER_TOKEN,
475 wakaba 1.76 data => chr $self->{next_char}};
476 wakaba 1.1 ## Stay in the data state
477    
478     if (@{$self->{char}}) {
479 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
480 wakaba 1.1 } else {
481 wakaba 1.76 $self->{set_next_char}->($self);
482 wakaba 1.1 }
483    
484    
485     return ($token);
486    
487     redo A;
488 wakaba 1.59 } elsif ($self->{state} == ENTITY_DATA_STATE) {
489 wakaba 1.1 ## (cannot happen in CDATA state)
490    
491 wakaba 1.72 my $token = $self->_tokenize_attempt_to_consume_an_entity (0, -1);
492 wakaba 1.1
493 wakaba 1.59 $self->{state} = DATA_STATE;
494 wakaba 1.1 # next-input-character is already done
495    
496     unless (defined $token) {
497 wakaba 1.77
498 wakaba 1.57 return ({type => CHARACTER_TOKEN, data => '&'});
499 wakaba 1.1 } else {
500 wakaba 1.77
501 wakaba 1.1 return ($token);
502     }
503    
504     redo A;
505 wakaba 1.59 } elsif ($self->{state} == TAG_OPEN_STATE) {
506 wakaba 1.41 if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
507 wakaba 1.76 if ($self->{next_char} == 0x002F) { # /
508 wakaba 1.1
509 wakaba 1.77
510 wakaba 1.1 if (@{$self->{char}}) {
511 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
512 wakaba 1.1 } else {
513 wakaba 1.76 $self->{set_next_char}->($self);
514 wakaba 1.1 }
515    
516 wakaba 1.59 $self->{state} = CLOSE_TAG_OPEN_STATE;
517 wakaba 1.1 redo A;
518     } else {
519 wakaba 1.77
520 wakaba 1.1 ## reconsume
521 wakaba 1.59 $self->{state} = DATA_STATE;
522 wakaba 1.1
523 wakaba 1.57 return ({type => CHARACTER_TOKEN, data => '<'});
524 wakaba 1.1
525     redo A;
526     }
527 wakaba 1.41 } elsif ($self->{content_model} & CM_FULL_MARKUP) { # PCDATA
528 wakaba 1.76 if ($self->{next_char} == 0x0021) { # !
529 wakaba 1.77
530 wakaba 1.59 $self->{state} = MARKUP_DECLARATION_OPEN_STATE;
531 wakaba 1.1
532     if (@{$self->{char}}) {
533 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
534 wakaba 1.1 } else {
535 wakaba 1.76 $self->{set_next_char}->($self);
536 wakaba 1.1 }
537    
538     redo A;
539 wakaba 1.76 } elsif ($self->{next_char} == 0x002F) { # /
540 wakaba 1.77
541 wakaba 1.59 $self->{state} = CLOSE_TAG_OPEN_STATE;
542 wakaba 1.1
543     if (@{$self->{char}}) {
544 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
545 wakaba 1.1 } else {
546 wakaba 1.76 $self->{set_next_char}->($self);
547 wakaba 1.1 }
548    
549     redo A;
550 wakaba 1.76 } elsif (0x0041 <= $self->{next_char} and
551     $self->{next_char} <= 0x005A) { # A..Z
552 wakaba 1.77
553 wakaba 1.1 $self->{current_token}
554 wakaba 1.57 = {type => START_TAG_TOKEN,
555 wakaba 1.76 tag_name => chr ($self->{next_char} + 0x0020)};
556 wakaba 1.59 $self->{state} = TAG_NAME_STATE;
557 wakaba 1.1
558     if (@{$self->{char}}) {
559 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
560 wakaba 1.1 } else {
561 wakaba 1.76 $self->{set_next_char}->($self);
562 wakaba 1.1 }
563    
564     redo A;
565 wakaba 1.76 } elsif (0x0061 <= $self->{next_char} and
566     $self->{next_char} <= 0x007A) { # a..z
567 wakaba 1.77
568 wakaba 1.57 $self->{current_token} = {type => START_TAG_TOKEN,
569 wakaba 1.76 tag_name => chr ($self->{next_char})};
570 wakaba 1.59 $self->{state} = TAG_NAME_STATE;
571 wakaba 1.1
572     if (@{$self->{char}}) {
573 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
574 wakaba 1.1 } else {
575 wakaba 1.76 $self->{set_next_char}->($self);
576 wakaba 1.1 }
577    
578     redo A;
579 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
580 wakaba 1.77
581 wakaba 1.3 $self->{parse_error}-> (type => 'empty start tag');
582 wakaba 1.59 $self->{state} = DATA_STATE;
583 wakaba 1.1
584     if (@{$self->{char}}) {
585 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
586 wakaba 1.1 } else {
587 wakaba 1.76 $self->{set_next_char}->($self);
588 wakaba 1.1 }
589    
590    
591 wakaba 1.57 return ({type => CHARACTER_TOKEN, data => '<>'});
592 wakaba 1.1
593     redo A;
594 wakaba 1.76 } elsif ($self->{next_char} == 0x003F) { # ?
595 wakaba 1.77
596 wakaba 1.3 $self->{parse_error}-> (type => 'pio');
597 wakaba 1.59 $self->{state} = BOGUS_COMMENT_STATE;
598 wakaba 1.76 ## $self->{next_char} is intentionally left as is
599 wakaba 1.1 redo A;
600     } else {
601 wakaba 1.77
602 wakaba 1.3 $self->{parse_error}-> (type => 'bare stago');
603 wakaba 1.59 $self->{state} = DATA_STATE;
604 wakaba 1.1 ## reconsume
605    
606 wakaba 1.57 return ({type => CHARACTER_TOKEN, data => '<'});
607 wakaba 1.1
608     redo A;
609     }
610     } else {
611 wakaba 1.41 die "$0: $self->{content_model} in tag open";
612 wakaba 1.1 }
613 wakaba 1.59 } elsif ($self->{state} == CLOSE_TAG_OPEN_STATE) {
614 wakaba 1.41 if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
615 wakaba 1.23 if (defined $self->{last_emitted_start_tag_name}) {
616 wakaba 1.30 ## NOTE: <http://krijnhoetmer.nl/irc-logs/whatwg/20070626#l-564>
617 wakaba 1.23 my @next_char;
618     TAGNAME: for (my $i = 0; $i < length $self->{last_emitted_start_tag_name}; $i++) {
619 wakaba 1.76 push @next_char, $self->{next_char};
620 wakaba 1.23 my $c = ord substr ($self->{last_emitted_start_tag_name}, $i, 1);
621     my $C = 0x0061 <= $c && $c <= 0x007A ? $c - 0x0020 : $c;
622 wakaba 1.76 if ($self->{next_char} == $c or $self->{next_char} == $C) {
623 wakaba 1.23
624 wakaba 1.77
625 wakaba 1.1 if (@{$self->{char}}) {
626 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
627 wakaba 1.1 } else {
628 wakaba 1.76 $self->{set_next_char}->($self);
629 wakaba 1.1 }
630    
631 wakaba 1.23 next TAGNAME;
632     } else {
633 wakaba 1.77
634 wakaba 1.76 $self->{next_char} = shift @next_char; # reconsume
635 wakaba 1.23 unshift @{$self->{char}}, (@next_char);
636 wakaba 1.59 $self->{state} = DATA_STATE;
637 wakaba 1.23
638 wakaba 1.57 return ({type => CHARACTER_TOKEN, data => '</'});
639 wakaba 1.23
640     redo A;
641     }
642     }
643 wakaba 1.76 push @next_char, $self->{next_char};
644 wakaba 1.23
645 wakaba 1.76 unless ($self->{next_char} == 0x0009 or # HT
646     $self->{next_char} == 0x000A or # LF
647     $self->{next_char} == 0x000B or # VT
648     $self->{next_char} == 0x000C or # FF
649     $self->{next_char} == 0x0020 or # SP
650     $self->{next_char} == 0x003E or # >
651     $self->{next_char} == 0x002F or # /
652     $self->{next_char} == -1) {
653 wakaba 1.77
654 wakaba 1.76 $self->{next_char} = shift @next_char; # reconsume
655 wakaba 1.1 unshift @{$self->{char}}, (@next_char);
656 wakaba 1.59 $self->{state} = DATA_STATE;
657 wakaba 1.57 return ({type => CHARACTER_TOKEN, data => '</'});
658 wakaba 1.1 redo A;
659 wakaba 1.23 } else {
660 wakaba 1.77
661 wakaba 1.76 $self->{next_char} = shift @next_char;
662 wakaba 1.23 unshift @{$self->{char}}, (@next_char);
663     # and consume...
664 wakaba 1.1 }
665 wakaba 1.23 } else {
666     ## No start tag token has ever been emitted
667 wakaba 1.77
668 wakaba 1.23 # next-input-character is already done
669 wakaba 1.59 $self->{state} = DATA_STATE;
670 wakaba 1.57 return ({type => CHARACTER_TOKEN, data => '</'});
671 wakaba 1.1 redo A;
672     }
673     }
674    
675 wakaba 1.76 if (0x0041 <= $self->{next_char} and
676     $self->{next_char} <= 0x005A) { # A..Z
677 wakaba 1.77
678 wakaba 1.57 $self->{current_token} = {type => END_TAG_TOKEN,
679 wakaba 1.76 tag_name => chr ($self->{next_char} + 0x0020)};
680 wakaba 1.59 $self->{state} = TAG_NAME_STATE;
681 wakaba 1.1
682     if (@{$self->{char}}) {
683 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
684 wakaba 1.1 } else {
685 wakaba 1.76 $self->{set_next_char}->($self);
686 wakaba 1.1 }
687    
688     redo A;
689 wakaba 1.76 } elsif (0x0061 <= $self->{next_char} and
690     $self->{next_char} <= 0x007A) { # a..z
691 wakaba 1.77
692 wakaba 1.57 $self->{current_token} = {type => END_TAG_TOKEN,
693 wakaba 1.76 tag_name => chr ($self->{next_char})};
694 wakaba 1.59 $self->{state} = TAG_NAME_STATE;
695 wakaba 1.1
696     if (@{$self->{char}}) {
697 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
698 wakaba 1.1 } else {
699 wakaba 1.76 $self->{set_next_char}->($self);
700 wakaba 1.1 }
701    
702     redo A;
703 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
704 wakaba 1.77
705 wakaba 1.3 $self->{parse_error}-> (type => 'empty end tag');
706 wakaba 1.59 $self->{state} = DATA_STATE;
707 wakaba 1.1
708     if (@{$self->{char}}) {
709 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
710 wakaba 1.1 } else {
711 wakaba 1.76 $self->{set_next_char}->($self);
712 wakaba 1.1 }
713    
714     redo A;
715 wakaba 1.76 } elsif ($self->{next_char} == -1) {
716 wakaba 1.77
717 wakaba 1.3 $self->{parse_error}-> (type => 'bare etago');
718 wakaba 1.59 $self->{state} = DATA_STATE;
719 wakaba 1.1 # reconsume
720    
721 wakaba 1.57 return ({type => CHARACTER_TOKEN, data => '</'});
722 wakaba 1.1
723     redo A;
724     } else {
725 wakaba 1.77
726 wakaba 1.3 $self->{parse_error}-> (type => 'bogus end tag');
727 wakaba 1.59 $self->{state} = BOGUS_COMMENT_STATE;
728 wakaba 1.76 ## $self->{next_char} is intentionally left as is
729 wakaba 1.1 redo A;
730     }
731 wakaba 1.59 } elsif ($self->{state} == TAG_NAME_STATE) {
732 wakaba 1.76 if ($self->{next_char} == 0x0009 or # HT
733     $self->{next_char} == 0x000A or # LF
734     $self->{next_char} == 0x000B or # VT
735     $self->{next_char} == 0x000C or # FF
736     $self->{next_char} == 0x0020) { # SP
737 wakaba 1.77
738 wakaba 1.59 $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
739 wakaba 1.1
740     if (@{$self->{char}}) {
741 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
742 wakaba 1.1 } else {
743 wakaba 1.76 $self->{set_next_char}->($self);
744 wakaba 1.1 }
745    
746     redo A;
747 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
748 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
749 wakaba 1.77
750 wakaba 1.28 $self->{current_token}->{first_start_tag}
751     = not defined $self->{last_emitted_start_tag_name};
752 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
753 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
754 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
755 wakaba 1.78 #if ($self->{current_token}->{attributes}) {
756     # ## NOTE: This should never be reached.
757     # !!! cp (36);
758     # !!! parse-error (type => 'end tag attribute');
759     #} else {
760 wakaba 1.77
761 wakaba 1.78 #}
762 wakaba 1.1 } else {
763     die "$0: $self->{current_token}->{type}: Unknown token type";
764     }
765 wakaba 1.59 $self->{state} = DATA_STATE;
766 wakaba 1.1
767     if (@{$self->{char}}) {
768 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
769 wakaba 1.1 } else {
770 wakaba 1.76 $self->{set_next_char}->($self);
771 wakaba 1.1 }
772    
773    
774     return ($self->{current_token}); # start tag or end tag
775    
776     redo A;
777 wakaba 1.76 } elsif (0x0041 <= $self->{next_char} and
778     $self->{next_char} <= 0x005A) { # A..Z
779 wakaba 1.77
780 wakaba 1.76 $self->{current_token}->{tag_name} .= chr ($self->{next_char} + 0x0020);
781 wakaba 1.1 # start tag or end tag
782     ## Stay in this state
783    
784     if (@{$self->{char}}) {
785 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
786 wakaba 1.1 } else {
787 wakaba 1.76 $self->{set_next_char}->($self);
788 wakaba 1.1 }
789    
790     redo A;
791 wakaba 1.76 } elsif ($self->{next_char} == -1) {
792 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed tag');
793 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
794 wakaba 1.77
795 wakaba 1.28 $self->{current_token}->{first_start_tag}
796     = not defined $self->{last_emitted_start_tag_name};
797 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
798 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
799 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
800 wakaba 1.78 #if ($self->{current_token}->{attributes}) {
801     # ## NOTE: This state should never be reached.
802     # !!! cp (40);
803     # !!! parse-error (type => 'end tag attribute');
804     #} else {
805 wakaba 1.77
806 wakaba 1.78 #}
807 wakaba 1.1 } else {
808     die "$0: $self->{current_token}->{type}: Unknown token type";
809     }
810 wakaba 1.59 $self->{state} = DATA_STATE;
811 wakaba 1.1 # reconsume
812    
813     return ($self->{current_token}); # start tag or end tag
814    
815     redo A;
816 wakaba 1.76 } elsif ($self->{next_char} == 0x002F) { # /
817 wakaba 1.1
818     if (@{$self->{char}}) {
819 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
820 wakaba 1.1 } else {
821 wakaba 1.76 $self->{set_next_char}->($self);
822 wakaba 1.1 }
823    
824 wakaba 1.76 if ($self->{next_char} == 0x003E and # >
825 wakaba 1.57 $self->{current_token}->{type} == START_TAG_TOKEN and
826 wakaba 1.1 $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
827     # permitted slash
828 wakaba 1.77
829 wakaba 1.1 #
830     } else {
831 wakaba 1.77
832 wakaba 1.3 $self->{parse_error}-> (type => 'nestc');
833 wakaba 1.1 }
834 wakaba 1.59 $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
835 wakaba 1.1 # next-input-character is already done
836     redo A;
837     } else {
838 wakaba 1.77
839 wakaba 1.76 $self->{current_token}->{tag_name} .= chr $self->{next_char};
840 wakaba 1.1 # start tag or end tag
841     ## Stay in the state
842    
843     if (@{$self->{char}}) {
844 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
845 wakaba 1.1 } else {
846 wakaba 1.76 $self->{set_next_char}->($self);
847 wakaba 1.1 }
848    
849     redo A;
850     }
851 wakaba 1.59 } elsif ($self->{state} == BEFORE_ATTRIBUTE_NAME_STATE) {
852 wakaba 1.76 if ($self->{next_char} == 0x0009 or # HT
853     $self->{next_char} == 0x000A or # LF
854     $self->{next_char} == 0x000B or # VT
855     $self->{next_char} == 0x000C or # FF
856     $self->{next_char} == 0x0020) { # SP
857 wakaba 1.77
858 wakaba 1.1 ## Stay in the state
859    
860     if (@{$self->{char}}) {
861 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
862 wakaba 1.1 } else {
863 wakaba 1.76 $self->{set_next_char}->($self);
864 wakaba 1.1 }
865    
866     redo A;
867 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
868 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
869 wakaba 1.77
870 wakaba 1.28 $self->{current_token}->{first_start_tag}
871     = not defined $self->{last_emitted_start_tag_name};
872 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
873 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
874 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
875 wakaba 1.1 if ($self->{current_token}->{attributes}) {
876 wakaba 1.77
877 wakaba 1.3 $self->{parse_error}-> (type => 'end tag attribute');
878 wakaba 1.77 } else {
879    
880 wakaba 1.1 }
881     } else {
882     die "$0: $self->{current_token}->{type}: Unknown token type";
883     }
884 wakaba 1.59 $self->{state} = DATA_STATE;
885 wakaba 1.1
886     if (@{$self->{char}}) {
887 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
888 wakaba 1.1 } else {
889 wakaba 1.76 $self->{set_next_char}->($self);
890 wakaba 1.1 }
891    
892    
893     return ($self->{current_token}); # start tag or end tag
894    
895     redo A;
896 wakaba 1.76 } elsif (0x0041 <= $self->{next_char} and
897     $self->{next_char} <= 0x005A) { # A..Z
898 wakaba 1.77
899 wakaba 1.76 $self->{current_attribute} = {name => chr ($self->{next_char} + 0x0020),
900 wakaba 1.1 value => ''};
901 wakaba 1.59 $self->{state} = ATTRIBUTE_NAME_STATE;
902 wakaba 1.1
903     if (@{$self->{char}}) {
904 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
905 wakaba 1.1 } else {
906 wakaba 1.76 $self->{set_next_char}->($self);
907 wakaba 1.1 }
908    
909     redo A;
910 wakaba 1.76 } elsif ($self->{next_char} == 0x002F) { # /
911 wakaba 1.1
912     if (@{$self->{char}}) {
913 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
914 wakaba 1.1 } else {
915 wakaba 1.76 $self->{set_next_char}->($self);
916 wakaba 1.1 }
917    
918 wakaba 1.76 if ($self->{next_char} == 0x003E and # >
919 wakaba 1.57 $self->{current_token}->{type} == START_TAG_TOKEN and
920 wakaba 1.1 $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
921     # permitted slash
922 wakaba 1.77
923 wakaba 1.1 #
924     } else {
925 wakaba 1.77
926 wakaba 1.3 $self->{parse_error}-> (type => 'nestc');
927 wakaba 1.1 }
928     ## Stay in the state
929     # next-input-character is already done
930     redo A;
931 wakaba 1.76 } elsif ($self->{next_char} == -1) {
932 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed tag');
933 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
934 wakaba 1.77
935 wakaba 1.28 $self->{current_token}->{first_start_tag}
936     = not defined $self->{last_emitted_start_tag_name};
937 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
938 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
939 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
940 wakaba 1.1 if ($self->{current_token}->{attributes}) {
941 wakaba 1.77
942 wakaba 1.3 $self->{parse_error}-> (type => 'end tag attribute');
943 wakaba 1.77 } else {
944    
945 wakaba 1.1 }
946     } else {
947     die "$0: $self->{current_token}->{type}: Unknown token type";
948     }
949 wakaba 1.59 $self->{state} = DATA_STATE;
950 wakaba 1.1 # reconsume
951    
952     return ($self->{current_token}); # start tag or end tag
953    
954     redo A;
955     } else {
956 wakaba 1.72 if ({
957     0x0022 => 1, # "
958     0x0027 => 1, # '
959     0x003D => 1, # =
960 wakaba 1.76 }->{$self->{next_char}}) {
961 wakaba 1.77
962 wakaba 1.72 $self->{parse_error}-> (type => 'bad attribute name');
963 wakaba 1.77 } else {
964    
965 wakaba 1.72 }
966 wakaba 1.76 $self->{current_attribute} = {name => chr ($self->{next_char}),
967 wakaba 1.1 value => ''};
968 wakaba 1.59 $self->{state} = ATTRIBUTE_NAME_STATE;
969 wakaba 1.1
970     if (@{$self->{char}}) {
971 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
972 wakaba 1.1 } else {
973 wakaba 1.76 $self->{set_next_char}->($self);
974 wakaba 1.1 }
975    
976     redo A;
977     }
978 wakaba 1.59 } elsif ($self->{state} == ATTRIBUTE_NAME_STATE) {
979 wakaba 1.1 my $before_leave = sub {
980     if (exists $self->{current_token}->{attributes} # start tag or end tag
981     ->{$self->{current_attribute}->{name}}) { # MUST
982 wakaba 1.77
983 wakaba 1.40 $self->{parse_error}-> (type => 'duplicate attribute:'.$self->{current_attribute}->{name});
984 wakaba 1.1 ## Discard $self->{current_attribute} # MUST
985     } else {
986 wakaba 1.77
987 wakaba 1.1 $self->{current_token}->{attributes}->{$self->{current_attribute}->{name}}
988     = $self->{current_attribute};
989     }
990     }; # $before_leave
991    
992 wakaba 1.76 if ($self->{next_char} == 0x0009 or # HT
993     $self->{next_char} == 0x000A or # LF
994     $self->{next_char} == 0x000B or # VT
995     $self->{next_char} == 0x000C or # FF
996     $self->{next_char} == 0x0020) { # SP
997 wakaba 1.77
998 wakaba 1.1 $before_leave->();
999 wakaba 1.59 $self->{state} = AFTER_ATTRIBUTE_NAME_STATE;
1000 wakaba 1.1
1001     if (@{$self->{char}}) {
1002 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1003 wakaba 1.1 } else {
1004 wakaba 1.76 $self->{set_next_char}->($self);
1005 wakaba 1.1 }
1006    
1007     redo A;
1008 wakaba 1.76 } elsif ($self->{next_char} == 0x003D) { # =
1009 wakaba 1.77
1010 wakaba 1.1 $before_leave->();
1011 wakaba 1.59 $self->{state} = BEFORE_ATTRIBUTE_VALUE_STATE;
1012 wakaba 1.1
1013     if (@{$self->{char}}) {
1014 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1015 wakaba 1.1 } else {
1016 wakaba 1.76 $self->{set_next_char}->($self);
1017 wakaba 1.1 }
1018    
1019     redo A;
1020 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
1021 wakaba 1.1 $before_leave->();
1022 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
1023 wakaba 1.77
1024 wakaba 1.28 $self->{current_token}->{first_start_tag}
1025     = not defined $self->{last_emitted_start_tag_name};
1026 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
1027 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
1028 wakaba 1.77
1029 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1030 wakaba 1.1 if ($self->{current_token}->{attributes}) {
1031 wakaba 1.3 $self->{parse_error}-> (type => 'end tag attribute');
1032 wakaba 1.1 }
1033     } else {
1034     die "$0: $self->{current_token}->{type}: Unknown token type";
1035     }
1036 wakaba 1.59 $self->{state} = DATA_STATE;
1037 wakaba 1.1
1038     if (@{$self->{char}}) {
1039 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1040 wakaba 1.1 } else {
1041 wakaba 1.76 $self->{set_next_char}->($self);
1042 wakaba 1.1 }
1043    
1044    
1045     return ($self->{current_token}); # start tag or end tag
1046    
1047     redo A;
1048 wakaba 1.76 } elsif (0x0041 <= $self->{next_char} and
1049     $self->{next_char} <= 0x005A) { # A..Z
1050 wakaba 1.77
1051 wakaba 1.76 $self->{current_attribute}->{name} .= chr ($self->{next_char} + 0x0020);
1052 wakaba 1.1 ## Stay in the state
1053    
1054     if (@{$self->{char}}) {
1055 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1056 wakaba 1.1 } else {
1057 wakaba 1.76 $self->{set_next_char}->($self);
1058 wakaba 1.1 }
1059    
1060     redo A;
1061 wakaba 1.76 } elsif ($self->{next_char} == 0x002F) { # /
1062 wakaba 1.1 $before_leave->();
1063    
1064     if (@{$self->{char}}) {
1065 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1066 wakaba 1.1 } else {
1067 wakaba 1.76 $self->{set_next_char}->($self);
1068 wakaba 1.1 }
1069    
1070 wakaba 1.76 if ($self->{next_char} == 0x003E and # >
1071 wakaba 1.57 $self->{current_token}->{type} == START_TAG_TOKEN and
1072 wakaba 1.1 $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
1073     # permitted slash
1074 wakaba 1.77
1075 wakaba 1.1 #
1076     } else {
1077 wakaba 1.77
1078 wakaba 1.3 $self->{parse_error}-> (type => 'nestc');
1079 wakaba 1.1 }
1080 wakaba 1.59 $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
1081 wakaba 1.1 # next-input-character is already done
1082     redo A;
1083 wakaba 1.76 } elsif ($self->{next_char} == -1) {
1084 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed tag');
1085 wakaba 1.1 $before_leave->();
1086 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
1087 wakaba 1.77
1088 wakaba 1.28 $self->{current_token}->{first_start_tag}
1089     = not defined $self->{last_emitted_start_tag_name};
1090 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
1091 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
1092 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1093 wakaba 1.1 if ($self->{current_token}->{attributes}) {
1094 wakaba 1.77
1095 wakaba 1.3 $self->{parse_error}-> (type => 'end tag attribute');
1096 wakaba 1.77 } else {
1097 wakaba 1.78 ## NOTE: This state should never be reached.
1098 wakaba 1.77
1099 wakaba 1.1 }
1100     } else {
1101     die "$0: $self->{current_token}->{type}: Unknown token type";
1102     }
1103 wakaba 1.59 $self->{state} = DATA_STATE;
1104 wakaba 1.1 # reconsume
1105    
1106     return ($self->{current_token}); # start tag or end tag
1107    
1108     redo A;
1109     } else {
1110 wakaba 1.76 if ($self->{next_char} == 0x0022 or # "
1111     $self->{next_char} == 0x0027) { # '
1112 wakaba 1.77
1113 wakaba 1.72 $self->{parse_error}-> (type => 'bad attribute name');
1114 wakaba 1.77 } else {
1115    
1116 wakaba 1.72 }
1117 wakaba 1.76 $self->{current_attribute}->{name} .= chr ($self->{next_char});
1118 wakaba 1.1 ## Stay in the state
1119    
1120     if (@{$self->{char}}) {
1121 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1122 wakaba 1.1 } else {
1123 wakaba 1.76 $self->{set_next_char}->($self);
1124 wakaba 1.1 }
1125    
1126     redo A;
1127     }
1128 wakaba 1.59 } elsif ($self->{state} == AFTER_ATTRIBUTE_NAME_STATE) {
1129 wakaba 1.76 if ($self->{next_char} == 0x0009 or # HT
1130     $self->{next_char} == 0x000A or # LF
1131     $self->{next_char} == 0x000B or # VT
1132     $self->{next_char} == 0x000C or # FF
1133     $self->{next_char} == 0x0020) { # SP
1134 wakaba 1.77
1135 wakaba 1.1 ## Stay in the state
1136    
1137     if (@{$self->{char}}) {
1138 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1139 wakaba 1.1 } else {
1140 wakaba 1.76 $self->{set_next_char}->($self);
1141 wakaba 1.1 }
1142    
1143     redo A;
1144 wakaba 1.76 } elsif ($self->{next_char} == 0x003D) { # =
1145 wakaba 1.77
1146 wakaba 1.59 $self->{state} = BEFORE_ATTRIBUTE_VALUE_STATE;
1147 wakaba 1.1
1148     if (@{$self->{char}}) {
1149 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1150 wakaba 1.1 } else {
1151 wakaba 1.76 $self->{set_next_char}->($self);
1152 wakaba 1.1 }
1153    
1154     redo A;
1155 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
1156 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
1157 wakaba 1.77
1158 wakaba 1.28 $self->{current_token}->{first_start_tag}
1159     = not defined $self->{last_emitted_start_tag_name};
1160 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
1161 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
1162 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1163 wakaba 1.1 if ($self->{current_token}->{attributes}) {
1164 wakaba 1.77
1165 wakaba 1.3 $self->{parse_error}-> (type => 'end tag attribute');
1166 wakaba 1.77 } else {
1167 wakaba 1.78 ## NOTE: This state should never be reached.
1168 wakaba 1.77
1169 wakaba 1.1 }
1170     } else {
1171     die "$0: $self->{current_token}->{type}: Unknown token type";
1172     }
1173 wakaba 1.59 $self->{state} = DATA_STATE;
1174 wakaba 1.1
1175     if (@{$self->{char}}) {
1176 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1177 wakaba 1.1 } else {
1178 wakaba 1.76 $self->{set_next_char}->($self);
1179 wakaba 1.1 }
1180    
1181    
1182     return ($self->{current_token}); # start tag or end tag
1183    
1184     redo A;
1185 wakaba 1.76 } elsif (0x0041 <= $self->{next_char} and
1186     $self->{next_char} <= 0x005A) { # A..Z
1187 wakaba 1.77
1188 wakaba 1.76 $self->{current_attribute} = {name => chr ($self->{next_char} + 0x0020),
1189 wakaba 1.1 value => ''};
1190 wakaba 1.59 $self->{state} = ATTRIBUTE_NAME_STATE;
1191 wakaba 1.1
1192     if (@{$self->{char}}) {
1193 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1194 wakaba 1.1 } else {
1195 wakaba 1.76 $self->{set_next_char}->($self);
1196 wakaba 1.1 }
1197    
1198     redo A;
1199 wakaba 1.76 } elsif ($self->{next_char} == 0x002F) { # /
1200 wakaba 1.1
1201     if (@{$self->{char}}) {
1202 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1203 wakaba 1.1 } else {
1204 wakaba 1.76 $self->{set_next_char}->($self);
1205 wakaba 1.1 }
1206    
1207 wakaba 1.76 if ($self->{next_char} == 0x003E and # >
1208 wakaba 1.57 $self->{current_token}->{type} == START_TAG_TOKEN and
1209 wakaba 1.1 $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
1210     # permitted slash
1211 wakaba 1.77
1212 wakaba 1.1 #
1213     } else {
1214 wakaba 1.77
1215 wakaba 1.3 $self->{parse_error}-> (type => 'nestc');
1216 wakaba 1.33 ## TODO: Different error type for <aa / bb> than <aa/>
1217 wakaba 1.1 }
1218 wakaba 1.59 $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
1219 wakaba 1.1 # next-input-character is already done
1220     redo A;
1221 wakaba 1.76 } elsif ($self->{next_char} == -1) {
1222 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed tag');
1223 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
1224 wakaba 1.77
1225 wakaba 1.28 $self->{current_token}->{first_start_tag}
1226     = not defined $self->{last_emitted_start_tag_name};
1227 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
1228 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
1229 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1230 wakaba 1.1 if ($self->{current_token}->{attributes}) {
1231 wakaba 1.77
1232 wakaba 1.3 $self->{parse_error}-> (type => 'end tag attribute');
1233 wakaba 1.77 } else {
1234 wakaba 1.78 ## NOTE: This state should never be reached.
1235 wakaba 1.77
1236 wakaba 1.1 }
1237     } else {
1238     die "$0: $self->{current_token}->{type}: Unknown token type";
1239     }
1240 wakaba 1.59 $self->{state} = DATA_STATE;
1241 wakaba 1.1 # reconsume
1242    
1243     return ($self->{current_token}); # start tag or end tag
1244    
1245     redo A;
1246     } else {
1247 wakaba 1.77
1248 wakaba 1.76 $self->{current_attribute} = {name => chr ($self->{next_char}),
1249 wakaba 1.1 value => ''};
1250 wakaba 1.59 $self->{state} = ATTRIBUTE_NAME_STATE;
1251 wakaba 1.1
1252     if (@{$self->{char}}) {
1253 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1254 wakaba 1.1 } else {
1255 wakaba 1.76 $self->{set_next_char}->($self);
1256 wakaba 1.1 }
1257    
1258     redo A;
1259     }
1260 wakaba 1.59 } elsif ($self->{state} == BEFORE_ATTRIBUTE_VALUE_STATE) {
1261 wakaba 1.76 if ($self->{next_char} == 0x0009 or # HT
1262     $self->{next_char} == 0x000A or # LF
1263     $self->{next_char} == 0x000B or # VT
1264     $self->{next_char} == 0x000C or # FF
1265     $self->{next_char} == 0x0020) { # SP
1266 wakaba 1.77
1267 wakaba 1.1 ## Stay in the state
1268    
1269     if (@{$self->{char}}) {
1270 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1271 wakaba 1.1 } else {
1272 wakaba 1.76 $self->{set_next_char}->($self);
1273 wakaba 1.1 }
1274    
1275     redo A;
1276 wakaba 1.76 } elsif ($self->{next_char} == 0x0022) { # "
1277 wakaba 1.77
1278 wakaba 1.59 $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
1279 wakaba 1.1
1280     if (@{$self->{char}}) {
1281 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1282 wakaba 1.1 } else {
1283 wakaba 1.76 $self->{set_next_char}->($self);
1284 wakaba 1.1 }
1285    
1286     redo A;
1287 wakaba 1.76 } elsif ($self->{next_char} == 0x0026) { # &
1288 wakaba 1.77
1289 wakaba 1.59 $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
1290 wakaba 1.1 ## reconsume
1291     redo A;
1292 wakaba 1.76 } elsif ($self->{next_char} == 0x0027) { # '
1293 wakaba 1.77
1294 wakaba 1.59 $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
1295 wakaba 1.1
1296     if (@{$self->{char}}) {
1297 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1298 wakaba 1.1 } else {
1299 wakaba 1.76 $self->{set_next_char}->($self);
1300 wakaba 1.1 }
1301    
1302     redo A;
1303 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
1304 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
1305 wakaba 1.77
1306 wakaba 1.28 $self->{current_token}->{first_start_tag}
1307     = not defined $self->{last_emitted_start_tag_name};
1308 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
1309 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
1310 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1311 wakaba 1.1 if ($self->{current_token}->{attributes}) {
1312 wakaba 1.77
1313 wakaba 1.3 $self->{parse_error}-> (type => 'end tag attribute');
1314 wakaba 1.77 } else {
1315 wakaba 1.78 ## NOTE: This state should never be reached.
1316 wakaba 1.77
1317 wakaba 1.1 }
1318     } else {
1319     die "$0: $self->{current_token}->{type}: Unknown token type";
1320     }
1321 wakaba 1.59 $self->{state} = DATA_STATE;
1322 wakaba 1.1
1323     if (@{$self->{char}}) {
1324 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1325 wakaba 1.1 } else {
1326 wakaba 1.76 $self->{set_next_char}->($self);
1327 wakaba 1.1 }
1328    
1329    
1330     return ($self->{current_token}); # start tag or end tag
1331    
1332     redo A;
1333 wakaba 1.76 } elsif ($self->{next_char} == -1) {
1334 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed tag');
1335 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
1336 wakaba 1.77
1337 wakaba 1.28 $self->{current_token}->{first_start_tag}
1338     = not defined $self->{last_emitted_start_tag_name};
1339 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
1340 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
1341 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1342 wakaba 1.1 if ($self->{current_token}->{attributes}) {
1343 wakaba 1.77
1344 wakaba 1.3 $self->{parse_error}-> (type => 'end tag attribute');
1345 wakaba 1.77 } else {
1346 wakaba 1.78 ## NOTE: This state should never be reached.
1347 wakaba 1.77
1348 wakaba 1.1 }
1349     } else {
1350     die "$0: $self->{current_token}->{type}: Unknown token type";
1351     }
1352 wakaba 1.59 $self->{state} = DATA_STATE;
1353 wakaba 1.1 ## reconsume
1354    
1355     return ($self->{current_token}); # start tag or end tag
1356    
1357     redo A;
1358     } else {
1359 wakaba 1.76 if ($self->{next_char} == 0x003D) { # =
1360 wakaba 1.77
1361 wakaba 1.72 $self->{parse_error}-> (type => 'bad attribute value');
1362 wakaba 1.77 } else {
1363    
1364 wakaba 1.72 }
1365 wakaba 1.76 $self->{current_attribute}->{value} .= chr ($self->{next_char});
1366 wakaba 1.59 $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
1367 wakaba 1.1
1368     if (@{$self->{char}}) {
1369 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1370 wakaba 1.1 } else {
1371 wakaba 1.76 $self->{set_next_char}->($self);
1372 wakaba 1.1 }
1373    
1374     redo A;
1375     }
1376 wakaba 1.59 } elsif ($self->{state} == ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE) {
1377 wakaba 1.76 if ($self->{next_char} == 0x0022) { # "
1378 wakaba 1.77
1379 wakaba 1.72 $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
1380 wakaba 1.1
1381     if (@{$self->{char}}) {
1382 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1383 wakaba 1.1 } else {
1384 wakaba 1.76 $self->{set_next_char}->($self);
1385 wakaba 1.1 }
1386    
1387     redo A;
1388 wakaba 1.76 } elsif ($self->{next_char} == 0x0026) { # &
1389 wakaba 1.77
1390 wakaba 1.59 $self->{last_attribute_value_state} = $self->{state};
1391     $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;
1392 wakaba 1.1
1393     if (@{$self->{char}}) {
1394 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1395 wakaba 1.1 } else {
1396 wakaba 1.76 $self->{set_next_char}->($self);
1397 wakaba 1.1 }
1398    
1399     redo A;
1400 wakaba 1.76 } elsif ($self->{next_char} == -1) {
1401 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed attribute value');
1402 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
1403 wakaba 1.77
1404 wakaba 1.28 $self->{current_token}->{first_start_tag}
1405     = not defined $self->{last_emitted_start_tag_name};
1406 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
1407 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
1408 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1409 wakaba 1.1 if ($self->{current_token}->{attributes}) {
1410 wakaba 1.77
1411 wakaba 1.3 $self->{parse_error}-> (type => 'end tag attribute');
1412 wakaba 1.77 } else {
1413 wakaba 1.78 ## NOTE: This state should never be reached.
1414 wakaba 1.77
1415 wakaba 1.1 }
1416     } else {
1417     die "$0: $self->{current_token}->{type}: Unknown token type";
1418     }
1419 wakaba 1.59 $self->{state} = DATA_STATE;
1420 wakaba 1.1 ## reconsume
1421    
1422     return ($self->{current_token}); # start tag or end tag
1423    
1424     redo A;
1425     } else {
1426 wakaba 1.77
1427 wakaba 1.76 $self->{current_attribute}->{value} .= chr ($self->{next_char});
1428 wakaba 1.1 ## Stay in the state
1429    
1430     if (@{$self->{char}}) {
1431 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1432 wakaba 1.1 } else {
1433 wakaba 1.76 $self->{set_next_char}->($self);
1434 wakaba 1.1 }
1435    
1436     redo A;
1437     }
1438 wakaba 1.59 } elsif ($self->{state} == ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE) {
1439 wakaba 1.76 if ($self->{next_char} == 0x0027) { # '
1440 wakaba 1.77
1441 wakaba 1.72 $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
1442 wakaba 1.1
1443     if (@{$self->{char}}) {
1444 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1445 wakaba 1.1 } else {
1446 wakaba 1.76 $self->{set_next_char}->($self);
1447 wakaba 1.1 }
1448    
1449     redo A;
1450 wakaba 1.76 } elsif ($self->{next_char} == 0x0026) { # &
1451 wakaba 1.77
1452 wakaba 1.59 $self->{last_attribute_value_state} = $self->{state};
1453     $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;
1454 wakaba 1.1
1455     if (@{$self->{char}}) {
1456 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1457 wakaba 1.1 } else {
1458 wakaba 1.76 $self->{set_next_char}->($self);
1459 wakaba 1.1 }
1460    
1461     redo A;
1462 wakaba 1.76 } elsif ($self->{next_char} == -1) {
1463 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed attribute value');
1464 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
1465 wakaba 1.77
1466 wakaba 1.28 $self->{current_token}->{first_start_tag}
1467     = not defined $self->{last_emitted_start_tag_name};
1468 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
1469 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
1470 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1471 wakaba 1.1 if ($self->{current_token}->{attributes}) {
1472 wakaba 1.77
1473 wakaba 1.3 $self->{parse_error}-> (type => 'end tag attribute');
1474 wakaba 1.77 } else {
1475 wakaba 1.78 ## NOTE: This state should never be reached.
1476 wakaba 1.77
1477 wakaba 1.1 }
1478     } else {
1479     die "$0: $self->{current_token}->{type}: Unknown token type";
1480     }
1481 wakaba 1.59 $self->{state} = DATA_STATE;
1482 wakaba 1.1 ## reconsume
1483    
1484     return ($self->{current_token}); # start tag or end tag
1485    
1486     redo A;
1487     } else {
1488 wakaba 1.77
1489 wakaba 1.76 $self->{current_attribute}->{value} .= chr ($self->{next_char});
1490 wakaba 1.1 ## Stay in the state
1491    
1492     if (@{$self->{char}}) {
1493 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1494 wakaba 1.1 } else {
1495 wakaba 1.76 $self->{set_next_char}->($self);
1496 wakaba 1.1 }
1497    
1498     redo A;
1499     }
1500 wakaba 1.59 } elsif ($self->{state} == ATTRIBUTE_VALUE_UNQUOTED_STATE) {
1501 wakaba 1.76 if ($self->{next_char} == 0x0009 or # HT
1502     $self->{next_char} == 0x000A or # LF
1503     $self->{next_char} == 0x000B or # HT
1504     $self->{next_char} == 0x000C or # FF
1505     $self->{next_char} == 0x0020) { # SP
1506 wakaba 1.77
1507 wakaba 1.59 $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
1508 wakaba 1.1
1509     if (@{$self->{char}}) {
1510 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1511 wakaba 1.1 } else {
1512 wakaba 1.76 $self->{set_next_char}->($self);
1513 wakaba 1.1 }
1514    
1515     redo A;
1516 wakaba 1.76 } elsif ($self->{next_char} == 0x0026) { # &
1517 wakaba 1.77
1518 wakaba 1.59 $self->{last_attribute_value_state} = $self->{state};
1519     $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;
1520 wakaba 1.1
1521     if (@{$self->{char}}) {
1522 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1523 wakaba 1.1 } else {
1524 wakaba 1.76 $self->{set_next_char}->($self);
1525 wakaba 1.1 }
1526    
1527     redo A;
1528 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
1529 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
1530 wakaba 1.77
1531 wakaba 1.28 $self->{current_token}->{first_start_tag}
1532     = not defined $self->{last_emitted_start_tag_name};
1533 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
1534 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
1535 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1536 wakaba 1.1 if ($self->{current_token}->{attributes}) {
1537 wakaba 1.77
1538 wakaba 1.3 $self->{parse_error}-> (type => 'end tag attribute');
1539 wakaba 1.77 } else {
1540 wakaba 1.78 ## NOTE: This state should never be reached.
1541 wakaba 1.77
1542 wakaba 1.1 }
1543     } else {
1544     die "$0: $self->{current_token}->{type}: Unknown token type";
1545     }
1546 wakaba 1.59 $self->{state} = DATA_STATE;
1547 wakaba 1.1
1548     if (@{$self->{char}}) {
1549 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1550 wakaba 1.1 } else {
1551 wakaba 1.76 $self->{set_next_char}->($self);
1552 wakaba 1.1 }
1553    
1554    
1555     return ($self->{current_token}); # start tag or end tag
1556    
1557     redo A;
1558 wakaba 1.76 } elsif ($self->{next_char} == -1) {
1559 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed tag');
1560 wakaba 1.57 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
1561 wakaba 1.77
1562 wakaba 1.28 $self->{current_token}->{first_start_tag}
1563     = not defined $self->{last_emitted_start_tag_name};
1564 wakaba 1.1 $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
1565 wakaba 1.57 } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
1566 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1567 wakaba 1.1 if ($self->{current_token}->{attributes}) {
1568 wakaba 1.77
1569 wakaba 1.3 $self->{parse_error}-> (type => 'end tag attribute');
1570 wakaba 1.77 } else {
1571 wakaba 1.78 ## NOTE: This state should never be reached.
1572 wakaba 1.77
1573 wakaba 1.1 }
1574     } else {
1575     die "$0: $self->{current_token}->{type}: Unknown token type";
1576     }
1577 wakaba 1.59 $self->{state} = DATA_STATE;
1578 wakaba 1.1 ## reconsume
1579    
1580     return ($self->{current_token}); # start tag or end tag
1581    
1582     redo A;
1583     } else {
1584 wakaba 1.72 if ({
1585     0x0022 => 1, # "
1586     0x0027 => 1, # '
1587     0x003D => 1, # =
1588 wakaba 1.76 }->{$self->{next_char}}) {
1589 wakaba 1.77
1590 wakaba 1.72 $self->{parse_error}-> (type => 'bad attribute value');
1591 wakaba 1.77 } else {
1592    
1593 wakaba 1.72 }
1594 wakaba 1.76 $self->{current_attribute}->{value} .= chr ($self->{next_char});
1595 wakaba 1.1 ## Stay in the state
1596    
1597     if (@{$self->{char}}) {
1598 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1599 wakaba 1.1 } else {
1600 wakaba 1.76 $self->{set_next_char}->($self);
1601 wakaba 1.1 }
1602    
1603     redo A;
1604     }
1605 wakaba 1.59 } elsif ($self->{state} == ENTITY_IN_ATTRIBUTE_VALUE_STATE) {
1606 wakaba 1.72 my $token = $self->_tokenize_attempt_to_consume_an_entity
1607     (1,
1608     $self->{last_attribute_value_state}
1609     == ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE ? 0x0022 : # "
1610     $self->{last_attribute_value_state}
1611     == ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE ? 0x0027 : # '
1612     -1);
1613 wakaba 1.1
1614     unless (defined $token) {
1615 wakaba 1.77
1616 wakaba 1.1 $self->{current_attribute}->{value} .= '&';
1617     } else {
1618 wakaba 1.77
1619 wakaba 1.1 $self->{current_attribute}->{value} .= $token->{data};
1620 wakaba 1.68 $self->{current_attribute}->{has_reference} = $token->{has_reference};
1621 wakaba 1.1 ## ISSUE: spec says "append the returned character token to the current attribute's value"
1622     }
1623    
1624     $self->{state} = $self->{last_attribute_value_state};
1625     # next-input-character is already done
1626     redo A;
1627 wakaba 1.72 } elsif ($self->{state} == AFTER_ATTRIBUTE_VALUE_QUOTED_STATE) {
1628 wakaba 1.76 if ($self->{next_char} == 0x0009 or # HT
1629     $self->{next_char} == 0x000A or # LF
1630     $self->{next_char} == 0x000B or # VT
1631     $self->{next_char} == 0x000C or # FF
1632     $self->{next_char} == 0x0020) { # SP
1633 wakaba 1.77
1634 wakaba 1.72 $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
1635    
1636     if (@{$self->{char}}) {
1637 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1638 wakaba 1.72 } else {
1639 wakaba 1.76 $self->{set_next_char}->($self);
1640 wakaba 1.72 }
1641    
1642     redo A;
1643 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
1644 wakaba 1.72 if ($self->{current_token}->{type} == START_TAG_TOKEN) {
1645 wakaba 1.77
1646 wakaba 1.72 $self->{current_token}->{first_start_tag}
1647     = not defined $self->{last_emitted_start_tag_name};
1648     $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
1649     } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
1650     $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1651     if ($self->{current_token}->{attributes}) {
1652 wakaba 1.77
1653 wakaba 1.72 $self->{parse_error}-> (type => 'end tag attribute');
1654 wakaba 1.77 } else {
1655 wakaba 1.78 ## NOTE: This state should never be reached.
1656 wakaba 1.77
1657 wakaba 1.72 }
1658     } else {
1659     die "$0: $self->{current_token}->{type}: Unknown token type";
1660     }
1661     $self->{state} = DATA_STATE;
1662    
1663     if (@{$self->{char}}) {
1664 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1665 wakaba 1.72 } else {
1666 wakaba 1.76 $self->{set_next_char}->($self);
1667 wakaba 1.72 }
1668    
1669    
1670     return ($self->{current_token}); # start tag or end tag
1671    
1672     redo A;
1673 wakaba 1.76 } elsif ($self->{next_char} == 0x002F) { # /
1674 wakaba 1.72
1675     if (@{$self->{char}}) {
1676 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1677 wakaba 1.72 } else {
1678 wakaba 1.76 $self->{set_next_char}->($self);
1679 wakaba 1.72 }
1680    
1681 wakaba 1.76 if ($self->{next_char} == 0x003E and # >
1682 wakaba 1.72 $self->{current_token}->{type} == START_TAG_TOKEN and
1683     $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
1684     # permitted slash
1685 wakaba 1.77
1686 wakaba 1.72 #
1687     } else {
1688 wakaba 1.77
1689 wakaba 1.72 $self->{parse_error}-> (type => 'nestc');
1690     }
1691     $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
1692     # next-input-character is already done
1693     redo A;
1694     } else {
1695 wakaba 1.77
1696 wakaba 1.72 $self->{parse_error}-> (type => 'no space between attributes');
1697     $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
1698     ## reconsume
1699     redo A;
1700     }
1701 wakaba 1.59 } elsif ($self->{state} == BOGUS_COMMENT_STATE) {
1702 wakaba 1.1 ## (only happen if PCDATA state)
1703    
1704 wakaba 1.57 my $token = {type => COMMENT_TOKEN, data => ''};
1705 wakaba 1.1
1706     BC: {
1707 wakaba 1.76 if ($self->{next_char} == 0x003E) { # >
1708 wakaba 1.77
1709 wakaba 1.59 $self->{state} = DATA_STATE;
1710 wakaba 1.1
1711     if (@{$self->{char}}) {
1712 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1713 wakaba 1.1 } else {
1714 wakaba 1.76 $self->{set_next_char}->($self);
1715 wakaba 1.1 }
1716    
1717    
1718     return ($token);
1719    
1720     redo A;
1721 wakaba 1.76 } elsif ($self->{next_char} == -1) {
1722 wakaba 1.77
1723 wakaba 1.59 $self->{state} = DATA_STATE;
1724 wakaba 1.1 ## reconsume
1725    
1726     return ($token);
1727    
1728     redo A;
1729     } else {
1730 wakaba 1.77
1731 wakaba 1.76 $token->{data} .= chr ($self->{next_char});
1732 wakaba 1.1
1733     if (@{$self->{char}}) {
1734 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1735 wakaba 1.1 } else {
1736 wakaba 1.76 $self->{set_next_char}->($self);
1737 wakaba 1.1 }
1738    
1739     redo BC;
1740     }
1741     } # BC
1742 wakaba 1.77
1743     die "$0: _get_next_token: unexpected case [BC]";
1744 wakaba 1.59 } elsif ($self->{state} == MARKUP_DECLARATION_OPEN_STATE) {
1745 wakaba 1.1 ## (only happen if PCDATA state)
1746    
1747     my @next_char;
1748 wakaba 1.76 push @next_char, $self->{next_char};
1749 wakaba 1.1
1750 wakaba 1.76 if ($self->{next_char} == 0x002D) { # -
1751 wakaba 1.1
1752     if (@{$self->{char}}) {
1753 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1754 wakaba 1.1 } else {
1755 wakaba 1.76 $self->{set_next_char}->($self);
1756 wakaba 1.1 }
1757    
1758 wakaba 1.76 push @next_char, $self->{next_char};
1759     if ($self->{next_char} == 0x002D) { # -
1760 wakaba 1.77
1761 wakaba 1.57 $self->{current_token} = {type => COMMENT_TOKEN, data => ''};
1762 wakaba 1.59 $self->{state} = COMMENT_START_STATE;
1763 wakaba 1.1
1764     if (@{$self->{char}}) {
1765 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1766 wakaba 1.1 } else {
1767 wakaba 1.76 $self->{set_next_char}->($self);
1768 wakaba 1.1 }
1769    
1770     redo A;
1771 wakaba 1.77 } else {
1772    
1773 wakaba 1.1 }
1774 wakaba 1.76 } elsif ($self->{next_char} == 0x0044 or # D
1775     $self->{next_char} == 0x0064) { # d
1776 wakaba 1.1
1777     if (@{$self->{char}}) {
1778 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1779 wakaba 1.1 } else {
1780 wakaba 1.76 $self->{set_next_char}->($self);
1781 wakaba 1.1 }
1782    
1783 wakaba 1.76 push @next_char, $self->{next_char};
1784     if ($self->{next_char} == 0x004F or # O
1785     $self->{next_char} == 0x006F) { # o
1786 wakaba 1.1
1787     if (@{$self->{char}}) {
1788 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1789 wakaba 1.1 } else {
1790 wakaba 1.76 $self->{set_next_char}->($self);
1791 wakaba 1.1 }
1792    
1793 wakaba 1.76 push @next_char, $self->{next_char};
1794     if ($self->{next_char} == 0x0043 or # C
1795     $self->{next_char} == 0x0063) { # c
1796 wakaba 1.1
1797     if (@{$self->{char}}) {
1798 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1799 wakaba 1.1 } else {
1800 wakaba 1.76 $self->{set_next_char}->($self);
1801 wakaba 1.1 }
1802    
1803 wakaba 1.76 push @next_char, $self->{next_char};
1804     if ($self->{next_char} == 0x0054 or # T
1805     $self->{next_char} == 0x0074) { # t
1806 wakaba 1.1
1807     if (@{$self->{char}}) {
1808 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1809 wakaba 1.1 } else {
1810 wakaba 1.76 $self->{set_next_char}->($self);
1811 wakaba 1.1 }
1812    
1813 wakaba 1.76 push @next_char, $self->{next_char};
1814     if ($self->{next_char} == 0x0059 or # Y
1815     $self->{next_char} == 0x0079) { # y
1816 wakaba 1.1
1817     if (@{$self->{char}}) {
1818 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1819 wakaba 1.1 } else {
1820 wakaba 1.76 $self->{set_next_char}->($self);
1821 wakaba 1.1 }
1822    
1823 wakaba 1.76 push @next_char, $self->{next_char};
1824     if ($self->{next_char} == 0x0050 or # P
1825     $self->{next_char} == 0x0070) { # p
1826 wakaba 1.1
1827     if (@{$self->{char}}) {
1828 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1829 wakaba 1.1 } else {
1830 wakaba 1.76 $self->{set_next_char}->($self);
1831 wakaba 1.1 }
1832    
1833 wakaba 1.76 push @next_char, $self->{next_char};
1834     if ($self->{next_char} == 0x0045 or # E
1835     $self->{next_char} == 0x0065) { # e
1836 wakaba 1.77
1837     ## TODO: What a stupid code this is!
1838 wakaba 1.59 $self->{state} = DOCTYPE_STATE;
1839 wakaba 1.1
1840     if (@{$self->{char}}) {
1841 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1842 wakaba 1.1 } else {
1843 wakaba 1.76 $self->{set_next_char}->($self);
1844 wakaba 1.1 }
1845    
1846     redo A;
1847 wakaba 1.77 } else {
1848    
1849 wakaba 1.1 }
1850 wakaba 1.77 } else {
1851    
1852 wakaba 1.1 }
1853 wakaba 1.77 } else {
1854    
1855 wakaba 1.1 }
1856 wakaba 1.77 } else {
1857    
1858 wakaba 1.1 }
1859 wakaba 1.77 } else {
1860    
1861 wakaba 1.1 }
1862 wakaba 1.77 } else {
1863    
1864 wakaba 1.1 }
1865 wakaba 1.77 } else {
1866    
1867 wakaba 1.1 }
1868    
1869 wakaba 1.30 $self->{parse_error}-> (type => 'bogus comment');
1870 wakaba 1.76 $self->{next_char} = shift @next_char;
1871 wakaba 1.1 unshift @{$self->{char}}, (@next_char);
1872 wakaba 1.59 $self->{state} = BOGUS_COMMENT_STATE;
1873 wakaba 1.1 redo A;
1874    
1875     ## ISSUE: typos in spec: chacacters, is is a parse error
1876     ## ISSUE: spec is somewhat unclear on "is the first character that will be in the comment"; what is "that will be in the comment" is what the algorithm defines, isn't it?
1877 wakaba 1.59 } elsif ($self->{state} == COMMENT_START_STATE) {
1878 wakaba 1.76 if ($self->{next_char} == 0x002D) { # -
1879 wakaba 1.77
1880 wakaba 1.59 $self->{state} = COMMENT_START_DASH_STATE;
1881 wakaba 1.23
1882     if (@{$self->{char}}) {
1883 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1884 wakaba 1.23 } else {
1885 wakaba 1.76 $self->{set_next_char}->($self);
1886 wakaba 1.23 }
1887    
1888     redo A;
1889 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
1890 wakaba 1.77
1891 wakaba 1.23 $self->{parse_error}-> (type => 'bogus comment');
1892 wakaba 1.59 $self->{state} = DATA_STATE;
1893 wakaba 1.23
1894     if (@{$self->{char}}) {
1895 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1896 wakaba 1.23 } else {
1897 wakaba 1.76 $self->{set_next_char}->($self);
1898 wakaba 1.23 }
1899    
1900    
1901     return ($self->{current_token}); # comment
1902    
1903     redo A;
1904 wakaba 1.76 } elsif ($self->{next_char} == -1) {
1905 wakaba 1.77
1906 wakaba 1.23 $self->{parse_error}-> (type => 'unclosed comment');
1907 wakaba 1.59 $self->{state} = DATA_STATE;
1908 wakaba 1.23 ## reconsume
1909    
1910     return ($self->{current_token}); # comment
1911    
1912 wakaba 1.77 redo A;
1913     } else {
1914    
1915 wakaba 1.23 $self->{current_token}->{data} # comment
1916 wakaba 1.76 .= chr ($self->{next_char});
1917 wakaba 1.59 $self->{state} = COMMENT_STATE;
1918 wakaba 1.23
1919     if (@{$self->{char}}) {
1920 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1921 wakaba 1.23 } else {
1922 wakaba 1.76 $self->{set_next_char}->($self);
1923 wakaba 1.23 }
1924    
1925     redo A;
1926     }
1927 wakaba 1.59 } elsif ($self->{state} == COMMENT_START_DASH_STATE) {
1928 wakaba 1.76 if ($self->{next_char} == 0x002D) { # -
1929 wakaba 1.77
1930 wakaba 1.59 $self->{state} = COMMENT_END_STATE;
1931 wakaba 1.23
1932     if (@{$self->{char}}) {
1933 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1934 wakaba 1.23 } else {
1935 wakaba 1.76 $self->{set_next_char}->($self);
1936 wakaba 1.23 }
1937    
1938     redo A;
1939 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
1940 wakaba 1.77
1941 wakaba 1.23 $self->{parse_error}-> (type => 'bogus comment');
1942 wakaba 1.59 $self->{state} = DATA_STATE;
1943 wakaba 1.23
1944     if (@{$self->{char}}) {
1945 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1946 wakaba 1.23 } else {
1947 wakaba 1.76 $self->{set_next_char}->($self);
1948 wakaba 1.23 }
1949    
1950    
1951     return ($self->{current_token}); # comment
1952    
1953     redo A;
1954 wakaba 1.76 } elsif ($self->{next_char} == -1) {
1955 wakaba 1.77
1956 wakaba 1.23 $self->{parse_error}-> (type => 'unclosed comment');
1957 wakaba 1.59 $self->{state} = DATA_STATE;
1958 wakaba 1.23 ## reconsume
1959    
1960     return ($self->{current_token}); # comment
1961    
1962     redo A;
1963     } else {
1964 wakaba 1.77
1965 wakaba 1.23 $self->{current_token}->{data} # comment
1966 wakaba 1.76 .= '-' . chr ($self->{next_char});
1967 wakaba 1.59 $self->{state} = COMMENT_STATE;
1968 wakaba 1.23
1969     if (@{$self->{char}}) {
1970 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1971 wakaba 1.23 } else {
1972 wakaba 1.76 $self->{set_next_char}->($self);
1973 wakaba 1.23 }
1974    
1975     redo A;
1976     }
1977 wakaba 1.59 } elsif ($self->{state} == COMMENT_STATE) {
1978 wakaba 1.76 if ($self->{next_char} == 0x002D) { # -
1979 wakaba 1.77
1980 wakaba 1.59 $self->{state} = COMMENT_END_DASH_STATE;
1981 wakaba 1.1
1982     if (@{$self->{char}}) {
1983 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
1984 wakaba 1.1 } else {
1985 wakaba 1.76 $self->{set_next_char}->($self);
1986 wakaba 1.1 }
1987    
1988     redo A;
1989 wakaba 1.76 } elsif ($self->{next_char} == -1) {
1990 wakaba 1.77
1991 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed comment');
1992 wakaba 1.59 $self->{state} = DATA_STATE;
1993 wakaba 1.1 ## reconsume
1994    
1995     return ($self->{current_token}); # comment
1996    
1997     redo A;
1998     } else {
1999 wakaba 1.77
2000 wakaba 1.76 $self->{current_token}->{data} .= chr ($self->{next_char}); # comment
2001 wakaba 1.1 ## Stay in the state
2002    
2003     if (@{$self->{char}}) {
2004 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2005 wakaba 1.1 } else {
2006 wakaba 1.76 $self->{set_next_char}->($self);
2007 wakaba 1.1 }
2008    
2009     redo A;
2010     }
2011 wakaba 1.59 } elsif ($self->{state} == COMMENT_END_DASH_STATE) {
2012 wakaba 1.76 if ($self->{next_char} == 0x002D) { # -
2013 wakaba 1.77
2014 wakaba 1.59 $self->{state} = COMMENT_END_STATE;
2015 wakaba 1.1
2016     if (@{$self->{char}}) {
2017 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2018 wakaba 1.1 } else {
2019 wakaba 1.76 $self->{set_next_char}->($self);
2020 wakaba 1.1 }
2021    
2022     redo A;
2023 wakaba 1.76 } elsif ($self->{next_char} == -1) {
2024 wakaba 1.77
2025 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed comment');
2026 wakaba 1.59 $self->{state} = DATA_STATE;
2027 wakaba 1.1 ## reconsume
2028    
2029     return ($self->{current_token}); # comment
2030    
2031     redo A;
2032     } else {
2033 wakaba 1.77
2034 wakaba 1.76 $self->{current_token}->{data} .= '-' . chr ($self->{next_char}); # comment
2035 wakaba 1.59 $self->{state} = COMMENT_STATE;
2036 wakaba 1.1
2037     if (@{$self->{char}}) {
2038 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2039 wakaba 1.1 } else {
2040 wakaba 1.76 $self->{set_next_char}->($self);
2041 wakaba 1.1 }
2042    
2043     redo A;
2044     }
2045 wakaba 1.59 } elsif ($self->{state} == COMMENT_END_STATE) {
2046 wakaba 1.76 if ($self->{next_char} == 0x003E) { # >
2047 wakaba 1.77
2048 wakaba 1.59 $self->{state} = DATA_STATE;
2049 wakaba 1.1
2050     if (@{$self->{char}}) {
2051 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2052 wakaba 1.1 } else {
2053 wakaba 1.76 $self->{set_next_char}->($self);
2054 wakaba 1.1 }
2055    
2056    
2057     return ($self->{current_token}); # comment
2058    
2059     redo A;
2060 wakaba 1.76 } elsif ($self->{next_char} == 0x002D) { # -
2061 wakaba 1.77
2062 wakaba 1.3 $self->{parse_error}-> (type => 'dash in comment');
2063 wakaba 1.1 $self->{current_token}->{data} .= '-'; # comment
2064     ## Stay in the state
2065    
2066     if (@{$self->{char}}) {
2067 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2068 wakaba 1.1 } else {
2069 wakaba 1.76 $self->{set_next_char}->($self);
2070 wakaba 1.1 }
2071    
2072     redo A;
2073 wakaba 1.76 } elsif ($self->{next_char} == -1) {
2074 wakaba 1.77
2075 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed comment');
2076 wakaba 1.59 $self->{state} = DATA_STATE;
2077 wakaba 1.1 ## reconsume
2078    
2079     return ($self->{current_token}); # comment
2080    
2081     redo A;
2082     } else {
2083 wakaba 1.77
2084 wakaba 1.3 $self->{parse_error}-> (type => 'dash in comment');
2085 wakaba 1.76 $self->{current_token}->{data} .= '--' . chr ($self->{next_char}); # comment
2086 wakaba 1.59 $self->{state} = COMMENT_STATE;
2087 wakaba 1.1
2088     if (@{$self->{char}}) {
2089 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2090 wakaba 1.1 } else {
2091 wakaba 1.76 $self->{set_next_char}->($self);
2092 wakaba 1.1 }
2093    
2094     redo A;
2095     }
2096 wakaba 1.59 } elsif ($self->{state} == DOCTYPE_STATE) {
2097 wakaba 1.76 if ($self->{next_char} == 0x0009 or # HT
2098     $self->{next_char} == 0x000A or # LF
2099     $self->{next_char} == 0x000B or # VT
2100     $self->{next_char} == 0x000C or # FF
2101     $self->{next_char} == 0x0020) { # SP
2102 wakaba 1.77
2103 wakaba 1.59 $self->{state} = BEFORE_DOCTYPE_NAME_STATE;
2104 wakaba 1.1
2105     if (@{$self->{char}}) {
2106 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2107 wakaba 1.1 } else {
2108 wakaba 1.76 $self->{set_next_char}->($self);
2109 wakaba 1.1 }
2110    
2111     redo A;
2112     } else {
2113 wakaba 1.77
2114 wakaba 1.3 $self->{parse_error}-> (type => 'no space before DOCTYPE name');
2115 wakaba 1.59 $self->{state} = BEFORE_DOCTYPE_NAME_STATE;
2116 wakaba 1.1 ## reconsume
2117     redo A;
2118     }
2119 wakaba 1.59 } elsif ($self->{state} == BEFORE_DOCTYPE_NAME_STATE) {
2120 wakaba 1.76 if ($self->{next_char} == 0x0009 or # HT
2121     $self->{next_char} == 0x000A or # LF
2122     $self->{next_char} == 0x000B or # VT
2123     $self->{next_char} == 0x000C or # FF
2124     $self->{next_char} == 0x0020) { # SP
2125 wakaba 1.77
2126 wakaba 1.1 ## Stay in the state
2127    
2128     if (@{$self->{char}}) {
2129 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2130 wakaba 1.1 } else {
2131 wakaba 1.76 $self->{set_next_char}->($self);
2132 wakaba 1.1 }
2133    
2134     redo A;
2135 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
2136 wakaba 1.77
2137 wakaba 1.18 $self->{parse_error}-> (type => 'no DOCTYPE name');
2138 wakaba 1.59 $self->{state} = DATA_STATE;
2139 wakaba 1.18
2140     if (@{$self->{char}}) {
2141 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2142 wakaba 1.18 } else {
2143 wakaba 1.76 $self->{set_next_char}->($self);
2144 wakaba 1.18 }
2145    
2146    
2147 wakaba 1.75 return ({type => DOCTYPE_TOKEN, quirks => 1});
2148 wakaba 1.18
2149     redo A;
2150 wakaba 1.77 } elsif ($self->{next_char} == -1) {
2151    
2152 wakaba 1.18 $self->{parse_error}-> (type => 'no DOCTYPE name');
2153 wakaba 1.59 $self->{state} = DATA_STATE;
2154 wakaba 1.18 ## reconsume
2155    
2156 wakaba 1.75 return ({type => DOCTYPE_TOKEN, quirks => 1});
2157 wakaba 1.18
2158     redo A;
2159     } else {
2160 wakaba 1.77
2161 wakaba 1.18 $self->{current_token}
2162 wakaba 1.57 = {type => DOCTYPE_TOKEN,
2163 wakaba 1.76 name => chr ($self->{next_char}),
2164 wakaba 1.75 #quirks => 0,
2165     };
2166 wakaba 1.4 ## ISSUE: "Set the token's name name to the" in the spec
2167 wakaba 1.59 $self->{state} = DOCTYPE_NAME_STATE;
2168 wakaba 1.1
2169     if (@{$self->{char}}) {
2170 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2171 wakaba 1.1 } else {
2172 wakaba 1.76 $self->{set_next_char}->($self);
2173 wakaba 1.1 }
2174    
2175     redo A;
2176 wakaba 1.18 }
2177 wakaba 1.59 } elsif ($self->{state} == DOCTYPE_NAME_STATE) {
2178 wakaba 1.18 ## ISSUE: Redundant "First," in the spec.
2179 wakaba 1.76 if ($self->{next_char} == 0x0009 or # HT
2180     $self->{next_char} == 0x000A or # LF
2181     $self->{next_char} == 0x000B or # VT
2182     $self->{next_char} == 0x000C or # FF
2183     $self->{next_char} == 0x0020) { # SP
2184 wakaba 1.77
2185 wakaba 1.59 $self->{state} = AFTER_DOCTYPE_NAME_STATE;
2186 wakaba 1.18
2187     if (@{$self->{char}}) {
2188 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2189 wakaba 1.18 } else {
2190 wakaba 1.76 $self->{set_next_char}->($self);
2191 wakaba 1.18 }
2192    
2193     redo A;
2194 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
2195 wakaba 1.77
2196 wakaba 1.59 $self->{state} = DATA_STATE;
2197 wakaba 1.1
2198     if (@{$self->{char}}) {
2199 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2200 wakaba 1.1 } else {
2201 wakaba 1.76 $self->{set_next_char}->($self);
2202 wakaba 1.1 }
2203    
2204    
2205 wakaba 1.18 return ($self->{current_token}); # DOCTYPE
2206 wakaba 1.1
2207     redo A;
2208 wakaba 1.76 } elsif ($self->{next_char} == -1) {
2209 wakaba 1.77
2210 wakaba 1.18 $self->{parse_error}-> (type => 'unclosed DOCTYPE');
2211 wakaba 1.59 $self->{state} = DATA_STATE;
2212 wakaba 1.1 ## reconsume
2213    
2214 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2215 wakaba 1.18 return ($self->{current_token}); # DOCTYPE
2216 wakaba 1.1
2217     redo A;
2218     } else {
2219 wakaba 1.77
2220 wakaba 1.18 $self->{current_token}->{name}
2221 wakaba 1.76 .= chr ($self->{next_char}); # DOCTYPE
2222 wakaba 1.18 ## Stay in the state
2223 wakaba 1.1
2224     if (@{$self->{char}}) {
2225 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2226 wakaba 1.1 } else {
2227 wakaba 1.76 $self->{set_next_char}->($self);
2228 wakaba 1.1 }
2229    
2230     redo A;
2231     }
2232 wakaba 1.59 } elsif ($self->{state} == AFTER_DOCTYPE_NAME_STATE) {
2233 wakaba 1.76 if ($self->{next_char} == 0x0009 or # HT
2234     $self->{next_char} == 0x000A or # LF
2235     $self->{next_char} == 0x000B or # VT
2236     $self->{next_char} == 0x000C or # FF
2237     $self->{next_char} == 0x0020) { # SP
2238 wakaba 1.77
2239 wakaba 1.18 ## Stay in the state
2240 wakaba 1.1
2241     if (@{$self->{char}}) {
2242 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2243 wakaba 1.1 } else {
2244 wakaba 1.76 $self->{set_next_char}->($self);
2245 wakaba 1.1 }
2246    
2247     redo A;
2248 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
2249 wakaba 1.77
2250 wakaba 1.59 $self->{state} = DATA_STATE;
2251 wakaba 1.1
2252     if (@{$self->{char}}) {
2253 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2254 wakaba 1.1 } else {
2255 wakaba 1.76 $self->{set_next_char}->($self);
2256 wakaba 1.1 }
2257    
2258    
2259     return ($self->{current_token}); # DOCTYPE
2260    
2261     redo A;
2262 wakaba 1.76 } elsif ($self->{next_char} == -1) {
2263 wakaba 1.77
2264 wakaba 1.18 $self->{parse_error}-> (type => 'unclosed DOCTYPE');
2265 wakaba 1.59 $self->{state} = DATA_STATE;
2266 wakaba 1.18 ## reconsume
2267    
2268 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2269 wakaba 1.18 return ($self->{current_token}); # DOCTYPE
2270    
2271     redo A;
2272 wakaba 1.76 } elsif ($self->{next_char} == 0x0050 or # P
2273     $self->{next_char} == 0x0070) { # p
2274 wakaba 1.18
2275     if (@{$self->{char}}) {
2276 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2277 wakaba 1.18 } else {
2278 wakaba 1.76 $self->{set_next_char}->($self);
2279 wakaba 1.18 }
2280    
2281 wakaba 1.76 if ($self->{next_char} == 0x0055 or # U
2282     $self->{next_char} == 0x0075) { # u
2283 wakaba 1.18
2284     if (@{$self->{char}}) {
2285 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2286 wakaba 1.18 } else {
2287 wakaba 1.76 $self->{set_next_char}->($self);
2288 wakaba 1.18 }
2289    
2290 wakaba 1.76 if ($self->{next_char} == 0x0042 or # B
2291     $self->{next_char} == 0x0062) { # b
2292 wakaba 1.18
2293     if (@{$self->{char}}) {
2294 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2295 wakaba 1.18 } else {
2296 wakaba 1.76 $self->{set_next_char}->($self);
2297 wakaba 1.18 }
2298    
2299 wakaba 1.76 if ($self->{next_char} == 0x004C or # L
2300     $self->{next_char} == 0x006C) { # l
2301 wakaba 1.18
2302     if (@{$self->{char}}) {
2303 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2304 wakaba 1.18 } else {
2305 wakaba 1.76 $self->{set_next_char}->($self);
2306 wakaba 1.18 }
2307    
2308 wakaba 1.76 if ($self->{next_char} == 0x0049 or # I
2309     $self->{next_char} == 0x0069) { # i
2310 wakaba 1.18
2311     if (@{$self->{char}}) {
2312 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2313 wakaba 1.18 } else {
2314 wakaba 1.76 $self->{set_next_char}->($self);
2315 wakaba 1.18 }
2316    
2317 wakaba 1.76 if ($self->{next_char} == 0x0043 or # C
2318     $self->{next_char} == 0x0063) { # c
2319 wakaba 1.77
2320 wakaba 1.59 $self->{state} = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
2321 wakaba 1.18
2322     if (@{$self->{char}}) {
2323 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2324 wakaba 1.18 } else {
2325 wakaba 1.76 $self->{set_next_char}->($self);
2326 wakaba 1.18 }
2327    
2328     redo A;
2329 wakaba 1.77 } else {
2330    
2331 wakaba 1.18 }
2332 wakaba 1.77 } else {
2333    
2334 wakaba 1.18 }
2335 wakaba 1.77 } else {
2336    
2337 wakaba 1.18 }
2338 wakaba 1.77 } else {
2339    
2340 wakaba 1.18 }
2341 wakaba 1.77 } else {
2342    
2343 wakaba 1.18 }
2344    
2345     #
2346 wakaba 1.76 } elsif ($self->{next_char} == 0x0053 or # S
2347     $self->{next_char} == 0x0073) { # s
2348 wakaba 1.18
2349     if (@{$self->{char}}) {
2350 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2351 wakaba 1.18 } else {
2352 wakaba 1.76 $self->{set_next_char}->($self);
2353 wakaba 1.18 }
2354    
2355 wakaba 1.76 if ($self->{next_char} == 0x0059 or # Y
2356     $self->{next_char} == 0x0079) { # y
2357 wakaba 1.18
2358     if (@{$self->{char}}) {
2359 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2360 wakaba 1.18 } else {
2361 wakaba 1.76 $self->{set_next_char}->($self);
2362 wakaba 1.18 }
2363    
2364 wakaba 1.76 if ($self->{next_char} == 0x0053 or # S
2365     $self->{next_char} == 0x0073) { # s
2366 wakaba 1.18
2367     if (@{$self->{char}}) {
2368 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2369 wakaba 1.18 } else {
2370 wakaba 1.76 $self->{set_next_char}->($self);
2371 wakaba 1.18 }
2372    
2373 wakaba 1.76 if ($self->{next_char} == 0x0054 or # T
2374     $self->{next_char} == 0x0074) { # t
2375 wakaba 1.18
2376     if (@{$self->{char}}) {
2377 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2378 wakaba 1.18 } else {
2379 wakaba 1.76 $self->{set_next_char}->($self);
2380 wakaba 1.18 }
2381    
2382 wakaba 1.76 if ($self->{next_char} == 0x0045 or # E
2383     $self->{next_char} == 0x0065) { # e
2384 wakaba 1.18
2385     if (@{$self->{char}}) {
2386 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2387 wakaba 1.18 } else {
2388 wakaba 1.76 $self->{set_next_char}->($self);
2389 wakaba 1.18 }
2390    
2391 wakaba 1.76 if ($self->{next_char} == 0x004D or # M
2392     $self->{next_char} == 0x006D) { # m
2393 wakaba 1.77
2394 wakaba 1.59 $self->{state} = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
2395 wakaba 1.18
2396     if (@{$self->{char}}) {
2397 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2398 wakaba 1.18 } else {
2399 wakaba 1.76 $self->{set_next_char}->($self);
2400 wakaba 1.18 }
2401    
2402     redo A;
2403 wakaba 1.77 } else {
2404    
2405 wakaba 1.18 }
2406 wakaba 1.77 } else {
2407    
2408 wakaba 1.18 }
2409 wakaba 1.77 } else {
2410    
2411 wakaba 1.18 }
2412 wakaba 1.77 } else {
2413    
2414 wakaba 1.18 }
2415 wakaba 1.77 } else {
2416    
2417 wakaba 1.18 }
2418    
2419     #
2420     } else {
2421    
2422 wakaba 1.77
2423 wakaba 1.18 if (@{$self->{char}}) {
2424 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2425 wakaba 1.18 } else {
2426 wakaba 1.76 $self->{set_next_char}->($self);
2427 wakaba 1.18 }
2428    
2429     #
2430     }
2431    
2432     $self->{parse_error}-> (type => 'string after DOCTYPE name');
2433 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2434 wakaba 1.73
2435 wakaba 1.59 $self->{state} = BOGUS_DOCTYPE_STATE;
2436 wakaba 1.18 # next-input-character is already done
2437     redo A;
2438 wakaba 1.59 } elsif ($self->{state} == BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {
2439 wakaba 1.18 if ({
2440     0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,
2441     #0x000D => 1, # HT, LF, VT, FF, SP, CR
2442 wakaba 1.76 }->{$self->{next_char}}) {
2443 wakaba 1.77
2444 wakaba 1.1 ## Stay in the state
2445    
2446     if (@{$self->{char}}) {
2447 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2448 wakaba 1.1 } else {
2449 wakaba 1.76 $self->{set_next_char}->($self);
2450 wakaba 1.1 }
2451    
2452     redo A;
2453 wakaba 1.76 } elsif ($self->{next_char} eq 0x0022) { # "
2454 wakaba 1.77
2455 wakaba 1.18 $self->{current_token}->{public_identifier} = ''; # DOCTYPE
2456 wakaba 1.59 $self->{state} = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;
2457 wakaba 1.18
2458     if (@{$self->{char}}) {
2459 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2460 wakaba 1.18 } else {
2461 wakaba 1.76 $self->{set_next_char}->($self);
2462 wakaba 1.18 }
2463    
2464     redo A;
2465 wakaba 1.76 } elsif ($self->{next_char} eq 0x0027) { # '
2466 wakaba 1.77
2467 wakaba 1.18 $self->{current_token}->{public_identifier} = ''; # DOCTYPE
2468 wakaba 1.59 $self->{state} = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;
2469 wakaba 1.18
2470     if (@{$self->{char}}) {
2471 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2472 wakaba 1.18 } else {
2473 wakaba 1.76 $self->{set_next_char}->($self);
2474 wakaba 1.18 }
2475    
2476     redo A;
2477 wakaba 1.76 } elsif ($self->{next_char} eq 0x003E) { # >
2478 wakaba 1.77
2479 wakaba 1.18 $self->{parse_error}-> (type => 'no PUBLIC literal');
2480    
2481 wakaba 1.59 $self->{state} = DATA_STATE;
2482 wakaba 1.18
2483     if (@{$self->{char}}) {
2484 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2485 wakaba 1.18 } else {
2486 wakaba 1.76 $self->{set_next_char}->($self);
2487 wakaba 1.18 }
2488    
2489    
2490 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2491 wakaba 1.18 return ($self->{current_token}); # DOCTYPE
2492    
2493     redo A;
2494 wakaba 1.76 } elsif ($self->{next_char} == -1) {
2495 wakaba 1.77
2496 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed DOCTYPE');
2497 wakaba 1.18
2498 wakaba 1.59 $self->{state} = DATA_STATE;
2499 wakaba 1.1 ## reconsume
2500    
2501 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2502 wakaba 1.18 return ($self->{current_token}); # DOCTYPE
2503 wakaba 1.1
2504     redo A;
2505     } else {
2506 wakaba 1.77
2507 wakaba 1.18 $self->{parse_error}-> (type => 'string after PUBLIC');
2508 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2509 wakaba 1.73
2510 wakaba 1.59 $self->{state} = BOGUS_DOCTYPE_STATE;
2511 wakaba 1.18
2512     if (@{$self->{char}}) {
2513 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2514 wakaba 1.18 } else {
2515 wakaba 1.76 $self->{set_next_char}->($self);
2516 wakaba 1.18 }
2517    
2518     redo A;
2519     }
2520 wakaba 1.59 } elsif ($self->{state} == DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE) {
2521 wakaba 1.76 if ($self->{next_char} == 0x0022) { # "
2522 wakaba 1.77
2523 wakaba 1.59 $self->{state} = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
2524 wakaba 1.18
2525     if (@{$self->{char}}) {
2526 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2527 wakaba 1.18 } else {
2528 wakaba 1.76 $self->{set_next_char}->($self);
2529 wakaba 1.18 }
2530    
2531     redo A;
2532 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
2533 wakaba 1.77
2534 wakaba 1.70 $self->{parse_error}-> (type => 'unclosed PUBLIC literal');
2535    
2536     $self->{state} = DATA_STATE;
2537    
2538     if (@{$self->{char}}) {
2539 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2540 wakaba 1.70 } else {
2541 wakaba 1.76 $self->{set_next_char}->($self);
2542 wakaba 1.70 }
2543    
2544    
2545 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2546 wakaba 1.70 return ($self->{current_token}); # DOCTYPE
2547    
2548     redo A;
2549 wakaba 1.76 } elsif ($self->{next_char} == -1) {
2550 wakaba 1.77
2551 wakaba 1.18 $self->{parse_error}-> (type => 'unclosed PUBLIC literal');
2552    
2553 wakaba 1.59 $self->{state} = DATA_STATE;
2554 wakaba 1.18 ## reconsume
2555    
2556 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2557 wakaba 1.18 return ($self->{current_token}); # DOCTYPE
2558    
2559     redo A;
2560     } else {
2561 wakaba 1.77
2562 wakaba 1.18 $self->{current_token}->{public_identifier} # DOCTYPE
2563 wakaba 1.76 .= chr $self->{next_char};
2564 wakaba 1.18 ## Stay in the state
2565    
2566     if (@{$self->{char}}) {
2567 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2568 wakaba 1.18 } else {
2569 wakaba 1.76 $self->{set_next_char}->($self);
2570 wakaba 1.18 }
2571    
2572     redo A;
2573     }
2574 wakaba 1.59 } elsif ($self->{state} == DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE) {
2575 wakaba 1.76 if ($self->{next_char} == 0x0027) { # '
2576 wakaba 1.77
2577 wakaba 1.59 $self->{state} = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
2578 wakaba 1.18
2579     if (@{$self->{char}}) {
2580 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2581 wakaba 1.18 } else {
2582 wakaba 1.76 $self->{set_next_char}->($self);
2583 wakaba 1.18 }
2584    
2585     redo A;
2586 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
2587 wakaba 1.77
2588 wakaba 1.70 $self->{parse_error}-> (type => 'unclosed PUBLIC literal');
2589    
2590     $self->{state} = DATA_STATE;
2591    
2592     if (@{$self->{char}}) {
2593 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2594 wakaba 1.70 } else {
2595 wakaba 1.76 $self->{set_next_char}->($self);
2596 wakaba 1.70 }
2597    
2598    
2599 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2600 wakaba 1.70 return ($self->{current_token}); # DOCTYPE
2601    
2602     redo A;
2603 wakaba 1.76 } elsif ($self->{next_char} == -1) {
2604 wakaba 1.77
2605 wakaba 1.18 $self->{parse_error}-> (type => 'unclosed PUBLIC literal');
2606    
2607 wakaba 1.59 $self->{state} = DATA_STATE;
2608 wakaba 1.18 ## reconsume
2609    
2610 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2611 wakaba 1.18 return ($self->{current_token}); # DOCTYPE
2612    
2613     redo A;
2614     } else {
2615 wakaba 1.77
2616 wakaba 1.18 $self->{current_token}->{public_identifier} # DOCTYPE
2617 wakaba 1.76 .= chr $self->{next_char};
2618 wakaba 1.18 ## Stay in the state
2619    
2620     if (@{$self->{char}}) {
2621 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2622 wakaba 1.18 } else {
2623 wakaba 1.76 $self->{set_next_char}->($self);
2624 wakaba 1.18 }
2625    
2626     redo A;
2627     }
2628 wakaba 1.59 } elsif ($self->{state} == AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {
2629 wakaba 1.18 if ({
2630     0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,
2631     #0x000D => 1, # HT, LF, VT, FF, SP, CR
2632 wakaba 1.76 }->{$self->{next_char}}) {
2633 wakaba 1.77
2634 wakaba 1.1 ## Stay in the state
2635    
2636     if (@{$self->{char}}) {
2637 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2638 wakaba 1.1 } else {
2639 wakaba 1.76 $self->{set_next_char}->($self);
2640 wakaba 1.1 }
2641    
2642     redo A;
2643 wakaba 1.76 } elsif ($self->{next_char} == 0x0022) { # "
2644 wakaba 1.77
2645 wakaba 1.18 $self->{current_token}->{system_identifier} = ''; # DOCTYPE
2646 wakaba 1.59 $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
2647 wakaba 1.18
2648     if (@{$self->{char}}) {
2649 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2650 wakaba 1.18 } else {
2651 wakaba 1.76 $self->{set_next_char}->($self);
2652 wakaba 1.18 }
2653    
2654     redo A;
2655 wakaba 1.76 } elsif ($self->{next_char} == 0x0027) { # '
2656 wakaba 1.77
2657 wakaba 1.18 $self->{current_token}->{system_identifier} = ''; # DOCTYPE
2658 wakaba 1.59 $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
2659 wakaba 1.18
2660     if (@{$self->{char}}) {
2661 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2662 wakaba 1.18 } else {
2663 wakaba 1.76 $self->{set_next_char}->($self);
2664 wakaba 1.18 }
2665    
2666     redo A;
2667 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
2668 wakaba 1.77
2669 wakaba 1.59 $self->{state} = DATA_STATE;
2670 wakaba 1.18
2671     if (@{$self->{char}}) {
2672 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2673 wakaba 1.18 } else {
2674 wakaba 1.76 $self->{set_next_char}->($self);
2675 wakaba 1.18 }
2676    
2677    
2678     return ($self->{current_token}); # DOCTYPE
2679    
2680     redo A;
2681 wakaba 1.76 } elsif ($self->{next_char} == -1) {
2682 wakaba 1.77
2683 wakaba 1.18 $self->{parse_error}-> (type => 'unclosed DOCTYPE');
2684    
2685 wakaba 1.59 $self->{state} = DATA_STATE;
2686 wakaba 1.26 ## reconsume
2687 wakaba 1.18
2688 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2689 wakaba 1.18 return ($self->{current_token}); # DOCTYPE
2690    
2691     redo A;
2692     } else {
2693 wakaba 1.77
2694 wakaba 1.18 $self->{parse_error}-> (type => 'string after PUBLIC literal');
2695 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2696 wakaba 1.73
2697 wakaba 1.59 $self->{state} = BOGUS_DOCTYPE_STATE;
2698 wakaba 1.18
2699     if (@{$self->{char}}) {
2700 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2701 wakaba 1.18 } else {
2702 wakaba 1.76 $self->{set_next_char}->($self);
2703 wakaba 1.18 }
2704    
2705     redo A;
2706 wakaba 1.1 }
2707 wakaba 1.59 } elsif ($self->{state} == BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {
2708 wakaba 1.18 if ({
2709     0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,
2710     #0x000D => 1, # HT, LF, VT, FF, SP, CR
2711 wakaba 1.76 }->{$self->{next_char}}) {
2712 wakaba 1.77
2713 wakaba 1.1 ## Stay in the state
2714    
2715     if (@{$self->{char}}) {
2716 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2717 wakaba 1.1 } else {
2718 wakaba 1.76 $self->{set_next_char}->($self);
2719 wakaba 1.1 }
2720    
2721     redo A;
2722 wakaba 1.76 } elsif ($self->{next_char} == 0x0022) { # "
2723 wakaba 1.77
2724 wakaba 1.18 $self->{current_token}->{system_identifier} = ''; # DOCTYPE
2725 wakaba 1.59 $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
2726 wakaba 1.18
2727     if (@{$self->{char}}) {
2728 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2729 wakaba 1.18 } else {
2730 wakaba 1.76 $self->{set_next_char}->($self);
2731 wakaba 1.18 }
2732    
2733     redo A;
2734 wakaba 1.76 } elsif ($self->{next_char} == 0x0027) { # '
2735 wakaba 1.77
2736 wakaba 1.18 $self->{current_token}->{system_identifier} = ''; # DOCTYPE
2737 wakaba 1.59 $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
2738 wakaba 1.18
2739     if (@{$self->{char}}) {
2740 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2741 wakaba 1.18 } else {
2742 wakaba 1.76 $self->{set_next_char}->($self);
2743 wakaba 1.18 }
2744    
2745     redo A;
2746 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
2747 wakaba 1.77
2748 wakaba 1.18 $self->{parse_error}-> (type => 'no SYSTEM literal');
2749 wakaba 1.59 $self->{state} = DATA_STATE;
2750 wakaba 1.1
2751     if (@{$self->{char}}) {
2752 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2753 wakaba 1.1 } else {
2754 wakaba 1.76 $self->{set_next_char}->($self);
2755 wakaba 1.1 }
2756    
2757    
2758 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2759 wakaba 1.1 return ($self->{current_token}); # DOCTYPE
2760    
2761     redo A;
2762 wakaba 1.76 } elsif ($self->{next_char} == -1) {
2763 wakaba 1.77
2764 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed DOCTYPE');
2765 wakaba 1.18
2766 wakaba 1.59 $self->{state} = DATA_STATE;
2767 wakaba 1.26 ## reconsume
2768 wakaba 1.18
2769 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2770 wakaba 1.18 return ($self->{current_token}); # DOCTYPE
2771    
2772     redo A;
2773     } else {
2774 wakaba 1.77
2775 wakaba 1.30 $self->{parse_error}-> (type => 'string after SYSTEM');
2776 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2777 wakaba 1.73
2778 wakaba 1.59 $self->{state} = BOGUS_DOCTYPE_STATE;
2779 wakaba 1.18
2780     if (@{$self->{char}}) {
2781 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2782 wakaba 1.18 } else {
2783 wakaba 1.76 $self->{set_next_char}->($self);
2784 wakaba 1.18 }
2785    
2786     redo A;
2787     }
2788 wakaba 1.59 } elsif ($self->{state} == DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE) {
2789 wakaba 1.76 if ($self->{next_char} == 0x0022) { # "
2790 wakaba 1.77
2791 wakaba 1.59 $self->{state} = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
2792 wakaba 1.18
2793     if (@{$self->{char}}) {
2794 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2795 wakaba 1.18 } else {
2796 wakaba 1.76 $self->{set_next_char}->($self);
2797 wakaba 1.18 }
2798    
2799     redo A;
2800 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
2801 wakaba 1.77
2802 wakaba 1.70 $self->{parse_error}-> (type => 'unclosed PUBLIC literal');
2803    
2804     $self->{state} = DATA_STATE;
2805    
2806     if (@{$self->{char}}) {
2807 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2808 wakaba 1.70 } else {
2809 wakaba 1.76 $self->{set_next_char}->($self);
2810 wakaba 1.70 }
2811    
2812    
2813 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2814 wakaba 1.70 return ($self->{current_token}); # DOCTYPE
2815    
2816     redo A;
2817 wakaba 1.76 } elsif ($self->{next_char} == -1) {
2818 wakaba 1.77
2819 wakaba 1.18 $self->{parse_error}-> (type => 'unclosed SYSTEM literal');
2820    
2821 wakaba 1.59 $self->{state} = DATA_STATE;
2822 wakaba 1.1 ## reconsume
2823    
2824 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2825 wakaba 1.1 return ($self->{current_token}); # DOCTYPE
2826    
2827     redo A;
2828     } else {
2829 wakaba 1.77
2830 wakaba 1.18 $self->{current_token}->{system_identifier} # DOCTYPE
2831 wakaba 1.76 .= chr $self->{next_char};
2832 wakaba 1.18 ## Stay in the state
2833    
2834     if (@{$self->{char}}) {
2835 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2836 wakaba 1.18 } else {
2837 wakaba 1.76 $self->{set_next_char}->($self);
2838 wakaba 1.18 }
2839    
2840     redo A;
2841     }
2842 wakaba 1.59 } elsif ($self->{state} == DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE) {
2843 wakaba 1.76 if ($self->{next_char} == 0x0027) { # '
2844 wakaba 1.77
2845 wakaba 1.59 $self->{state} = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
2846 wakaba 1.18
2847     if (@{$self->{char}}) {
2848 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2849 wakaba 1.18 } else {
2850 wakaba 1.76 $self->{set_next_char}->($self);
2851 wakaba 1.18 }
2852    
2853     redo A;
2854 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
2855 wakaba 1.77
2856 wakaba 1.70 $self->{parse_error}-> (type => 'unclosed PUBLIC literal');
2857    
2858     $self->{state} = DATA_STATE;
2859    
2860     if (@{$self->{char}}) {
2861 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2862 wakaba 1.70 } else {
2863 wakaba 1.76 $self->{set_next_char}->($self);
2864 wakaba 1.70 }
2865    
2866    
2867 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2868 wakaba 1.70 return ($self->{current_token}); # DOCTYPE
2869    
2870     redo A;
2871 wakaba 1.76 } elsif ($self->{next_char} == -1) {
2872 wakaba 1.77
2873 wakaba 1.18 $self->{parse_error}-> (type => 'unclosed SYSTEM literal');
2874    
2875 wakaba 1.59 $self->{state} = DATA_STATE;
2876 wakaba 1.18 ## reconsume
2877    
2878 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2879 wakaba 1.18 return ($self->{current_token}); # DOCTYPE
2880    
2881     redo A;
2882     } else {
2883 wakaba 1.77
2884 wakaba 1.18 $self->{current_token}->{system_identifier} # DOCTYPE
2885 wakaba 1.76 .= chr $self->{next_char};
2886 wakaba 1.18 ## Stay in the state
2887    
2888     if (@{$self->{char}}) {
2889 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2890 wakaba 1.18 } else {
2891 wakaba 1.76 $self->{set_next_char}->($self);
2892 wakaba 1.18 }
2893    
2894     redo A;
2895     }
2896 wakaba 1.59 } elsif ($self->{state} == AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {
2897 wakaba 1.18 if ({
2898     0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,
2899     #0x000D => 1, # HT, LF, VT, FF, SP, CR
2900 wakaba 1.76 }->{$self->{next_char}}) {
2901 wakaba 1.77
2902 wakaba 1.18 ## Stay in the state
2903    
2904     if (@{$self->{char}}) {
2905 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2906 wakaba 1.18 } else {
2907 wakaba 1.76 $self->{set_next_char}->($self);
2908 wakaba 1.18 }
2909    
2910     redo A;
2911 wakaba 1.76 } elsif ($self->{next_char} == 0x003E) { # >
2912 wakaba 1.77
2913 wakaba 1.59 $self->{state} = DATA_STATE;
2914 wakaba 1.18
2915     if (@{$self->{char}}) {
2916 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2917 wakaba 1.18 } else {
2918 wakaba 1.76 $self->{set_next_char}->($self);
2919 wakaba 1.18 }
2920    
2921    
2922     return ($self->{current_token}); # DOCTYPE
2923    
2924     redo A;
2925 wakaba 1.76 } elsif ($self->{next_char} == -1) {
2926 wakaba 1.77
2927 wakaba 1.18 $self->{parse_error}-> (type => 'unclosed DOCTYPE');
2928    
2929 wakaba 1.59 $self->{state} = DATA_STATE;
2930 wakaba 1.26 ## reconsume
2931 wakaba 1.18
2932 wakaba 1.75 $self->{current_token}->{quirks} = 1;
2933 wakaba 1.18 return ($self->{current_token}); # DOCTYPE
2934    
2935     redo A;
2936     } else {
2937 wakaba 1.77
2938 wakaba 1.18 $self->{parse_error}-> (type => 'string after SYSTEM literal');
2939 wakaba 1.75 #$self->{current_token}->{quirks} = 1;
2940 wakaba 1.73
2941 wakaba 1.59 $self->{state} = BOGUS_DOCTYPE_STATE;
2942 wakaba 1.1
2943     if (@{$self->{char}}) {
2944 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2945 wakaba 1.1 } else {
2946 wakaba 1.76 $self->{set_next_char}->($self);
2947 wakaba 1.1 }
2948    
2949     redo A;
2950     }
2951 wakaba 1.59 } elsif ($self->{state} == BOGUS_DOCTYPE_STATE) {
2952 wakaba 1.76 if ($self->{next_char} == 0x003E) { # >
2953 wakaba 1.77
2954 wakaba 1.59 $self->{state} = DATA_STATE;
2955 wakaba 1.1
2956     if (@{$self->{char}}) {
2957 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2958 wakaba 1.1 } else {
2959 wakaba 1.76 $self->{set_next_char}->($self);
2960 wakaba 1.1 }
2961    
2962    
2963     return ($self->{current_token}); # DOCTYPE
2964    
2965     redo A;
2966 wakaba 1.76 } elsif ($self->{next_char} == -1) {
2967 wakaba 1.77
2968 wakaba 1.3 $self->{parse_error}-> (type => 'unclosed DOCTYPE');
2969 wakaba 1.59 $self->{state} = DATA_STATE;
2970 wakaba 1.1 ## reconsume
2971    
2972     return ($self->{current_token}); # DOCTYPE
2973    
2974     redo A;
2975     } else {
2976 wakaba 1.77
2977 wakaba 1.1 ## Stay in the state
2978    
2979     if (@{$self->{char}}) {
2980 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
2981 wakaba 1.1 } else {
2982 wakaba 1.76 $self->{set_next_char}->($self);
2983 wakaba 1.1 }
2984    
2985     redo A;
2986     }
2987     } else {
2988     die "$0: $self->{state}: Unknown state";
2989     }
2990     } # A
2991    
2992     die "$0: _get_next_token: unexpected case";
2993     } # _get_next_token
2994    
2995 wakaba 1.72 sub _tokenize_attempt_to_consume_an_entity ($$$) {
2996     my ($self, $in_attr, $additional) = @_;
2997 wakaba 1.20
2998     if ({
2999     0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, # HT, LF, VT, FF,
3000     0x0020 => 1, 0x003C => 1, 0x0026 => 1, -1 => 1, # SP, <, & # 0x000D # CR
3001 wakaba 1.72 $additional => 1,
3002 wakaba 1.76 }->{$self->{next_char}}) {
3003 wakaba 1.78
3004 wakaba 1.20 ## Don't consume
3005     ## No error
3006     return undef;
3007 wakaba 1.76 } elsif ($self->{next_char} == 0x0023) { # #
3008 wakaba 1.1
3009     if (@{$self->{char}}) {
3010 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
3011 wakaba 1.1 } else {
3012 wakaba 1.76 $self->{set_next_char}->($self);
3013 wakaba 1.1 }
3014    
3015 wakaba 1.76 if ($self->{next_char} == 0x0078 or # x
3016     $self->{next_char} == 0x0058) { # X
3017 wakaba 1.26 my $code;
3018 wakaba 1.1 X: {
3019 wakaba 1.76 my $x_char = $self->{next_char};
3020 wakaba 1.1
3021     if (@{$self->{char}}) {
3022 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
3023 wakaba 1.1 } else {
3024 wakaba 1.76 $self->{set_next_char}->($self);
3025 wakaba 1.1 }
3026    
3027 wakaba 1.76 if (0x0030 <= $self->{next_char} and
3028     $self->{next_char} <= 0x0039) { # 0..9
3029 wakaba 1.78
3030 wakaba 1.26 $code ||= 0;
3031     $code *= 0x10;
3032 wakaba 1.76 $code += $self->{next_char} - 0x0030;
3033 wakaba 1.1 redo X;
3034 wakaba 1.76 } elsif (0x0061 <= $self->{next_char} and
3035     $self->{next_char} <= 0x0066) { # a..f
3036 wakaba 1.78
3037 wakaba 1.26 $code ||= 0;
3038     $code *= 0x10;
3039 wakaba 1.76 $code += $self->{next_char} - 0x0060 + 9;
3040 wakaba 1.1 redo X;
3041 wakaba 1.76 } elsif (0x0041 <= $self->{next_char} and
3042     $self->{next_char} <= 0x0046) { # A..F
3043 wakaba 1.78
3044 wakaba 1.26 $code ||= 0;
3045     $code *= 0x10;
3046 wakaba 1.76 $code += $self->{next_char} - 0x0040 + 9;
3047 wakaba 1.1 redo X;
3048 wakaba 1.26 } elsif (not defined $code) { # no hexadecimal digit
3049 wakaba 1.78
3050 wakaba 1.3 $self->{parse_error}-> (type => 'bare hcro');
3051 wakaba 1.76 unshift @{$self->{char}}, ($x_char, $self->{next_char});
3052     $self->{next_char} = 0x0023; # #
3053 wakaba 1.1 return undef;
3054 wakaba 1.76 } elsif ($self->{next_char} == 0x003B) { # ;
3055 wakaba 1.1
3056 wakaba 1.78
3057 wakaba 1.1 if (@{$self->{char}}) {
3058 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
3059 wakaba 1.1 } else {
3060 wakaba 1.76 $self->{set_next_char}->($self);
3061 wakaba 1.1 }
3062    
3063     } else {
3064 wakaba 1.78
3065 wakaba 1.3 $self->{parse_error}-> (type => 'no refc');
3066 wakaba 1.1 }
3067    
3068 wakaba 1.26 if ($code == 0 or (0xD800 <= $code and $code <= 0xDFFF)) {
3069 wakaba 1.78
3070 wakaba 1.26 $self->{parse_error}-> (type => sprintf 'invalid character reference:U+%04X', $code);
3071     $code = 0xFFFD;
3072     } elsif ($code > 0x10FFFF) {
3073 wakaba 1.78
3074 wakaba 1.26 $self->{parse_error}-> (type => sprintf 'invalid character reference:U-%08X', $code);
3075     $code = 0xFFFD;
3076     } elsif ($code == 0x000D) {
3077 wakaba 1.78
3078 wakaba 1.26 $self->{parse_error}-> (type => 'CR character reference');
3079     $code = 0x000A;
3080     } elsif (0x80 <= $code and $code <= 0x9F) {
3081 wakaba 1.78
3082 wakaba 1.30 $self->{parse_error}-> (type => sprintf 'C1 character reference:U+%04X', $code);
3083 wakaba 1.26 $code = $c1_entity_char->{$code};
3084 wakaba 1.1 }
3085    
3086 wakaba 1.68 return {type => CHARACTER_TOKEN, data => chr $code,
3087     has_reference => 1};
3088 wakaba 1.1 } # X
3089 wakaba 1.76 } elsif (0x0030 <= $self->{next_char} and
3090     $self->{next_char} <= 0x0039) { # 0..9
3091     my $code = $self->{next_char} - 0x0030;
3092 wakaba 1.1
3093     if (@{$self->{char}}) {
3094 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
3095 wakaba 1.1 } else {
3096 wakaba 1.76 $self->{set_next_char}->($self);
3097 wakaba 1.1 }
3098    
3099    
3100 wakaba 1.76 while (0x0030 <= $self->{next_char} and
3101     $self->{next_char} <= 0x0039) { # 0..9
3102 wakaba 1.78
3103 wakaba 1.1 $code *= 10;
3104 wakaba 1.76 $code += $self->{next_char} - 0x0030;
3105 wakaba 1.1
3106    
3107     if (@{$self->{char}}) {
3108 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
3109 wakaba 1.1 } else {
3110 wakaba 1.76 $self->{set_next_char}->($self);
3111 wakaba 1.1 }
3112    
3113     }
3114    
3115 wakaba 1.76 if ($self->{next_char} == 0x003B) { # ;
3116 wakaba 1.1
3117 wakaba 1.78
3118 wakaba 1.1 if (@{$self->{char}}) {
3119 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
3120 wakaba 1.1 } else {
3121 wakaba 1.76 $self->{set_next_char}->($self);
3122 wakaba 1.1 }
3123    
3124     } else {
3125 wakaba 1.78
3126 wakaba 1.3 $self->{parse_error}-> (type => 'no refc');
3127 wakaba 1.1 }
3128    
3129 wakaba 1.26 if ($code == 0 or (0xD800 <= $code and $code <= 0xDFFF)) {
3130 wakaba 1.78
3131 wakaba 1.26 $self->{parse_error}-> (type => sprintf 'invalid character reference:U+%04X', $code);
3132     $code = 0xFFFD;
3133     } elsif ($code > 0x10FFFF) {
3134 wakaba 1.78
3135 wakaba 1.26 $self->{parse_error}-> (type => sprintf 'invalid character reference:U-%08X', $code);
3136     $code = 0xFFFD;
3137     } elsif ($code == 0x000D) {
3138 wakaba 1.78
3139 wakaba 1.26 $self->{parse_error}-> (type => 'CR character reference');
3140     $code = 0x000A;
3141 wakaba 1.4 } elsif (0x80 <= $code and $code <= 0x9F) {
3142 wakaba 1.78
3143 wakaba 1.30 $self->{parse_error}-> (type => sprintf 'C1 character reference:U+%04X', $code);
3144 wakaba 1.4 $code = $c1_entity_char->{$code};
3145 wakaba 1.1 }
3146    
3147 wakaba 1.68 return {type => CHARACTER_TOKEN, data => chr $code, has_reference => 1};
3148 wakaba 1.1 } else {
3149 wakaba 1.78
3150 wakaba 1.3 $self->{parse_error}-> (type => 'bare nero');
3151 wakaba 1.76 unshift @{$self->{char}}, ($self->{next_char});
3152     $self->{next_char} = 0x0023; # #
3153 wakaba 1.1 return undef;
3154     }
3155 wakaba 1.76 } elsif ((0x0041 <= $self->{next_char} and
3156     $self->{next_char} <= 0x005A) or
3157     (0x0061 <= $self->{next_char} and
3158     $self->{next_char} <= 0x007A)) {
3159     my $entity_name = chr $self->{next_char};
3160 wakaba 1.1
3161     if (@{$self->{char}}) {
3162 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
3163 wakaba 1.1 } else {
3164 wakaba 1.76 $self->{set_next_char}->($self);
3165 wakaba 1.1 }
3166    
3167    
3168     my $value = $entity_name;
3169 wakaba 1.37 my $match = 0;
3170 wakaba 1.16 require Whatpm::_NamedEntityList;
3171     our $EntityChar;
3172 wakaba 1.1
3173     while (length $entity_name < 10 and
3174     ## NOTE: Some number greater than the maximum length of entity name
3175 wakaba 1.76 ((0x0041 <= $self->{next_char} and # a
3176     $self->{next_char} <= 0x005A) or # x
3177     (0x0061 <= $self->{next_char} and # a
3178     $self->{next_char} <= 0x007A) or # z
3179     (0x0030 <= $self->{next_char} and # 0
3180     $self->{next_char} <= 0x0039) or # 9
3181     $self->{next_char} == 0x003B)) { # ;
3182     $entity_name .= chr $self->{next_char};
3183 wakaba 1.16 if (defined $EntityChar->{$entity_name}) {
3184 wakaba 1.76 if ($self->{next_char} == 0x003B) { # ;
3185 wakaba 1.78
3186 wakaba 1.26 $value = $EntityChar->{$entity_name};
3187 wakaba 1.16 $match = 1;
3188    
3189     if (@{$self->{char}}) {
3190 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
3191 wakaba 1.16 } else {
3192 wakaba 1.76 $self->{set_next_char}->($self);
3193 wakaba 1.16 }
3194    
3195     last;
3196 wakaba 1.37 } else {
3197 wakaba 1.78
3198 wakaba 1.26 $value = $EntityChar->{$entity_name};
3199     $match = -1;
3200 wakaba 1.37
3201     if (@{$self->{char}}) {
3202 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
3203 wakaba 1.37 } else {
3204 wakaba 1.76 $self->{set_next_char}->($self);
3205 wakaba 1.37 }
3206    
3207 wakaba 1.16 }
3208 wakaba 1.1 } else {
3209 wakaba 1.78
3210 wakaba 1.76 $value .= chr $self->{next_char};
3211 wakaba 1.37 $match *= 2;
3212    
3213 wakaba 1.1 if (@{$self->{char}}) {
3214 wakaba 1.76 $self->{next_char} = shift @{$self->{char}};
3215 wakaba 1.1 } else {
3216 wakaba 1.76 $self->{set_next_char}->($self);
3217 wakaba 1.1 }
3218    
3219 wakaba 1.37 }
3220 wakaba 1.1 }
3221    
3222 wakaba 1.16 if ($match > 0) {
3223 wakaba 1.78
3224 wakaba 1.68 return {type => CHARACTER_TOKEN, data => $value, has_reference => 1};
3225 wakaba 1.16 } elsif ($match < 0) {
3226 wakaba 1.30 $self->{parse_error}-> (type => 'no refc');
3227 wakaba 1.37 if ($in_attr and $match < -1) {
3228 wakaba 1.78
3229 wakaba 1.57 return {type => CHARACTER_TOKEN, data => '&'.$entity_name};
3230 wakaba 1.37 } else {
3231 wakaba 1.78
3232 wakaba 1.68 return {type => CHARACTER_TOKEN, data => $value, has_reference => 1};
3233 wakaba 1.37 }
3234 wakaba 1.1 } else {
3235 wakaba 1.78
3236 wakaba 1.3 $self->{parse_error}-> (type => 'bare ero');
3237 wakaba 1.68 ## NOTE: "No characters are consumed" in the spec.
3238 wakaba 1.57 return {type => CHARACTER_TOKEN, data => '&'.$value};
3239 wakaba 1.1 }
3240     } else {
3241 wakaba 1.78
3242 wakaba 1.1 ## no characters are consumed
3243 wakaba 1.3 $self->{parse_error}-> (type => 'bare ero');
3244 wakaba 1.1 return undef;
3245     }
3246     } # _tokenize_attempt_to_consume_an_entity
3247    
3248     sub _initialize_tree_constructor ($) {
3249     my $self = shift;
3250     ## NOTE: $self->{document} MUST be specified before this method is called
3251     $self->{document}->strict_error_checking (0);
3252     ## TODO: Turn mutation events off # MUST
3253     ## TODO: Turn loose Document option (manakai extension) on
3254 wakaba 1.18 $self->{document}->manakai_is_html (1); # MUST
3255 wakaba 1.1 } # _initialize_tree_constructor
3256    
3257     sub _terminate_tree_constructor ($) {
3258     my $self = shift;
3259     $self->{document}->strict_error_checking (1);
3260     ## TODO: Turn mutation events on
3261     } # _terminate_tree_constructor
3262    
3263     ## ISSUE: Should append_child (for example) in script executed in tree construction stage fire mutation events?
3264    
3265 wakaba 1.3 { # tree construction stage
3266     my $token;
3267    
3268 wakaba 1.1 sub _construct_tree ($) {
3269     my ($self) = @_;
3270    
3271     ## When an interactive UA render the $self->{document} available
3272     ## to the user, or when it begin accepting user input, are
3273     ## not defined.
3274    
3275     ## Append a character: collect it and all subsequent consecutive
3276     ## characters and insert one Text node whose data is concatenation
3277     ## of all those characters. # MUST
3278    
3279     $token = $self->_get_next_token;
3280    
3281 wakaba 1.3 undef $self->{form_element};
3282     undef $self->{head_element};
3283     $self->{open_elements} = [];
3284     undef $self->{inner_html_node};
3285    
3286 wakaba 1.84 ## NOTE: The "initial" insertion mode.
3287 wakaba 1.3 $self->_tree_construction_initial; # MUST
3288 wakaba 1.84
3289 wakaba 1.85 ## NOTE: The "before html" insertion mode.
3290 wakaba 1.3 $self->_tree_construction_root_element;
3291 wakaba 1.84 $self->{insertion_mode} = BEFORE_HEAD_IM;
3292    
3293     ## NOTE: The "before head" insertion mode and so on.
3294 wakaba 1.3 $self->_tree_construction_main;
3295     } # _construct_tree
3296    
3297     sub _tree_construction_initial ($) {
3298     my $self = shift;
3299 wakaba 1.84
3300     ## NOTE: "initial" insertion mode
3301    
3302 wakaba 1.18 INITIAL: {
3303 wakaba 1.57 if ($token->{type} == DOCTYPE_TOKEN) {
3304 wakaba 1.18 ## NOTE: Conformance checkers MAY, instead of reporting "not HTML5"
3305     ## error, switch to a conformance checking mode for another
3306     ## language.
3307     my $doctype_name = $token->{name};
3308     $doctype_name = '' unless defined $doctype_name;
3309     $doctype_name =~ tr/a-z/A-Z/;
3310     if (not defined $token->{name} or # <!DOCTYPE>
3311     defined $token->{public_identifier} or
3312     defined $token->{system_identifier}) {
3313 wakaba 1.79
3314 wakaba 1.18 $self->{parse_error}-> (type => 'not HTML5');
3315     } elsif ($doctype_name ne 'HTML') {
3316 wakaba 1.79
3317 wakaba 1.18 ## ISSUE: ASCII case-insensitive? (in fact it does not matter)
3318     $self->{parse_error}-> (type => 'not HTML5');
3319 wakaba 1.79 } else {
3320    
3321 wakaba 1.18 }
3322    
3323     my $doctype = $self->{document}->create_document_type_definition
3324     ($token->{name}); ## ISSUE: If name is missing (e.g. <!DOCTYPE>)?
3325     $doctype->public_id ($token->{public_identifier})
3326     if defined $token->{public_identifier};
3327     $doctype->system_id ($token->{system_identifier})
3328     if defined $token->{system_identifier};
3329     ## NOTE: Other DocumentType attributes are null or empty lists.
3330     ## ISSUE: internalSubset = null??
3331     $self->{document}->append_child ($doctype);
3332    
3333 wakaba 1.75 if ($token->{quirks} or $doctype_name ne 'HTML') {
3334 wakaba 1.79
3335 wakaba 1.18 $self->{document}->manakai_compat_mode ('quirks');
3336     } elsif (defined $token->{public_identifier}) {
3337     my $pubid = $token->{public_identifier};
3338     $pubid =~ tr/a-z/A-z/;
3339     if ({
3340     "+//SILMARIL//DTD HTML PRO V0R11 19970101//EN" => 1,
3341     "-//ADVASOFT LTD//DTD HTML 3.0 ASWEDIT + EXTENSIONS//EN" => 1,
3342     "-//AS//DTD HTML 3.0 ASWEDIT + EXTENSIONS//EN" => 1,
3343     "-//IETF//DTD HTML 2.0 LEVEL 1//EN" => 1,
3344     "-//IETF//DTD HTML 2.0 LEVEL 2//EN" => 1,
3345     "-//IETF//DTD HTML 2.0 STRICT LEVEL 1//EN" => 1,
3346     "-//IETF//DTD HTML 2.0 STRICT LEVEL 2//EN" => 1,
3347     "-//IETF//DTD HTML 2.0 STRICT//EN" => 1,
3348     "-//IETF//DTD HTML 2.0//EN" => 1,
3349     "-//IETF//DTD HTML 2.1E//EN" => 1,
3350     "-//IETF//DTD HTML 3.0//EN" => 1,
3351     "-//IETF//DTD HTML 3.0//EN//" => 1,
3352     "-//IETF//DTD HTML 3.2 FINAL//EN" => 1,
3353     "-//IETF//DTD HTML 3.2//EN" => 1,
3354     "-//IETF//DTD HTML 3//EN" => 1,
3355     "-//IETF//DTD HTML LEVEL 0//EN" => 1,
3356     "-//IETF//DTD HTML LEVEL 0//EN//2.0" => 1,
3357     "-//IETF//DTD HTML LEVEL 1//EN" => 1,
3358     "-//IETF//DTD HTML LEVEL 1//EN//2.0" => 1,
3359     "-//IETF//DTD HTML LEVEL 2//EN" => 1,
3360     "-//IETF//DTD HTML LEVEL 2//EN//2.0" => 1,
3361     "-//IETF//DTD HTML LEVEL 3//EN" => 1,
3362     "-//IETF//DTD HTML LEVEL 3//EN//3.0" => 1,
3363     "-//IETF//DTD HTML STRICT LEVEL 0//EN" => 1,
3364     "-//IETF//DTD HTML STRICT LEVEL 0//EN//2.0" => 1,
3365     "-//IETF//DTD HTML STRICT LEVEL 1//EN" => 1,
3366     "-//IETF//DTD HTML STRICT LEVEL 1//EN//2.0" => 1,
3367     "-//IETF//DTD HTML STRICT LEVEL 2//EN" => 1,
3368     "-//IETF//DTD HTML STRICT LEVEL 2//EN//2.0" => 1,
3369     "-//IETF//DTD HTML STRICT LEVEL 3//EN" => 1,
3370     "-//IETF//DTD HTML STRICT LEVEL 3//EN//3.0" => 1,
3371     "-//IETF//DTD HTML STRICT//EN" => 1,
3372     "-//IETF//DTD HTML STRICT//EN//2.0" => 1,
3373     "-//IETF//DTD HTML STRICT//EN//3.0" => 1,
3374     "-//IETF//DTD HTML//EN" => 1,
3375     "-//IETF//DTD HTML//EN//2.0" => 1,
3376     "-//IETF//DTD HTML//EN//3.0" => 1,
3377     "-//METRIUS//DTD METRIUS PRESENTATIONAL//EN" => 1,
3378     "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML STRICT//EN" => 1,
3379     "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML//EN" => 1,
3380     "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 TABLES//EN" => 1,
3381     "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML STRICT//EN" => 1,
3382     "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML//EN" => 1,
3383     "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 TABLES//EN" => 1,
3384     "-//NETSCAPE COMM. CORP.//DTD HTML//EN" => 1,
3385     "-//NETSCAPE COMM. CORP.//DTD STRICT HTML//EN" => 1,
3386     "-//O'REILLY AND ASSOCIATES//DTD HTML 2.0//EN" => 1,
3387     "-//O'REILLY AND ASSOCIATES//DTD HTML EXTENDED 1.0//EN" => 1,
3388 wakaba 1.72 "-//O'REILLY AND ASSOCIATES//DTD HTML EXTENDED RELAXED 1.0//EN" => 1,
3389     "-//SOFTQUAD SOFTWARE//DTD HOTMETAL PRO 6.0::19990601::EXTENSIONS TO HTML 4.0//EN" => 1,
3390     "-//SOFTQUAD//DTD HOTMETAL PRO 4.0::19971010::EXTENSIONS TO HTML 4.0//EN" => 1,
3391 wakaba 1.18 "-//SPYGLASS//DTD HTML 2.0 EXTENDED//EN" => 1,
3392     "-//SQ//DTD HTML 2.0 HOTMETAL + EXTENSIONS//EN" => 1,
3393     "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA HTML//EN" => 1,
3394     "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA STRICT HTML//EN" => 1,
3395     "-//W3C//DTD HTML 3 1995-03-24//EN" => 1,
3396     "-//W3C//DTD HTML 3.2 DRAFT//EN" => 1,
3397     "-//W3C//DTD HTML 3.2 FINAL//EN" => 1,
3398     "-//W3C//DTD HTML 3.2//EN" => 1,
3399     "-//W3C//DTD HTML 3.2S DRAFT//EN" => 1,
3400     "-//W3C//DTD HTML 4.0 FRAMESET//EN" => 1,
3401     "-//W3C//DTD HTML 4.0 TRANSITIONAL//EN" => 1,
3402     "-//W3C//DTD HTML EXPERIMETNAL 19960712//EN" => 1,
3403     "-//W3C//DTD HTML EXPERIMENTAL 970421//EN" => 1,
3404     "-//W3C//DTD W3 HTML//EN" => 1,
3405     "-//W3O//DTD W3 HTML 3.0//EN" => 1,
3406     "-//W3O//DTD W3 HTML 3.0//EN//" => 1,
3407     "-//W3O//DTD W3 HTML STRICT 3.0//EN//" => 1,
3408     "-//WEBTECHS//DTD MOZILLA HTML 2.0//EN" => 1,
3409     "-//WEBTECHS//DTD MOZILLA HTML//EN" => 1,
3410     "-/W3C/DTD HTML 4.0 TRANSITIONAL/EN" => 1,
3411     "HTML" => 1,
3412     }->{$pubid}) {
3413 wakaba 1.79
3414 wakaba 1.18 $self->{document}->manakai_compat_mode ('quirks');
3415     } elsif ($pubid eq "-//W3C//DTD HTML 4.01 FRAMESET//EN" or
3416     $pubid eq "-//W3C//DTD HTML 4.01 TRANSITIONAL//EN") {
3417     if (defined $token->{system_identifier}) {
3418 wakaba 1.79
3419 wakaba 1.18 $self->{document}->manakai_compat_mode ('quirks');
3420     } else {
3421 wakaba 1.79
3422 wakaba 1.18 $self->{document}->manakai_compat_mode ('limited quirks');
3423 wakaba 1.3 }
3424 wakaba 1.80 } elsif ($pubid eq "-//W3C//DTD XHTML 1.0 FRAMESET//EN" or
3425     $pubid eq "-//W3C//DTD XHTML 1.0 TRANSITIONAL//EN") {
3426 wakaba 1.79
3427 wakaba 1.18 $self->{document}->manakai_compat_mode ('limited quirks');
3428 wakaba 1.79 } else {
3429    
3430 wakaba 1.18 }
3431 wakaba 1.79 } else {
3432    
3433 wakaba 1.18 }
3434     if (defined $token->{system_identifier}) {
3435     my $sysid = $token->{system_identifier};
3436     $sysid =~ tr/A-Z/a-z/;
3437     if ($sysid eq "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd") {
3438 wakaba 1.80 ## TODO: Check the spec: PUBLIC "(limited quirks)" "(quirks)"
3439 wakaba 1.18 $self->{document}->manakai_compat_mode ('quirks');
3440 wakaba 1.79
3441     } else {
3442    
3443 wakaba 1.18 }
3444 wakaba 1.79 } else {
3445    
3446 wakaba 1.18 }
3447    
3448 wakaba 1.85 ## Go to the "before html" insertion mode.
3449 wakaba 1.18 $token = $self->_get_next_token;
3450     return;
3451     } elsif ({
3452 wakaba 1.57 START_TAG_TOKEN, 1,
3453     END_TAG_TOKEN, 1,
3454     END_OF_FILE_TOKEN, 1,
3455 wakaba 1.18 }->{$token->{type}}) {
3456 wakaba 1.79
3457 wakaba 1.18 $self->{parse_error}-> (type => 'no DOCTYPE');
3458     $self->{document}->manakai_compat_mode ('quirks');
3459 wakaba 1.85 ## Go to the "before html" insertion mode.
3460 wakaba 1.18 ## reprocess
3461     return;
3462 wakaba 1.57 } elsif ($token->{type} == CHARACTER_TOKEN) {
3463 wakaba 1.18 if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D
3464     ## Ignore the token
3465 wakaba 1.26
3466 wakaba 1.18 unless (length $token->{data}) {
3467 wakaba 1.79
3468 wakaba 1.84 ## Stay in the insertion mode.
3469 wakaba 1.18 $token = $self->_get_next_token;
3470     redo INITIAL;
3471 wakaba 1.79 } else {
3472    
3473 wakaba 1.3 }
3474 wakaba 1.79 } else {
3475    
3476 wakaba 1.3 }
3477 wakaba 1.18
3478     $self->{parse_error}-> (type => 'no DOCTYPE');
3479     $self->{document}->manakai_compat_mode ('quirks');
3480 wakaba 1.85 ## Go to the "before html" insertion mode.
3481 wakaba 1.18 ## reprocess
3482     return;
3483 wakaba 1.57 } elsif ($token->{type} == COMMENT_TOKEN) {
3484 wakaba 1.79
3485 wakaba 1.18 my $comment = $self->{document}->create_comment ($token->{data});
3486     $self->{document}->append_child ($comment);
3487    
3488 wakaba 1.84 ## Stay in the insertion mode.
3489 wakaba 1.18 $token = $self->_get_next_token;
3490     redo INITIAL;
3491     } else {
3492 wakaba 1.57 die "$0: $token->{type}: Unknown token type";
3493 wakaba 1.18 }
3494     } # INITIAL
3495 wakaba 1.79
3496     die "$0: _tree_construction_initial: This should be never reached";
3497 wakaba 1.3 } # _tree_construction_initial
3498    
3499     sub _tree_construction_root_element ($) {
3500     my $self = shift;
3501 wakaba 1.84
3502 wakaba 1.85 ## NOTE: "before html" insertion mode.
3503 wakaba 1.3
3504     B: {
3505 wakaba 1.57 if ($token->{type} == DOCTYPE_TOKEN) {
3506 wakaba 1.79
3507 wakaba 1.3 $self->{parse_error}-> (type => 'in html:#DOCTYPE');
3508     ## Ignore the token
3509 wakaba 1.84 ## Stay in the insertion mode.
3510 wakaba 1.3 $token = $self->_get_next_token;
3511     redo B;
3512 wakaba 1.57 } elsif ($token->{type} == COMMENT_TOKEN) {
3513 wakaba 1.79
3514 wakaba 1.3 my $comment = $self->{document}->create_comment ($token->{data});
3515     $self->{document}->append_child ($comment);
3516 wakaba 1.84 ## Stay in the insertion mode.
3517 wakaba 1.3 $token = $self->_get_next_token;
3518     redo B;
3519 wakaba 1.57 } elsif ($token->{type} == CHARACTER_TOKEN) {
3520 wakaba 1.26 if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D
3521     ## Ignore the token.
3522    
3523 wakaba 1.3 unless (length $token->{data}) {
3524 wakaba 1.79
3525 wakaba 1.84 ## Stay in the insertion mode.
3526 wakaba 1.3 $token = $self->_get_next_token;
3527     redo B;
3528 wakaba 1.79 } else {
3529    
3530 wakaba 1.3 }
3531 wakaba 1.79 } else {
3532    
3533 wakaba 1.3 }
3534 wakaba 1.63
3535     $self->{application_cache_selection}->(undef);
3536    
3537     #
3538     } elsif ($token->{type} == START_TAG_TOKEN) {
3539 wakaba 1.84 if ($token->{tag_name} eq 'html') {
3540     my $root_element;
3541 wakaba 1.79
3542 wakaba 1.84 $root_element = $self->{document}->create_element_ns
3543     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
3544    
3545     for my $attr_name (keys %{ $token->{attributes}}) {
3546     $root_element->set_attribute_ns (undef, [undef, $attr_name],
3547     $token->{attributes} ->{$attr_name}->{value});
3548     }
3549    
3550     $self->{document}->append_child ($root_element);
3551     push @{$self->{open_elements}}, [$root_element, 'html'];
3552    
3553     if ($token->{attributes}->{manifest}) {
3554    
3555     $self->{application_cache_selection}
3556     ->($token->{attributes}->{manifest}->{value});
3557     ## ISSUE: No relative reference resolution?
3558     } else {
3559    
3560     $self->{application_cache_selection}->(undef);
3561     }
3562    
3563     $token = $self->_get_next_token;
3564     return; ## Go to the "before head" insertion mode.
3565 wakaba 1.63 } else {
3566 wakaba 1.79
3567 wakaba 1.84 #
3568 wakaba 1.63 }
3569 wakaba 1.3 } elsif ({
3570 wakaba 1.57 END_TAG_TOKEN, 1,
3571     END_OF_FILE_TOKEN, 1,
3572 wakaba 1.3 }->{$token->{type}}) {
3573 wakaba 1.79
3574 wakaba 1.3 #
3575     } else {
3576 wakaba 1.57 die "$0: $token->{type}: Unknown token type";
3577 wakaba 1.3 }
3578 wakaba 1.63
3579 wakaba 1.84 my $root_element;
3580 wakaba 1.3 $root_element = $self->{document}->create_element_ns
3581     (q<http://www.w3.org/1999/xhtml>, [undef, 'html']);
3582    
3583 wakaba 1.84 $self->{document}->append_child ($root_element);
3584     push @{$self->{open_elements}}, [$root_element, 'html'];
3585    
3586     $self->{application_cache_selection}->(undef);
3587    
3588     ## NOTE: Reprocess the token.
3589     return; ## Go to the "before head" insertion mode.
3590    
3591     ## ISSUE: There is an issue in the spec
3592 wakaba 1.3 } # B
3593 wakaba 1.79
3594     die "$0: _tree_construction_root_element: This should never be reached";
3595 wakaba 1.3 } # _tree_construction_root_element
3596    
3597     sub _reset_insertion_mode ($) {
3598     my $self = shift;
3599    
3600     ## Step 1
3601     my $last;
3602    
3603     ## Step 2
3604     my $i = -1;
3605     my $node = $self->{open_elements}->[$i];
3606    
3607     ## Step 3
3608     S3: {
3609 wakaba 1.29 ## ISSUE: Oops! "If node is the first node in the stack of open
3610     ## elements, then set last to true. If the context element of the
3611     ## HTML fragment parsing algorithm is neither a td element nor a
3612     ## th element, then set node to the context element. (fragment case)":
3613     ## The second "if" is in the scope of the first "if"!?
3614     if ($self->{open_elements}->[0]->[0] eq $node->[0]) {
3615     $last = 1;
3616     if (defined $self->{inner_html_node}) {
3617     if ($self->{inner_html_node}->[1] eq 'td' or
3618     $self->{inner_html_node}->[1] eq 'th') {
3619 wakaba 1.79
3620 wakaba 1.29 #
3621     } else {
3622 wakaba 1.79
3623 wakaba 1.29 $node = $self->{inner_html_node};
3624     }
3625 wakaba 1.3 }
3626     }
3627    
3628     ## Step 4..13
3629     my $new_mode = {
3630 wakaba 1.56 select => IN_SELECT_IM,
3631 wakaba 1.83 ## NOTE: |option| and |optgroup| do not set
3632     ## insertion mode to "in select" by themselves.
3633 wakaba 1.56 td => IN_CELL_IM,
3634     th => IN_CELL_IM,
3635     tr => IN_ROW_IM,
3636     tbody => IN_TABLE_BODY_IM,
3637     thead => IN_TABLE_BODY_IM,
3638     tfoot => IN_TABLE_BODY_IM,
3639     caption => IN_CAPTION_IM,
3640     colgroup => IN_COLUMN_GROUP_IM,
3641     table => IN_TABLE_IM,
3642     head => IN_BODY_IM, # not in head!
3643     body => IN_BODY_IM,
3644     frameset => IN_FRAMESET_IM,
3645 wakaba 1.3 }->{$node->[1]};
3646     $self->{insertion_mode} = $new_mode and return if defined $new_mode;
3647    
3648     ## Step 14
3649     if ($node->[1] eq 'html') {
3650     unless (defined $self->{head_element}) {
3651 wakaba 1.79
3652 wakaba 1.56 $self->{insertion_mode} = BEFORE_HEAD_IM;
3653 wakaba 1.3 } else {
3654 wakaba 1.81 ## ISSUE: Can this state be reached?
3655 wakaba 1.79
3656 wakaba 1.56 $self->{insertion_mode} = AFTER_HEAD_IM;
3657 wakaba 1.3 }
3658     return;
3659 wakaba 1.79 } else {
3660    
3661 wakaba 1.3 }
3662    
3663     ## Step 15
3664 wakaba 1.56 $self->{insertion_mode} = IN_BODY_IM and return if $last;
3665 wakaba 1.3
3666     ## Step 16
3667     $i--;
3668     $node = $self->{open_elements}->[$i];
3669    
3670     ## Step 17
3671     redo S3;
3672     } # S3
3673 wakaba 1.79
3674     die "$0: _reset_insertion_mode: This line should never be reached";
3675 wakaba 1.3 } # _reset_insertion_mode
3676    
3677     sub _tree_construction_main ($) {
3678     my $self = shift;
3679    
3680 wakaba 1.1 my $active_formatting_elements = [];
3681    
3682     my $reconstruct_active_formatting_elements = sub { # MUST
3683     my $insert = shift;
3684    
3685     ## Step 1
3686     return unless @$active_formatting_elements;
3687    
3688     ## Step 3
3689     my $i = -1;
3690     my $entry = $active_formatting_elements->[$i];
3691    
3692     ## Step 2
3693     return if $entry->[0] eq '#marker';
3694 wakaba 1.3 for (@{$self->{open_elements}}) {
3695 wakaba 1.1 if ($entry->[0] eq $_->[0]) {
3696 wakaba 1.79
3697 wakaba 1.1 return;
3698     }
3699     }
3700    
3701     S4: {
3702     ## Step 4
3703     last S4 if $active_formatting_elements->[0]->[0] eq $entry->[0];
3704    
3705     ## Step 5
3706     $i--;
3707     $entry = $active_formatting_elements->[$i];
3708    
3709     ## Step 6
3710     if ($entry->[0] eq '#marker') {
3711 wakaba 1.79
3712 wakaba 1.1 #
3713     } else {
3714     my $in_open_elements;
3715 wakaba 1.3 OE: for (@{$self->{open_elements}}) {
3716 wakaba 1.1 if ($entry->[0] eq $_->[0]) {
3717 wakaba 1.79
3718 wakaba 1.1 $in_open_elements = 1;
3719     last OE;
3720     }
3721     }
3722     if ($in_open_elements) {
3723 wakaba 1.79
3724 wakaba 1.1 #
3725     } else {
3726 wakaba 1.81 ## NOTE: <!DOCTYPE HTML><p><b><i><u></p> <p>X
3727 wakaba 1.79
3728 wakaba 1.1 redo S4;
3729     }
3730     }
3731    
3732     ## Step 7
3733     $i++;
3734     $entry = $active_formatting_elements->[$i];
3735     } # S4
3736    
3737     S7: {
3738     ## Step 8
3739     my $clone = [$entry->[0]->clone_node (0), $entry->[1]];
3740    
3741     ## Step 9
3742     $insert->($clone->[0]);
3743 wakaba 1.3 push @{$self->{open_elements}}, $clone;
3744 wakaba 1.1
3745     ## Step 10
3746 wakaba 1.3 $active_formatting_elements->[$i] = $self->{open_elements}->[-1];
3747 wakaba 1.1
3748     ## Step 11
3749     unless ($clone->[0] eq $active_formatting_elements->[-1]->[0]) {
3750 wakaba 1.79
3751 wakaba 1.1 ## Step 7'
3752     $i++;
3753     $entry = $active_formatting_elements->[$i];
3754    
3755     redo S7;
3756     }
3757 wakaba 1.79
3758    
3759 wakaba 1.1 } # S7
3760     }; # $reconstruct_active_formatting_elements
3761    
3762     my $clear_up_to_marker = sub {
3763     for (reverse 0..$#$active_formatting_elements) {
3764     if ($active_formatting_elements->[$_]->[0] eq '#marker') {
3765 wakaba 1.79
3766 wakaba 1.1 splice @$active_formatting_elements, $_;
3767     return;
3768     }
3769     }
3770 wakaba 1.79
3771    
3772 wakaba 1.1 }; # $clear_up_to_marker
3773    
3774 wakaba 1.25 my $parse_rcdata = sub ($$) {
3775     my ($content_model_flag, $insert) = @_;
3776    
3777     ## Step 1
3778     my $start_tag_name = $token->{tag_name};
3779     my $el;
3780    
3781     $el = $self->{document}->create_element_ns
3782     (q<http://www.w3.org/1999/xhtml>, [undef, $start_tag_name]);
3783 wakaba 1.1
3784 wakaba 1.6 for my $attr_name (keys %{ $token->{attributes}}) {
3785 wakaba 1.25 $el->set_attribute_ns (undef, [undef, $attr_name],
3786 wakaba 1.6 $token->{attributes} ->{$attr_name}->{value});
3787     }
3788    
3789 wakaba 1.25
3790     ## Step 2
3791     $insert->($el); # /context node/->append_child ($el)
3792    
3793     ## Step 3
3794 wakaba 1.41 $self->{content_model} = $content_model_flag; # CDATA or RCDATA
3795 wakaba 1.13 delete $self->{escape}; # MUST
3796 wakaba 1.25
3797     ## Step 4
3798 wakaba 1.1 my $text = '';
3799     $token = $self->_get_next_token;
3800 wakaba 1.57 while ($token->{type} == CHARACTER_TOKEN) { # or until stop tokenizing
3801 wakaba 1.79
3802 wakaba 1.1 $text .= $token->{data};
3803     $token = $self->_get_next_token;
3804 wakaba 1.25 }
3805    
3806     ## Step 5
3807 wakaba 1.1 if (length $text) {
3808 wakaba 1.79
3809 wakaba 1.25 my $text = $self->{document}->create_text_node ($text);
3810     $el->append_child ($text);
3811 wakaba 1.1 }
3812 wakaba 1.25
3813     ## Step 6
3814 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL;
3815 wakaba 1.25
3816     ## Step 7
3817 wakaba 1.79 if ($token->{type} == END_TAG_TOKEN and
3818     $token->{tag_name} eq $start_tag_name) {
3819    
3820 wakaba 1.1 ## Ignore the token
3821 wakaba 1.41 } elsif ($content_model_flag == CDATA_CONTENT_MODEL) {
3822 wakaba 1.79
3823 wakaba 1.41 $self->{parse_error}-> (type => 'in CDATA:#'.$token->{type});
3824     } elsif ($content_model_flag == RCDATA_CONTENT_MODEL) {
3825 wakaba 1.79
3826 wakaba 1.41 $self->{parse_error}-> (type => 'in RCDATA:#'.$token->{type});
3827 wakaba 1.1 } else {
3828 wakaba 1.41 die "$0: $content_model_flag in parse_rcdata";
3829 wakaba 1.1 }
3830     $token = $self->_get_next_token;
3831 wakaba 1.25 }; # $parse_rcdata
3832 wakaba 1.1
3833 wakaba 1.25 my $script_start_tag = sub ($) {
3834     my $insert = $_[0];
3835 wakaba 1.1 my $script_el;
3836    
3837     $script_el = $self->{document}->create_element_ns
3838     (q<http://www.w3.org/1999/xhtml>, [undef, 'script']);
3839    
3840     for my $attr_name (keys %{ $token->{attributes}}) {
3841     $script_el->set_attribute_ns (undef, [undef, $attr_name],
3842     $token->{attributes} ->{$attr_name}->{value});
3843     }
3844    
3845     ## TODO: mark as "parser-inserted"
3846    
3847 wakaba 1.41 $self->{content_model} = CDATA_CONTENT_MODEL;
3848 wakaba 1.13 delete $self->{escape}; # MUST
3849 wakaba 1.1
3850     my $text = '';
3851     $token = $self->_get_next_token;
3852 wakaba 1.57 while ($token->{type} == CHARACTER_TOKEN) {
3853 wakaba 1.79
3854 wakaba 1.1 $text .= $token->{data};
3855     $token = $self->_get_next_token;
3856     } # stop if non-character token or tokenizer stops tokenising
3857     if (length $text) {
3858 wakaba 1.79
3859 wakaba 1.1 $script_el->manakai_append_text ($text);
3860     }
3861    
3862 wakaba 1.41 $self->{content_model} = PCDATA_CONTENT_MODEL;
3863 wakaba 1.1
3864 wakaba 1.57 if ($token->{type} == END_TAG_TOKEN and
3865 wakaba 1.1 $token->{tag_name} eq 'script') {
3866 wakaba 1.79
3867 wakaba 1.1 ## Ignore the token
3868     } else {
3869 wakaba 1.79
3870 wakaba 1.3 $self->{parse_error}-> (type => 'in CDATA:#'.$token->{type});
3871 wakaba 1.1 ## ISSUE: And ignore?
3872     ## TODO: mark as "already executed"
3873     }
3874    
3875 wakaba 1.3 if (defined $self->{inner_html_node}) {
3876 wakaba 1.79
3877 wakaba 1.3 ## TODO: mark as "already executed"
3878     } else {
3879 wakaba 1.79
3880 wakaba 1.1 ## TODO: $old_insertion_point = current insertion point
3881     ## TODO: insertion point = just before the next input character
3882 wakaba 1.25
3883     $insert->($script_el);
3884 wakaba 1.1
3885     ## TODO: insertion point = $old_insertion_point (might be "undefined")
3886    
3887     ## TODO: if there is a script that will execute as soon as the parser resume, then...
3888     }
3889    
3890     $token = $self->_get_next_token;
3891     }; # $script_start_tag
3892    
3893     my $formatting_end_tag = sub {
3894     my $tag_name = shift;
3895    
3896     FET: {
3897     ## Step 1
3898     my $formatting_element;
3899     my $formatting_element_i_in_active;
3900     AFE: for (reverse 0..$#$active_formatting_elements) {
3901     if ($active_formatting_elements->[$_]->[1] eq $tag_name) {
3902 wakaba 1.79
3903 wakaba 1.1 $formatting_element = $active_formatting_elements->[$_];
3904     $formatting_element_i_in_active = $_;
3905     last AFE;
3906     } elsif ($active_formatting_elements->[$_]->[0] eq '#marker') {
3907 wakaba 1.79
3908 wakaba 1.1 last AFE;
3909     }
3910     } # AFE
3911     unless (defined $formatting_element) {
3912 wakaba 1.79
3913 wakaba 1.3 $self->{parse_error}-> (type => 'unmatched end tag:'.$tag_name);
3914 wakaba 1.1 ## Ignore the token
3915     $token = $self->_get_next_token;
3916     return;
3917     }
3918     ## has an element in scope
3919     my $in_scope = 1;
3920     my $formatting_element_i_in_open;
3921 wakaba 1.3 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3922     my $node = $self->{open_elements}->[$_];
3923 wakaba 1.1 if ($node->[0] eq $formatting_element->[0]) {
3924     if ($in_scope) {
3925 wakaba 1.79
3926 wakaba 1.1 $formatting_element_i_in_open = $_;
3927     last INSCOPE;
3928     } else { # in open elements but not in scope
3929 wakaba 1.79
3930 wakaba 1.4 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
3931 wakaba 1.1 ## Ignore the token
3932     $token = $self->_get_next_token;
3933     return;
3934     }
3935     } elsif ({
3936     table => 1, caption => 1, td => 1, th => 1,
3937     button => 1, marquee => 1, object => 1, html => 1,
3938     }->{$node->[1]}) {
3939 wakaba 1.79
3940 wakaba 1.1 $in_scope = 0;
3941     }
3942     } # INSCOPE
3943     unless (defined $formatting_element_i_in_open) {
3944 wakaba 1.79
3945 wakaba 1.4 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
3946 wakaba 1.1 pop @$active_formatting_elements; # $formatting_element
3947     $token = $self->_get_next_token; ## TODO: ok?
3948     return;
3949     }
3950 wakaba 1.3 if (not $self->{open_elements}->[-1]->[0] eq $formatting_element->[0]) {
3951 wakaba 1.79
3952 wakaba 1.4 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3953 wakaba 1.1 }
3954    
3955     ## Step 2
3956     my $furthest_block;
3957     my $furthest_block_i_in_open;
3958 wakaba 1.3 OE: for (reverse 0..$#{$self->{open_elements}}) {
3959     my $node = $self->{open_elements}->[$_];
3960 wakaba 1.1 if (not $formatting_category->{$node->[1]} and
3961     #not $phrasing_category->{$node->[1]} and
3962     ($special_category->{$node->[1]} or
3963     $scoping_category->{$node->[1]})) {
3964 wakaba 1.79
3965 wakaba 1.1 $furthest_block = $node;
3966     $furthest_block_i_in_open = $_;
3967     } elsif ($node->[0] eq $formatting_element->[0]) {
3968 wakaba 1.79
3969 wakaba 1.1 last OE;
3970     }
3971     } # OE
3972    
3973     ## Step 3
3974     unless (defined $furthest_block) { # MUST
3975 wakaba 1.79
3976 wakaba 1.3 splice @{$self->{open_elements}}, $formatting_element_i_in_open;
3977 wakaba 1.1 splice @$active_formatting_elements, $formatting_element_i_in_active, 1;
3978     $token = $self->_get_next_token;
3979     return;
3980     }
3981    
3982     ## Step 4
3983 wakaba 1.3 my $common_ancestor_node = $self->{open_elements}->[$formatting_element_i_in_open - 1];
3984 wakaba 1.1
3985     ## Step 5
3986     my $furthest_block_parent = $furthest_block->[0]->parent_node;
3987     if (defined $furthest_block_parent) {
3988 wakaba 1.79
3989 wakaba 1.1 $furthest_block_parent->remove_child ($furthest_block->[0]);
3990     }
3991    
3992     ## Step 6
3993     my $bookmark_prev_el
3994     = $active_formatting_elements->[$formatting_element_i_in_active - 1]
3995     ->[0];
3996    
3997     ## Step 7
3998     my $node = $furthest_block;
3999     my $node_i_in_open = $furthest_block_i_in_open;
4000     my $last_node = $furthest_block;
4001     S7: {
4002     ## Step 1
4003     $node_i_in_open--;
4004 wakaba 1.3 $node = $self->{open_elements}->[$node_i_in_open];
4005 wakaba 1.1
4006     ## Step 2
4007     my $node_i_in_active;
4008     S7S2: {
4009     for (reverse 0..$#$active_formatting_elements) {
4010     if ($active_formatting_elements->[$_]->[0] eq $node->[0]) {
4011 wakaba 1.79
4012 wakaba 1.1 $node_i_in_active = $_;
4013     last S7S2;
4014     }
4015     }
4016 wakaba 1.3 splice @{$self->{open_elements}}, $node_i_in_open, 1;
4017 wakaba 1.1 redo S7;
4018     } # S7S2
4019    
4020     ## Step 3
4021     last S7 if $node->[0] eq $formatting_element->[0];
4022    
4023     ## Step 4
4024     if ($last_node->[0] eq $furthest_block->[0]) {
4025 wakaba 1.79
4026 wakaba 1.1 $bookmark_prev_el = $node->[0];
4027     }
4028    
4029     ## Step 5
4030     if ($node->[0]->has_child_nodes ()) {
4031 wakaba 1.79
4032 wakaba 1.1 my $clone = [$node->[0]->clone_node (0), $node->[1]];
4033     $active_formatting_elements->[$node_i_in_active] = $clone;
4034 wakaba 1.3 $self->{open_elements}->[$node_i_in_open] = $clone;
4035 wakaba 1.1 $node = $clone;
4036     }
4037    
4038     ## Step 6
4039     $node->[0]->append_child ($last_node->[0]);
4040    
4041     ## Step 7
4042     $last_node = $node;
4043    
4044     ## Step 8
4045     redo S7;
4046     } # S7
4047    
4048     ## Step 8
4049     $common_ancestor_node->[0]->append_child ($last_node->[0]);
4050    
4051     ## Step 9
4052     my $clone = [$formatting_element->[0]->clone_node (0),
4053     $formatting_element->[1]];
4054    
4055     ## Step 10
4056     my @cn = @{$furthest_block->[0]->child_nodes};
4057     $clone->[0]->append_child ($_) for @cn;
4058    
4059     ## Step 11
4060     $furthest_block->[0]->append_child ($clone->[0]);
4061    
4062     ## Step 12
4063     my $i;
4064     AFE: for (reverse 0..$#$active_formatting_elements) {
4065     if ($active_formatting_elements->[$_]->[0] eq $formatting_element->[0]) {
4066 wakaba 1.79
4067 wakaba 1.1 splice @$active_formatting_elements, $_, 1;
4068     $i-- and last AFE if defined $i;
4069     } elsif ($active_formatting_elements->[$_]->[0] eq $bookmark_prev_el) {
4070 wakaba 1.79
4071 wakaba 1.1 $i = $_;
4072     }
4073     } # AFE
4074     splice @$active_formatting_elements, $i + 1, 0, $clone;
4075    
4076     ## Step 13
4077     undef $i;
4078 wakaba 1.3 OE: for (reverse 0..$#{$self->{open_elements}}) {
4079     if ($self->{open_elements}->[$_]->[0] eq $formatting_element->[0]) {
4080 wakaba 1.79
4081 wakaba 1.3 splice @{$self->{open_elements}}, $_, 1;
4082 wakaba 1.1 $i-- and last OE if defined $i;
4083 wakaba 1.3 } elsif ($self->{open_elements}->[$_]->[0] eq $furthest_block->[0]) {
4084 wakaba 1.79
4085 wakaba 1.1 $i = $_;
4086     }
4087     } # OE
4088 wakaba 1.3 splice @{$self->{open_elements}}, $i + 1, 1, $clone;
4089 wakaba 1.1
4090     ## Step 14
4091     redo FET;
4092     } # FET
4093     }; # $formatting_end_tag
4094    
4095     my $insert_to_current = sub {
4096 wakaba 1.25 $self->{open_elements}->[-1]->[0]->append_child ($_[0]);
4097 wakaba 1.1 }; # $insert_to_current
4098    
4099     my $insert_to_foster = sub {
4100     my $child = shift;
4101     if ({
4102     table => 1, tbody => 1, tfoot => 1,
4103     thead => 1, tr => 1,
4104 wakaba 1.3 }->{$self->{open_elements}->[-1]->[1]}) {
4105 wakaba 1.1 # MUST
4106     my $foster_parent_element;
4107     my $next_sibling;
4108 wakaba 1.3 OE: for (reverse 0..$#{$self->{open_elements}}) {
4109     if ($self->{open_elements}->[$_]->[1] eq 'table') {
4110     my $parent = $self->{open_elements}->[$_]->[0]->parent_node;
4111 wakaba 1.1 if (defined $parent and $parent->node_type == 1) {
4112 wakaba 1.79
4113 wakaba 1.1 $foster_parent_element = $parent;
4114 wakaba 1.3 $next_sibling = $self->{open_elements}->[$_]->[0];
4115 wakaba 1.1 } else {
4116 wakaba 1.79
4117 wakaba 1.1 $foster_parent_element
4118 wakaba 1.3 = $self->{open_elements}->[$_ - 1]->[0];
4119 wakaba 1.1 }
4120     last OE;
4121     }
4122     } # OE
4123 wakaba 1.3 $foster_parent_element = $self->{open_elements}->[0]->[0]
4124 wakaba 1.1 unless defined $foster_parent_element;
4125     $foster_parent_element->insert_before
4126     ($child, $next_sibling);
4127     } else {
4128 wakaba 1.79
4129 wakaba 1.3 $self->{open_elements}->[-1]->[0]->append_child ($child);
4130 wakaba 1.1 }
4131     }; # $insert_to_foster
4132    
4133 wakaba 1.54 my $insert;
4134    
4135     B: {
4136 wakaba 1.57 if ($token->{type} == DOCTYPE_TOKEN) {
4137 wakaba 1.79
4138 wakaba 1.54 $self->{parse_error}-> (type => 'DOCTYPE in the middle');
4139     ## Ignore the token
4140     ## Stay in the phase
4141     $token = $self->_get_next_token;
4142     redo B;
4143 wakaba 1.57 } elsif ($token->{type} == END_OF_FILE_TOKEN) {
4144 wakaba 1.58 if ($self->{insertion_mode} & AFTER_HTML_IMS) {
4145 wakaba 1.79
4146 wakaba 1.54 #
4147     } else {
4148     ## Generate implied end tags
4149 wakaba 1.86 while ({
4150     dd => 1, dt => 1, li => 1, p => 1,
4151     }->{$self->{open_elements}->[-1]->[1]}) {
4152 wakaba 1.79
4153 wakaba 1.86 pop @{$self->{open_elements}};
4154 wakaba 1.54 }
4155 wakaba 1.1
4156 wakaba 1.54 if (@{$self->{open_elements}} > 2 or
4157     (@{$self->{open_elements}} == 2 and $self->{open_elements}->[1]->[1] ne 'body')) {
4158 wakaba 1.79
4159 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
4160     } elsif (defined $self->{inner_html_node} and
4161     @{$self->{open_elements}} > 1 and
4162     $self->{open_elements}->[1]->[1] ne 'body') {
4163 wakaba 1.81 ## ISSUE: This case is never reached.
4164 wakaba 1.79
4165 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
4166 wakaba 1.79 } else {
4167    
4168 wakaba 1.54 }
4169    
4170     ## ISSUE: There is an issue in the spec.
4171     }
4172    
4173     ## Stop parsing
4174     last B;
4175 wakaba 1.57 } elsif ($token->{type} == START_TAG_TOKEN and
4176 wakaba 1.54 $token->{tag_name} eq 'html') {
4177 wakaba 1.56 if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4178 wakaba 1.79
4179 wakaba 1.54 $self->{parse_error}-> (type => 'after html:html');
4180 wakaba 1.56 $self->{insertion_mode} = AFTER_BODY_IM;
4181     } elsif ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
4182 wakaba 1.79
4183 wakaba 1.54 $self->{parse_error}-> (type => 'after html:html');
4184 wakaba 1.56 $self->{insertion_mode} = AFTER_FRAMESET_IM;
4185 wakaba 1.79 } else {
4186    
4187 wakaba 1.54 }
4188    
4189 wakaba 1.84
4190     $self->{parse_error}-> (type => 'not first start tag');
4191 wakaba 1.54 my $top_el = $self->{open_elements}->[0]->[0];
4192     for my $attr_name (keys %{$token->{attributes}}) {
4193     unless ($top_el->has_attribute_ns (undef, $attr_name)) {
4194 wakaba 1.79
4195 wakaba 1.54 $top_el->set_attribute_ns
4196     (undef, [undef, $attr_name],
4197     $token->{attributes}->{$attr_name}->{value});
4198     }
4199     }
4200     $token = $self->_get_next_token;
4201     redo B;
4202 wakaba 1.57 } elsif ($token->{type} == COMMENT_TOKEN) {
4203 wakaba 1.54 my $comment = $self->{document}->create_comment ($token->{data});
4204 wakaba 1.58 if ($self->{insertion_mode} & AFTER_HTML_IMS) {
4205 wakaba 1.79
4206 wakaba 1.54 $self->{document}->append_child ($comment);
4207 wakaba 1.56 } elsif ($self->{insertion_mode} == AFTER_BODY_IM) {
4208 wakaba 1.79
4209 wakaba 1.54 $self->{open_elements}->[0]->[0]->append_child ($comment);
4210     } else {
4211 wakaba 1.79
4212 wakaba 1.54 $self->{open_elements}->[-1]->[0]->append_child ($comment);
4213     }
4214     $token = $self->_get_next_token;
4215     redo B;
4216 wakaba 1.58 } elsif ($self->{insertion_mode} & HEAD_IMS) {
4217 wakaba 1.57 if ($token->{type} == CHARACTER_TOKEN) {
4218 wakaba 1.54 if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
4219     $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
4220     unless (length $token->{data}) {
4221 wakaba 1.79
4222 wakaba 1.54 $token = $self->_get_next_token;
4223     redo B;
4224     }
4225     }
4226    
4227 wakaba 1.56 if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
4228 wakaba 1.79
4229 wakaba 1.54 ## As if <head>
4230    
4231     $self->{head_element} = $self->{document}->create_element_ns
4232     (q<http://www.w3.org/1999/xhtml>, [undef, 'head']);
4233    
4234     $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
4235     push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
4236    
4237     ## Reprocess in the "in head" insertion mode...
4238     pop @{$self->{open_elements}};
4239    
4240     ## Reprocess in the "after head" insertion mode...
4241 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
4242 wakaba 1.79
4243 wakaba 1.54 ## As if </noscript>
4244     pop @{$self->{open_elements}};
4245     $self->{parse_error}-> (type => 'in noscript:#character');
4246    
4247     ## Reprocess in the "in head" insertion mode...
4248     ## As if </head>
4249     pop @{$self->{open_elements}};
4250    
4251     ## Reprocess in the "after head" insertion mode...
4252 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
4253 wakaba 1.79
4254 wakaba 1.54 pop @{$self->{open_elements}};
4255    
4256     ## Reprocess in the "after head" insertion mode...
4257 wakaba 1.79 } else {
4258    
4259 wakaba 1.54 }
4260    
4261     ## "after head" insertion mode
4262     ## As if <body>
4263    
4264     {
4265     my $el;
4266    
4267     $el = $self->{document}->create_element_ns
4268     (q<http://www.w3.org/1999/xhtml>, [undef, 'body']);
4269    
4270     $self->{open_elements}->[-1]->[0]->append_child ($el);
4271     push @{$self->{open_elements}}, [$el, 'body'];
4272     }
4273    
4274 wakaba 1.56 $self->{insertion_mode} = IN_BODY_IM;
4275 wakaba 1.54 ## reprocess
4276     redo B;
4277 wakaba 1.57 } elsif ($token->{type} == START_TAG_TOKEN) {
4278 wakaba 1.54 if ($token->{tag_name} eq 'head') {
4279 wakaba 1.56 if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
4280 wakaba 1.54
4281 wakaba 1.79
4282 wakaba 1.54 $self->{head_element} = $self->{document}->create_element_ns
4283     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
4284    
4285     for my $attr_name (keys %{ $token->{attributes}}) {
4286     $self->{head_element}->set_attribute_ns (undef, [undef, $attr_name],
4287     $token->{attributes} ->{$attr_name}->{value});
4288     }
4289    
4290     $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
4291     push @{$self->{open_elements}}, [$self->{head_element}, $token->{tag_name}];
4292 wakaba 1.56 $self->{insertion_mode} = IN_HEAD_IM;
4293 wakaba 1.54 $token = $self->_get_next_token;
4294     redo B;
4295 wakaba 1.56 } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
4296 wakaba 1.79
4297 wakaba 1.56 #
4298     } else {
4299 wakaba 1.79
4300 wakaba 1.54 $self->{parse_error}-> (type => 'in head:head'); # or in head noscript
4301     ## Ignore the token
4302     $token = $self->_get_next_token;
4303     redo B;
4304     }
4305 wakaba 1.56 } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {
4306 wakaba 1.79
4307 wakaba 1.54 ## As if <head>
4308    
4309     $self->{head_element} = $self->{document}->create_element_ns
4310     (q<http://www.w3.org/1999/xhtml>, [undef, 'head']);
4311    
4312     $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
4313     push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
4314    
4315 wakaba 1.56 $self->{insertion_mode} = IN_HEAD_IM;
4316 wakaba 1.54 ## Reprocess in the "in head" insertion mode...
4317 wakaba 1.79 } else {
4318    
4319 wakaba 1.54 }
4320    
4321     if ($token->{tag_name} eq 'base') {
4322 wakaba 1.56 if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
4323 wakaba 1.79
4324 wakaba 1.54 ## As if </noscript>
4325     pop @{$self->{open_elements}};
4326     $self->{parse_error}-> (type => 'in noscript:base');
4327    
4328 wakaba 1.56 $self->{insertion_mode} = IN_HEAD_IM;
4329 wakaba 1.54 ## Reprocess in the "in head" insertion mode...
4330 wakaba 1.79 } else {
4331    
4332 wakaba 1.54 }
4333    
4334     ## NOTE: There is a "as if in head" code clone.
4335 wakaba 1.56 if ($self->{insertion_mode} == AFTER_HEAD_IM) {
4336 wakaba 1.79
4337 wakaba 1.54 $self->{parse_error}-> (type => 'after head:'.$token->{tag_name});
4338     push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
4339 wakaba 1.79 } else {
4340    
4341 wakaba 1.54 }
4342    
4343     {
4344     my $el;
4345    
4346     $el = $self->{document}->create_element_ns
4347     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
4348    
4349     for my $attr_name (keys %{ $token->{attributes}}) {
4350     $el->set_attribute_ns (undef, [undef, $attr_name],
4351     $token->{attributes} ->{$attr_name}->{value});
4352     }
4353    
4354     $self->{open_elements}->[-1]->[0]->append_child ($el);
4355     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
4356     }
4357    
4358     pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
4359     pop @{$self->{open_elements}}
4360 wakaba 1.56 if $self->{insertion_mode} == AFTER_HEAD_IM;
4361 wakaba 1.54 $token = $self->_get_next_token;
4362     redo B;
4363     } elsif ($token->{tag_name} eq 'link') {
4364     ## NOTE: There is a "as if in head" code clone.
4365 wakaba 1.56 if ($self->{insertion_mode} == AFTER_HEAD_IM) {
4366 wakaba 1.79
4367 wakaba 1.54 $self->{parse_error}-> (type => 'after head:'.$token->{tag_name});
4368     push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
4369 wakaba 1.79 } else {
4370    
4371 wakaba 1.54 }
4372    
4373 wakaba 1.25 {
4374     my $el;
4375    
4376 wakaba 1.1 $el = $self->{document}->create_element_ns
4377     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
4378    
4379 wakaba 1.25 for my $attr_name (keys %{ $token->{attributes}}) {
4380 wakaba 1.1 $el->set_attribute_ns (undef, [undef, $attr_name],
4381 wakaba 1.25 $token->{attributes} ->{$attr_name}->{value});
4382 wakaba 1.1 }
4383    
4384 wakaba 1.54 $self->{open_elements}->[-1]->[0]->append_child ($el);
4385 wakaba 1.25 push @{$self->{open_elements}}, [$el, $token->{tag_name}];
4386     }
4387    
4388 wakaba 1.54 pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
4389     pop @{$self->{open_elements}}
4390 wakaba 1.56 if $self->{insertion_mode} == AFTER_HEAD_IM;
4391 wakaba 1.54 $token = $self->_get_next_token;
4392     redo B;
4393     } elsif ($token->{tag_name} eq 'meta') {
4394     ## NOTE: There is a "as if in head" code clone.
4395 wakaba 1.56 if ($self->{insertion_mode} == AFTER_HEAD_IM) {
4396 wakaba 1.79
4397 wakaba 1.54 $self->{parse_error}-> (type => 'after head:'.$token->{tag_name});
4398     push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
4399 wakaba 1.79 } else {
4400    
4401 wakaba 1.54 }
4402    
4403 wakaba 1.34 {
4404     my $el;
4405    
4406     $el = $self->{document}->create_element_ns
4407     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
4408    
4409     for my $attr_name (keys %{ $token->{attributes}}) {
4410     $el->set_attribute_ns (undef, [undef, $attr_name],
4411     $token->{attributes} ->{$attr_name}->{value});
4412     }
4413    
4414 wakaba 1.54 $self->{open_elements}->[-1]->[0]->append_child ($el);
4415 wakaba 1.34 push @{$self->{open_elements}}, [$el, $token->{tag_name}];
4416     }
4417    
4418 wakaba 1.68 my $meta_el = pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
4419 wakaba 1.34
4420 wakaba 1.54 unless ($self->{confident}) {
4421     if ($token->{attributes}->{charset}) { ## TODO: And if supported
4422 wakaba 1.79
4423 wakaba 1.65 $self->{change_encoding}
4424     ->($self, $token->{attributes}->{charset}->{value});
4425 wakaba 1.68
4426     $meta_el->[0]->get_attribute_node_ns (undef, 'charset')
4427     ->set_user_data (manakai_has_reference =>
4428     $token->{attributes}->{charset}
4429     ->{has_reference});
4430 wakaba 1.65 } elsif ($token->{attributes}->{content}) {
4431 wakaba 1.54 ## ISSUE: Algorithm name in the spec was incorrect so that not linked to the definition.
4432 wakaba 1.65 if ($token->{attributes}->{content}->{value}
4433 wakaba 1.71 =~ /\A[^;]*;[\x09-\x0D\x20]*[Cc][Hh][Aa][Rr][Ss][Ee][Tt]
4434     [\x09-\x0D\x20]*=
4435 wakaba 1.54 [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'|
4436     ([^"'\x09-\x0D\x20][^\x09-\x0D\x20]*))/x) {
4437 wakaba 1.79
4438 wakaba 1.65 $self->{change_encoding}
4439     ->($self, defined $1 ? $1 : defined $2 ? $2 : $3);
4440 wakaba 1.69 $meta_el->[0]->get_attribute_node_ns (undef, 'content')
4441     ->set_user_data (manakai_has_reference =>
4442     $token->{attributes}->{content}
4443     ->{has_reference});
4444 wakaba 1.79 } else {
4445    
4446 wakaba 1.65 }
4447 wakaba 1.54 }
4448 wakaba 1.68 } else {
4449     if ($token->{attributes}->{charset}) {
4450 wakaba 1.79
4451 wakaba 1.68 $meta_el->[0]->get_attribute_node_ns (undef, 'charset')
4452     ->set_user_data (manakai_has_reference =>
4453     $token->{attributes}->{charset}
4454     ->{has_reference});
4455     }
4456 wakaba 1.69 if ($token->{attributes}->{content}) {
4457 wakaba 1.79
4458 wakaba 1.69 $meta_el->[0]->get_attribute_node_ns (undef, 'content')
4459     ->set_user_data (manakai_has_reference =>
4460     $token->{attributes}->{content}
4461     ->{has_reference});
4462     }
4463 wakaba 1.54 }
4464 wakaba 1.34
4465 wakaba 1.54 pop @{$self->{open_elements}}
4466 wakaba 1.56 if $self->{insertion_mode} == AFTER_HEAD_IM;
4467 wakaba 1.54 $token = $self->_get_next_token;
4468     redo B;
4469     } elsif ($token->{tag_name} eq 'title') {
4470 wakaba 1.56 if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
4471 wakaba 1.79
4472 wakaba 1.54 ## As if </noscript>
4473     pop @{$self->{open_elements}};
4474     $self->{parse_error}-> (type => 'in noscript:title');
4475 wakaba 1.1
4476 wakaba 1.56 $self->{insertion_mode} = IN_HEAD_IM;
4477 wakaba 1.54 ## Reprocess in the "in head" insertion mode...
4478 wakaba 1.56 } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
4479 wakaba 1.79
4480 wakaba 1.54 $self->{parse_error}-> (type => 'after head:'.$token->{tag_name});
4481     push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
4482 wakaba 1.79 } else {
4483    
4484 wakaba 1.54 }
4485    
4486     ## NOTE: There is a "as if in head" code clone.
4487     my $parent = defined $self->{head_element} ? $self->{head_element}
4488     : $self->{open_elements}->[-1]->[0];
4489     $parse_rcdata->(RCDATA_CONTENT_MODEL,
4490     sub { $parent->append_child ($_[0]) });
4491     pop @{$self->{open_elements}}
4492 wakaba 1.56 if $self->{insertion_mode} == AFTER_HEAD_IM;
4493 wakaba 1.54 redo B;
4494     } elsif ($token->{tag_name} eq 'style') {
4495     ## NOTE: Or (scripting is enabled and tag_name eq 'noscript' and
4496 wakaba 1.56 ## insertion mode IN_HEAD_IM)
4497 wakaba 1.54 ## NOTE: There is a "as if in head" code clone.
4498 wakaba 1.56 if ($self->{insertion_mode} == AFTER_HEAD_IM) {
4499 wakaba 1.79
4500 wakaba 1.54 $self->{parse_error}-> (type => 'after head:'.$token->{tag_name});
4501     push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
4502 wakaba 1.79 } else {
4503    
4504 wakaba 1.54 }
4505     $parse_rcdata->(CDATA_CONTENT_MODEL, $insert_to_current);
4506     pop @{$self->{open_elements}}
4507 wakaba 1.56 if $self->{insertion_mode} == AFTER_HEAD_IM;
4508 wakaba 1.54 redo B;
4509     } elsif ($token->{tag_name} eq 'noscript') {
4510 wakaba 1.56 if ($self->{insertion_mode} == IN_HEAD_IM) {
4511 wakaba 1.79
4512 wakaba 1.54 ## NOTE: and scripting is disalbed
4513    
4514 wakaba 1.1 {
4515     my $el;
4516    
4517     $el = $self->{document}->create_element_ns
4518     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
4519    
4520     for my $attr_name (keys %{ $token->{attributes}}) {
4521     $el->set_attribute_ns (undef, [undef, $attr_name],
4522     $token->{attributes} ->{$attr_name}->{value});
4523     }
4524    
4525 wakaba 1.54 $self->{open_elements}->[-1]->[0]->append_child ($el);
4526 wakaba 1.3 push @{$self->{open_elements}}, [$el, $token->{tag_name}];
4527 wakaba 1.1 }
4528    
4529 wakaba 1.56 $self->{insertion_mode} = IN_HEAD_NOSCRIPT_IM;
4530 wakaba 1.54 $token = $self->_get_next_token;
4531     redo B;
4532 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
4533 wakaba 1.79
4534 wakaba 1.54 $self->{parse_error}-> (type => 'in noscript:noscript');
4535     ## Ignore the token
4536     $token = $self->_get_next_token;
4537     redo B;
4538     } else {
4539 wakaba 1.79
4540 wakaba 1.54 #
4541     }
4542     } elsif ($token->{tag_name} eq 'script') {
4543 wakaba 1.56 if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
4544 wakaba 1.79
4545 wakaba 1.54 ## As if </noscript>
4546     pop @{$self->{open_elements}};
4547     $self->{parse_error}-> (type => 'in noscript:script');
4548    
4549 wakaba 1.56 $self->{insertion_mode} = IN_HEAD_IM;
4550 wakaba 1.54 ## Reprocess in the "in head" insertion mode...
4551 wakaba 1.56 } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
4552 wakaba 1.79
4553 wakaba 1.54 $self->{parse_error}-> (type => 'after head:'.$token->{tag_name});
4554     push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
4555 wakaba 1.79 } else {
4556    
4557 wakaba 1.54 }
4558    
4559     ## NOTE: There is a "as if in head" code clone.
4560     $script_start_tag->($insert_to_current);
4561     pop @{$self->{open_elements}}
4562 wakaba 1.56 if $self->{insertion_mode} == AFTER_HEAD_IM;
4563 wakaba 1.54 redo B;
4564     } elsif ($token->{tag_name} eq 'body' or
4565     $token->{tag_name} eq 'frameset') {
4566 wakaba 1.56 if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
4567 wakaba 1.79
4568 wakaba 1.54 ## As if </noscript>
4569     pop @{$self->{open_elements}};
4570     $self->{parse_error}-> (type => 'in noscript:'.$token->{tag_name});
4571    
4572     ## Reprocess in the "in head" insertion mode...
4573     ## As if </head>
4574     pop @{$self->{open_elements}};
4575    
4576     ## Reprocess in the "after head" insertion mode...
4577 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
4578 wakaba 1.79
4579 wakaba 1.54 pop @{$self->{open_elements}};
4580    
4581     ## Reprocess in the "after head" insertion mode...
4582 wakaba 1.79 } else {
4583    
4584 wakaba 1.54 }
4585    
4586     ## "after head" insertion mode
4587    
4588 wakaba 1.1 {
4589     my $el;
4590    
4591     $el = $self->{document}->create_element_ns
4592     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
4593    
4594     for my $attr_name (keys %{ $token->{attributes}}) {
4595     $el->set_attribute_ns (undef, [undef, $attr_name],
4596     $token->{attributes} ->{$attr_name}->{value});
4597     }
4598    
4599 wakaba 1.54 $self->{open_elements}->[-1]->[0]->append_child ($el);
4600 wakaba 1.3 push @{$self->{open_elements}}, [$el, $token->{tag_name}];
4601 wakaba 1.1 }
4602    
4603 wakaba 1.56 if ($token->{tag_name} eq 'body') {
4604 wakaba 1.79
4605 wakaba 1.56 $self->{insertion_mode} = IN_BODY_IM;
4606     } elsif ($token->{tag_name} eq 'frameset') {
4607 wakaba 1.79
4608 wakaba 1.56 $self->{insertion_mode} = IN_FRAMESET_IM;
4609     } else {
4610     die "$0: tag name: $self->{tag_name}";
4611     }
4612 wakaba 1.54 $token = $self->_get_next_token;
4613     redo B;
4614     } else {
4615 wakaba 1.79
4616 wakaba 1.54 #
4617 wakaba 1.8 }
4618 wakaba 1.54
4619 wakaba 1.56 if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
4620 wakaba 1.79
4621 wakaba 1.54 ## As if </noscript>
4622     pop @{$self->{open_elements}};
4623     $self->{parse_error}-> (type => 'in noscript:/'.$token->{tag_name});
4624    
4625     ## Reprocess in the "in head" insertion mode...
4626     ## As if </head>
4627     pop @{$self->{open_elements}};
4628    
4629     ## Reprocess in the "after head" insertion mode...
4630 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
4631 wakaba 1.79
4632 wakaba 1.54 ## As if </head>
4633     pop @{$self->{open_elements}};
4634    
4635     ## Reprocess in the "after head" insertion mode...
4636 wakaba 1.79 } else {
4637    
4638 wakaba 1.54 }
4639    
4640     ## "after head" insertion mode
4641     ## As if <body>
4642    
4643 wakaba 1.1 {
4644     my $el;
4645    
4646     $el = $self->{document}->create_element_ns
4647 wakaba 1.54 (q<http://www.w3.org/1999/xhtml>, [undef, 'body']);
4648 wakaba 1.1
4649 wakaba 1.54 $self->{open_elements}->[-1]->[0]->append_child ($el);
4650     push @{$self->{open_elements}}, [$el, 'body'];
4651 wakaba 1.1 }
4652    
4653 wakaba 1.56 $self->{insertion_mode} = IN_BODY_IM;
4654 wakaba 1.54 ## reprocess
4655     redo B;
4656 wakaba 1.57 } elsif ($token->{type} == END_TAG_TOKEN) {
4657 wakaba 1.54 if ($token->{tag_name} eq 'head') {
4658 wakaba 1.56 if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
4659 wakaba 1.79
4660 wakaba 1.54 ## As if <head>
4661    
4662     $self->{head_element} = $self->{document}->create_element_ns
4663     (q<http://www.w3.org/1999/xhtml>, [undef, 'head']);
4664    
4665     $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
4666     push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
4667    
4668     ## Reprocess in the "in head" insertion mode...
4669     pop @{$self->{open_elements}};
4670 wakaba 1.56 $self->{insertion_mode} = AFTER_HEAD_IM;
4671 wakaba 1.54 $token = $self->_get_next_token;
4672     redo B;
4673 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
4674 wakaba 1.79
4675 wakaba 1.54 ## As if </noscript>
4676     pop @{$self->{open_elements}};
4677 wakaba 1.82 $self->{parse_error}-> (type => 'in noscript:/head');
4678 wakaba 1.54
4679     ## Reprocess in the "in head" insertion mode...
4680     pop @{$self->{open_elements}};
4681 wakaba 1.56 $self->{insertion_mode} = AFTER_HEAD_IM;
4682 wakaba 1.54 $token = $self->_get_next_token;
4683     redo B;
4684 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
4685 wakaba 1.79
4686 wakaba 1.54 pop @{$self->{open_elements}};
4687 wakaba 1.56 $self->{insertion_mode} = AFTER_HEAD_IM;
4688 wakaba 1.54 $token = $self->_get_next_token;
4689     redo B;
4690     } else {
4691 wakaba 1.79
4692 wakaba 1.54 #
4693     }
4694     } elsif ($token->{tag_name} eq 'noscript') {
4695 wakaba 1.56 if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
4696 wakaba 1.79
4697 wakaba 1.54 pop @{$self->{open_elements}};
4698 wakaba 1.56 $self->{insertion_mode} = IN_HEAD_IM;
4699 wakaba 1.54 $token = $self->_get_next_token;
4700     redo B;
4701 wakaba 1.56 } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {
4702 wakaba 1.79
4703 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:noscript');
4704     ## Ignore the token ## ISSUE: An issue in the spec.
4705     $token = $self->_get_next_token;
4706     redo B;
4707     } else {
4708 wakaba 1.79
4709 wakaba 1.54 #
4710     }
4711     } elsif ({
4712     body => 1, html => 1,
4713     }->{$token->{tag_name}}) {
4714 wakaba 1.56 if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
4715 wakaba 1.79
4716 wakaba 1.54 ## As if <head>
4717    
4718     $self->{head_element} = $self->{document}->create_element_ns
4719     (q<http://www.w3.org/1999/xhtml>, [undef, 'head']);
4720    
4721     $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
4722     push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
4723    
4724 wakaba 1.56 $self->{insertion_mode} = IN_HEAD_IM;
4725 wakaba 1.54 ## Reprocess in the "in head" insertion mode...
4726 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
4727 wakaba 1.79
4728 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
4729     ## Ignore the token
4730     $token = $self->_get_next_token;
4731     redo B;
4732 wakaba 1.79 } else {
4733    
4734 wakaba 1.54 }
4735    
4736     #
4737     } elsif ({
4738     p => 1, br => 1,
4739     }->{$token->{tag_name}}) {
4740 wakaba 1.56 if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
4741 wakaba 1.79
4742 wakaba 1.54 ## As if <head>
4743    
4744     $self->{head_element} = $self->{document}->create_element_ns
4745     (q<http://www.w3.org/1999/xhtml>, [undef, 'head']);
4746    
4747     $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
4748     push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
4749    
4750 wakaba 1.56 $self->{insertion_mode} = IN_HEAD_IM;
4751 wakaba 1.54 ## Reprocess in the "in head" insertion mode...
4752 wakaba 1.79 } else {
4753    
4754 wakaba 1.54 }
4755    
4756     #
4757     } else {
4758 wakaba 1.56 if ($self->{insertion_mode} == AFTER_HEAD_IM) {
4759 wakaba 1.79
4760 wakaba 1.56 #
4761     } else {
4762 wakaba 1.79
4763 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
4764     ## Ignore the token
4765     $token = $self->_get_next_token;
4766     redo B;
4767     }
4768     }
4769    
4770 wakaba 1.56 if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
4771 wakaba 1.79
4772 wakaba 1.54 ## As if </noscript>
4773     pop @{$self->{open_elements}};
4774     $self->{parse_error}-> (type => 'in noscript:/'.$token->{tag_name});
4775    
4776     ## Reprocess in the "in head" insertion mode...
4777     ## As if </head>
4778     pop @{$self->{open_elements}};
4779    
4780     ## Reprocess in the "after head" insertion mode...
4781 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
4782 wakaba 1.79
4783 wakaba 1.54 ## As if </head>
4784     pop @{$self->{open_elements}};
4785    
4786     ## Reprocess in the "after head" insertion mode...
4787 wakaba 1.56 } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {
4788 wakaba 1.82 ## ISSUE: This case cannot be reached?
4789 wakaba 1.79
4790 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
4791     ## Ignore the token ## ISSUE: An issue in the spec.
4792     $token = $self->_get_next_token;
4793     redo B;
4794 wakaba 1.79 } else {
4795    
4796 wakaba 1.8 }
4797 wakaba 1.54
4798     ## "after head" insertion mode
4799     ## As if <body>
4800    
4801 wakaba 1.1 {
4802     my $el;
4803    
4804     $el = $self->{document}->create_element_ns
4805 wakaba 1.54 (q<http://www.w3.org/1999/xhtml>, [undef, 'body']);
4806 wakaba 1.1
4807 wakaba 1.54 $self->{open_elements}->[-1]->[0]->append_child ($el);
4808     push @{$self->{open_elements}}, [$el, 'body'];
4809 wakaba 1.1 }
4810    
4811 wakaba 1.56 $self->{insertion_mode} = IN_BODY_IM;
4812 wakaba 1.54 ## reprocess
4813     redo B;
4814     } else {
4815     die "$0: $token->{type}: Unknown token type";
4816 wakaba 1.1 }
4817 wakaba 1.54
4818     ## ISSUE: An issue in the spec.
4819 wakaba 1.58 } elsif ($self->{insertion_mode} & BODY_IMS) {
4820 wakaba 1.57 if ($token->{type} == CHARACTER_TOKEN) {
4821 wakaba 1.79
4822 wakaba 1.54 ## NOTE: There is a code clone of "character in body".
4823     $reconstruct_active_formatting_elements->($insert_to_current);
4824    
4825     $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});
4826    
4827     $token = $self->_get_next_token;
4828     redo B;
4829 wakaba 1.57 } elsif ($token->{type} == START_TAG_TOKEN) {
4830 wakaba 1.54 if ({
4831     caption => 1, col => 1, colgroup => 1, tbody => 1,
4832     td => 1, tfoot => 1, th => 1, thead => 1, tr => 1,
4833     }->{$token->{tag_name}}) {
4834 wakaba 1.56 if ($self->{insertion_mode} == IN_CELL_IM) {
4835 wakaba 1.54 ## have an element in table scope
4836     my $tn;
4837     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4838     my $node = $self->{open_elements}->[$_];
4839     if ($node->[1] eq 'td' or $node->[1] eq 'th') {
4840 wakaba 1.79
4841 wakaba 1.54 $tn = $node->[1];
4842     last INSCOPE;
4843     } elsif ({
4844     table => 1, html => 1,
4845     }->{$node->[1]}) {
4846 wakaba 1.79
4847 wakaba 1.54 last INSCOPE;
4848     }
4849     } # INSCOPE
4850     unless (defined $tn) {
4851 wakaba 1.79
4852 wakaba 1.82 ## TODO: This error type is wrong.
4853 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
4854     ## Ignore the token
4855     $token = $self->_get_next_token;
4856     redo B;
4857     }
4858    
4859 wakaba 1.79
4860 wakaba 1.54 ## Close the cell
4861     unshift @{$self->{token}}, $token; # <?>
4862 wakaba 1.57 $token = {type => END_TAG_TOKEN, tag_name => $tn};
4863 wakaba 1.54 redo B;
4864 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_CAPTION_IM) {
4865 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:caption');
4866    
4867     ## As if </caption>
4868     ## have a table element in table scope
4869     my $i;
4870     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4871     my $node = $self->{open_elements}->[$_];
4872     if ($node->[1] eq 'caption') {
4873 wakaba 1.79
4874 wakaba 1.54 $i = $_;
4875     last INSCOPE;
4876     } elsif ({
4877     table => 1, html => 1,
4878     }->{$node->[1]}) {
4879 wakaba 1.79
4880 wakaba 1.54 last INSCOPE;
4881     }
4882     } # INSCOPE
4883     unless (defined $i) {
4884 wakaba 1.79
4885 wakaba 1.83 ## TODO: this type is wrong.
4886 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:caption');
4887     ## Ignore the token
4888     $token = $self->_get_next_token;
4889     redo B;
4890     }
4891    
4892     ## generate implied end tags
4893 wakaba 1.86 while ({
4894     dd => 1, dt => 1, li => 1, p => 1,
4895     }->{$self->{open_elements}->[-1]->[1]}) {
4896 wakaba 1.79
4897 wakaba 1.86 pop @{$self->{open_elements}};
4898 wakaba 1.54 }
4899    
4900     if ($self->{open_elements}->[-1]->[1] ne 'caption') {
4901 wakaba 1.79
4902 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
4903 wakaba 1.79 } else {
4904    
4905 wakaba 1.54 }
4906    
4907     splice @{$self->{open_elements}}, $i;
4908    
4909     $clear_up_to_marker->();
4910    
4911 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_IM;
4912 wakaba 1.54
4913     ## reprocess
4914     redo B;
4915     } else {
4916 wakaba 1.79
4917 wakaba 1.54 #
4918     }
4919     } else {
4920 wakaba 1.79
4921 wakaba 1.54 #
4922     }
4923 wakaba 1.57 } elsif ($token->{type} == END_TAG_TOKEN) {
4924 wakaba 1.54 if ($token->{tag_name} eq 'td' or $token->{tag_name} eq 'th') {
4925 wakaba 1.56 if ($self->{insertion_mode} == IN_CELL_IM) {
4926 wakaba 1.54 ## have an element in table scope
4927     my $i;
4928     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4929     my $node = $self->{open_elements}->[$_];
4930     if ($node->[1] eq $token->{tag_name}) {
4931 wakaba 1.79
4932 wakaba 1.54 $i = $_;
4933     last INSCOPE;
4934     } elsif ({
4935     table => 1, html => 1,
4936     }->{$node->[1]}) {
4937 wakaba 1.79
4938 wakaba 1.54 last INSCOPE;
4939     }
4940     } # INSCOPE
4941     unless (defined $i) {
4942 wakaba 1.79
4943 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
4944     ## Ignore the token
4945     $token = $self->_get_next_token;
4946     redo B;
4947     }
4948    
4949     ## generate implied end tags
4950 wakaba 1.86 while ({
4951     dd => 1, dt => 1, li => 1, p => 1,
4952     }->{$self->{open_elements}->[-1]->[1]}) {
4953 wakaba 1.79
4954 wakaba 1.86 pop @{$self->{open_elements}};
4955 wakaba 1.54 }
4956 wakaba 1.86
4957 wakaba 1.54 if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {
4958 wakaba 1.79
4959 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
4960 wakaba 1.79 } else {
4961    
4962 wakaba 1.54 }
4963    
4964     splice @{$self->{open_elements}}, $i;
4965    
4966     $clear_up_to_marker->();
4967    
4968 wakaba 1.56 $self->{insertion_mode} = IN_ROW_IM;
4969 wakaba 1.54
4970     $token = $self->_get_next_token;
4971     redo B;
4972 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_CAPTION_IM) {
4973 wakaba 1.79
4974 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
4975     ## Ignore the token
4976     $token = $self->_get_next_token;
4977     redo B;
4978     } else {
4979 wakaba 1.79
4980 wakaba 1.54 #
4981     }
4982     } elsif ($token->{tag_name} eq 'caption') {
4983 wakaba 1.56 if ($self->{insertion_mode} == IN_CAPTION_IM) {
4984 wakaba 1.54 ## have a table element in table scope
4985     my $i;
4986     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4987     my $node = $self->{open_elements}->[$_];
4988     if ($node->[1] eq $token->{tag_name}) {
4989 wakaba 1.79
4990 wakaba 1.54 $i = $_;
4991     last INSCOPE;
4992     } elsif ({
4993     table => 1, html => 1,
4994     }->{$node->[1]}) {
4995 wakaba 1.79
4996 wakaba 1.54 last INSCOPE;
4997     }
4998     } # INSCOPE
4999     unless (defined $i) {
5000 wakaba 1.79
5001 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
5002     ## Ignore the token
5003     $token = $self->_get_next_token;
5004     redo B;
5005     }
5006    
5007     ## generate implied end tags
5008 wakaba 1.86 while ({
5009     dd => 1, dt => 1, li => 1, p => 1,
5010     }->{$self->{open_elements}->[-1]->[1]}) {
5011 wakaba 1.79
5012 wakaba 1.86 pop @{$self->{open_elements}};
5013 wakaba 1.54 }
5014    
5015     if ($self->{open_elements}->[-1]->[1] ne 'caption') {
5016 wakaba 1.79
5017 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5018 wakaba 1.79 } else {
5019    
5020 wakaba 1.54 }
5021    
5022     splice @{$self->{open_elements}}, $i;
5023    
5024     $clear_up_to_marker->();
5025    
5026 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_IM;
5027 wakaba 1.54
5028     $token = $self->_get_next_token;
5029     redo B;
5030 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_CELL_IM) {
5031 wakaba 1.79
5032 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
5033     ## Ignore the token
5034     $token = $self->_get_next_token;
5035     redo B;
5036     } else {
5037 wakaba 1.79
5038 wakaba 1.54 #
5039 wakaba 1.1 }
5040 wakaba 1.54 } elsif ({
5041     table => 1, tbody => 1, tfoot => 1,
5042     thead => 1, tr => 1,
5043     }->{$token->{tag_name}} and
5044 wakaba 1.56 $self->{insertion_mode} == IN_CELL_IM) {
5045 wakaba 1.54 ## have an element in table scope
5046     my $i;
5047     my $tn;
5048     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5049     my $node = $self->{open_elements}->[$_];
5050     if ($node->[1] eq $token->{tag_name}) {
5051 wakaba 1.79
5052 wakaba 1.54 $i = $_;
5053     last INSCOPE;
5054     } elsif ($node->[1] eq 'td' or $node->[1] eq 'th') {
5055 wakaba 1.79
5056 wakaba 1.54 $tn = $node->[1];
5057     ## NOTE: There is exactly one |td| or |th| element
5058     ## in scope in the stack of open elements by definition.
5059     } elsif ({
5060     table => 1, html => 1,
5061     }->{$node->[1]}) {
5062 wakaba 1.79
5063 wakaba 1.54 last INSCOPE;
5064     }
5065     } # INSCOPE
5066     unless (defined $i) {
5067 wakaba 1.79
5068 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
5069     ## Ignore the token
5070     $token = $self->_get_next_token;
5071     redo B;
5072 wakaba 1.79 } else {
5073    
5074 wakaba 1.1 }
5075    
5076 wakaba 1.54 ## Close the cell
5077     unshift @{$self->{token}}, $token; # </?>
5078 wakaba 1.57 $token = {type => END_TAG_TOKEN, tag_name => $tn};
5079 wakaba 1.54 redo B;
5080     } elsif ($token->{tag_name} eq 'table' and
5081 wakaba 1.56 $self->{insertion_mode} == IN_CAPTION_IM) {
5082 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:caption');
5083 wakaba 1.31
5084 wakaba 1.54 ## As if </caption>
5085     ## have a table element in table scope
5086     my $i;
5087     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5088     my $node = $self->{open_elements}->[$_];
5089     if ($node->[1] eq 'caption') {
5090 wakaba 1.79
5091 wakaba 1.54 $i = $_;
5092     last INSCOPE;
5093     } elsif ({
5094     table => 1, html => 1,
5095     }->{$node->[1]}) {
5096 wakaba 1.79
5097 wakaba 1.54 last INSCOPE;
5098     }
5099     } # INSCOPE
5100     unless (defined $i) {
5101 wakaba 1.79
5102 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:caption');
5103     ## Ignore the token
5104     $token = $self->_get_next_token;
5105     redo B;
5106     }
5107    
5108     ## generate implied end tags
5109 wakaba 1.86 while ({
5110     dd => 1, dt => 1, li => 1, p => 1,
5111     }->{$self->{open_elements}->[-1]->[1]}) {
5112 wakaba 1.79
5113 wakaba 1.86 pop @{$self->{open_elements}};
5114 wakaba 1.54 }
5115 wakaba 1.20
5116 wakaba 1.54 if ($self->{open_elements}->[-1]->[1] ne 'caption') {
5117 wakaba 1.79
5118 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5119 wakaba 1.79 } else {
5120    
5121 wakaba 1.54 }
5122 wakaba 1.12
5123 wakaba 1.54 splice @{$self->{open_elements}}, $i;
5124 wakaba 1.31
5125 wakaba 1.54 $clear_up_to_marker->();
5126 wakaba 1.1
5127 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_IM;
5128 wakaba 1.3
5129 wakaba 1.54 ## reprocess
5130     redo B;
5131     } elsif ({
5132     body => 1, col => 1, colgroup => 1, html => 1,
5133     }->{$token->{tag_name}}) {
5134 wakaba 1.58 if ($self->{insertion_mode} & BODY_TABLE_IMS) {
5135 wakaba 1.79
5136 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
5137     ## Ignore the token
5138     $token = $self->_get_next_token;
5139     redo B;
5140     } else {
5141 wakaba 1.79
5142 wakaba 1.54 #
5143     }
5144     } elsif ({
5145     tbody => 1, tfoot => 1,
5146     thead => 1, tr => 1,
5147     }->{$token->{tag_name}} and
5148 wakaba 1.56 $self->{insertion_mode} == IN_CAPTION_IM) {
5149 wakaba 1.79
5150 wakaba 1.25 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
5151 wakaba 1.1 ## Ignore the token
5152     $token = $self->_get_next_token;
5153 wakaba 1.54 redo B;
5154     } else {
5155 wakaba 1.79
5156 wakaba 1.54 #
5157 wakaba 1.1 }
5158 wakaba 1.54 } else {
5159     die "$0: $token->{type}: Unknown token type";
5160 wakaba 1.1 }
5161    
5162 wakaba 1.54 $insert = $insert_to_current;
5163     #
5164 wakaba 1.58 } elsif ($self->{insertion_mode} & TABLE_IMS) {
5165 wakaba 1.60 if ($token->{type} == CHARACTER_TOKEN) {
5166 wakaba 1.54 if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
5167     $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
5168    
5169     unless (length $token->{data}) {
5170 wakaba 1.79
5171 wakaba 1.54 $token = $self->_get_next_token;
5172     redo B;
5173 wakaba 1.79 } else {
5174    
5175 wakaba 1.54 }
5176     }
5177 wakaba 1.1
5178 wakaba 1.54 $self->{parse_error}-> (type => 'in table:#character');
5179 wakaba 1.1
5180 wakaba 1.54 ## As if in body, but insert into foster parent element
5181     ## ISSUE: Spec says that "whenever a node would be inserted
5182     ## into the current node" while characters might not be
5183     ## result in a new Text node.
5184     $reconstruct_active_formatting_elements->($insert_to_foster);
5185    
5186     if ({
5187     table => 1, tbody => 1, tfoot => 1,
5188     thead => 1, tr => 1,
5189     }->{$self->{open_elements}->[-1]->[1]}) {
5190     # MUST
5191     my $foster_parent_element;
5192     my $next_sibling;
5193     my $prev_sibling;
5194     OE: for (reverse 0..$#{$self->{open_elements}}) {
5195     if ($self->{open_elements}->[$_]->[1] eq 'table') {
5196     my $parent = $self->{open_elements}->[$_]->[0]->parent_node;
5197     if (defined $parent and $parent->node_type == 1) {
5198 wakaba 1.79
5199 wakaba 1.54 $foster_parent_element = $parent;
5200     $next_sibling = $self->{open_elements}->[$_]->[0];
5201     $prev_sibling = $next_sibling->previous_sibling;
5202     } else {
5203 wakaba 1.79
5204 wakaba 1.54 $foster_parent_element = $self->{open_elements}->[$_ - 1]->[0];
5205     $prev_sibling = $foster_parent_element->last_child;
5206     }
5207     last OE;
5208     }
5209     } # OE
5210     $foster_parent_element = $self->{open_elements}->[0]->[0] and
5211     $prev_sibling = $foster_parent_element->last_child
5212     unless defined $foster_parent_element;
5213     if (defined $prev_sibling and
5214     $prev_sibling->node_type == 3) {
5215 wakaba 1.79
5216 wakaba 1.54 $prev_sibling->manakai_append_text ($token->{data});
5217     } else {
5218 wakaba 1.79
5219 wakaba 1.54 $foster_parent_element->insert_before
5220     ($self->{document}->create_text_node ($token->{data}),
5221     $next_sibling);
5222     }
5223     } else {
5224 wakaba 1.79
5225 wakaba 1.54 $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});
5226     }
5227    
5228 wakaba 1.52 $token = $self->_get_next_token;
5229 wakaba 1.1 redo B;
5230 wakaba 1.60 } elsif ($token->{type} == START_TAG_TOKEN) {
5231 wakaba 1.54 if ({
5232 wakaba 1.56 tr => ($self->{insertion_mode} != IN_ROW_IM),
5233 wakaba 1.54 th => 1, td => 1,
5234     }->{$token->{tag_name}}) {
5235 wakaba 1.56 if ($self->{insertion_mode} == IN_TABLE_IM) {
5236 wakaba 1.54 ## Clear back to table context
5237     while ($self->{open_elements}->[-1]->[1] ne 'table' and
5238     $self->{open_elements}->[-1]->[1] ne 'html') {
5239 wakaba 1.79
5240 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5241     pop @{$self->{open_elements}};
5242     }
5243    
5244    
5245     {
5246     my $el;
5247    
5248     $el = $self->{document}->create_element_ns
5249     (q<http://www.w3.org/1999/xhtml>, [undef, 'tbody']);
5250    
5251     $self->{open_elements}->[-1]->[0]->append_child ($el);
5252     push @{$self->{open_elements}}, [$el, 'tbody'];
5253     }
5254    
5255 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_BODY_IM;
5256 wakaba 1.54 ## reprocess in the "in table body" insertion mode...
5257     }
5258    
5259 wakaba 1.56 if ($self->{insertion_mode} == IN_TABLE_BODY_IM) {
5260 wakaba 1.54 unless ($token->{tag_name} eq 'tr') {
5261 wakaba 1.79
5262 wakaba 1.54 $self->{parse_error}-> (type => 'missing start tag:tr');
5263     }
5264    
5265     ## Clear back to table body context
5266     while (not {
5267     tbody => 1, tfoot => 1, thead => 1, html => 1,
5268     }->{$self->{open_elements}->[-1]->[1]}) {
5269 wakaba 1.79
5270 wakaba 1.83 ## ISSUE: Can this case be reached?
5271 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5272     pop @{$self->{open_elements}};
5273     }
5274    
5275 wakaba 1.56 $self->{insertion_mode} = IN_ROW_IM;
5276 wakaba 1.54 if ($token->{tag_name} eq 'tr') {
5277    
5278 wakaba 1.79
5279 wakaba 1.54 {
5280     my $el;
5281    
5282     $el = $self->{document}->create_element_ns
5283     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
5284    
5285     for my $attr_name (keys %{ $token->{attributes}}) {
5286     $el->set_attribute_ns (undef, [undef, $attr_name],
5287     $token->{attributes} ->{$attr_name}->{value});
5288 wakaba 1.1 }
5289 wakaba 1.54
5290     $self->{open_elements}->[-1]->[0]->append_child ($el);
5291     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
5292     }
5293    
5294     $token = $self->_get_next_token;
5295     redo B;
5296     } else {
5297    
5298 wakaba 1.79
5299 wakaba 1.54 {
5300     my $el;
5301    
5302     $el = $self->{document}->create_element_ns
5303     (q<http://www.w3.org/1999/xhtml>, [undef, 'tr']);
5304    
5305     $self->{open_elements}->[-1]->[0]->append_child ($el);
5306     push @{$self->{open_elements}}, [$el, 'tr'];
5307     }
5308    
5309     ## reprocess in the "in row" insertion mode
5310     }
5311 wakaba 1.79 } else {
5312    
5313 wakaba 1.54 }
5314 wakaba 1.52
5315 wakaba 1.54 ## Clear back to table row context
5316     while (not {
5317     tr => 1, html => 1,
5318     }->{$self->{open_elements}->[-1]->[1]}) {
5319 wakaba 1.79
5320 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5321     pop @{$self->{open_elements}};
5322     }
5323    
5324    
5325     {
5326     my $el;
5327    
5328     $el = $self->{document}->create_element_ns
5329     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
5330 wakaba 1.1
5331 wakaba 1.54 for my $attr_name (keys %{ $token->{attributes}}) {
5332     $el->set_attribute_ns (undef, [undef, $attr_name],
5333     $token->{attributes} ->{$attr_name}->{value});
5334     }
5335    
5336     $self->{open_elements}->[-1]->[0]->append_child ($el);
5337     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
5338     }
5339    
5340 wakaba 1.56 $self->{insertion_mode} = IN_CELL_IM;
5341 wakaba 1.54
5342     push @$active_formatting_elements, ['#marker', ''];
5343    
5344     $token = $self->_get_next_token;
5345     redo B;
5346     } elsif ({
5347     caption => 1, col => 1, colgroup => 1,
5348     tbody => 1, tfoot => 1, thead => 1,
5349 wakaba 1.56 tr => 1, # $self->{insertion_mode} == IN_ROW_IM
5350 wakaba 1.54 }->{$token->{tag_name}}) {
5351 wakaba 1.56 if ($self->{insertion_mode} == IN_ROW_IM) {
5352 wakaba 1.54 ## As if </tr>
5353     ## have an element in table scope
5354     my $i;
5355     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5356     my $node = $self->{open_elements}->[$_];
5357     if ($node->[1] eq 'tr') {
5358 wakaba 1.79
5359 wakaba 1.54 $i = $_;
5360     last INSCOPE;
5361     } elsif ({
5362 wakaba 1.83 html => 1,
5363    
5364     ## NOTE: This element does not appear here, maybe.
5365     table => 1,
5366 wakaba 1.54 }->{$node->[1]}) {
5367 wakaba 1.79
5368 wakaba 1.54 last INSCOPE;
5369     }
5370     } # INSCOPE
5371 wakaba 1.79 unless (defined $i) {
5372    
5373 wakaba 1.83 ## TODO: This type is wrong.
5374 wakaba 1.79 $self->{parse_error}-> (type => 'unmacthed end tag:'.$token->{tag_name});
5375 wakaba 1.54 ## Ignore the token
5376     $token = $self->_get_next_token;
5377     redo B;
5378     }
5379    
5380     ## Clear back to table row context
5381     while (not {
5382     tr => 1, html => 1,
5383     }->{$self->{open_elements}->[-1]->[1]}) {
5384 wakaba 1.79
5385 wakaba 1.83 ## ISSUE: Can this case be reached?
5386 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5387     pop @{$self->{open_elements}};
5388     }
5389    
5390     pop @{$self->{open_elements}}; # tr
5391 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_BODY_IM;
5392 wakaba 1.54 if ($token->{tag_name} eq 'tr') {
5393 wakaba 1.79
5394 wakaba 1.54 ## reprocess
5395     redo B;
5396     } else {
5397 wakaba 1.79
5398 wakaba 1.54 ## reprocess in the "in table body" insertion mode...
5399     }
5400     }
5401 wakaba 1.52
5402 wakaba 1.56 if ($self->{insertion_mode} == IN_TABLE_BODY_IM) {
5403 wakaba 1.54 ## have an element in table scope
5404     my $i;
5405     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5406     my $node = $self->{open_elements}->[$_];
5407     if ({
5408     tbody => 1, thead => 1, tfoot => 1,
5409     }->{$node->[1]}) {
5410 wakaba 1.79
5411 wakaba 1.54 $i = $_;
5412     last INSCOPE;
5413     } elsif ({
5414     table => 1, html => 1,
5415     }->{$node->[1]}) {
5416 wakaba 1.79
5417 wakaba 1.54 last INSCOPE;
5418     }
5419     } # INSCOPE
5420     unless (defined $i) {
5421 wakaba 1.79
5422 wakaba 1.83 ## TODO: This erorr type ios wrong.
5423     $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
5424 wakaba 1.54 ## Ignore the token
5425     $token = $self->_get_next_token;
5426     redo B;
5427     }
5428 wakaba 1.52
5429 wakaba 1.54 ## Clear back to table body context
5430     while (not {
5431     tbody => 1, tfoot => 1, thead => 1, html => 1,
5432     }->{$self->{open_elements}->[-1]->[1]}) {
5433 wakaba 1.79
5434 wakaba 1.83 ## ISSUE: Can this state be reached?
5435 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5436     pop @{$self->{open_elements}};
5437     }
5438    
5439     ## As if <{current node}>
5440     ## have an element in table scope
5441     ## true by definition
5442    
5443     ## Clear back to table body context
5444     ## nop by definition
5445    
5446     pop @{$self->{open_elements}};
5447 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_IM;
5448 wakaba 1.54 ## reprocess in "in table" insertion mode...
5449 wakaba 1.79 } else {
5450    
5451 wakaba 1.54 }
5452 wakaba 1.51
5453 wakaba 1.54 if ($token->{tag_name} eq 'col') {
5454     ## Clear back to table context
5455     while ($self->{open_elements}->[-1]->[1] ne 'table' and
5456     $self->{open_elements}->[-1]->[1] ne 'html') {
5457 wakaba 1.79
5458 wakaba 1.83 ## ISSUE: Can this state be reached?
5459 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5460     pop @{$self->{open_elements}};
5461     }
5462    
5463    
5464 wakaba 1.51 {
5465     my $el;
5466    
5467     $el = $self->{document}->create_element_ns
5468 wakaba 1.54 (q<http://www.w3.org/1999/xhtml>, [undef, 'colgroup']);
5469 wakaba 1.51
5470     $self->{open_elements}->[-1]->[0]->append_child ($el);
5471 wakaba 1.54 push @{$self->{open_elements}}, [$el, 'colgroup'];
5472 wakaba 1.51 }
5473    
5474 wakaba 1.56 $self->{insertion_mode} = IN_COLUMN_GROUP_IM;
5475 wakaba 1.54 ## reprocess
5476     redo B;
5477     } elsif ({
5478     caption => 1,
5479     colgroup => 1,
5480     tbody => 1, tfoot => 1, thead => 1,
5481     }->{$token->{tag_name}}) {
5482     ## Clear back to table context
5483     while ($self->{open_elements}->[-1]->[1] ne 'table' and
5484     $self->{open_elements}->[-1]->[1] ne 'html') {
5485 wakaba 1.79
5486 wakaba 1.83 ## ISSUE: Can this state be reached?
5487 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5488     pop @{$self->{open_elements}};
5489     }
5490    
5491     push @$active_formatting_elements, ['#marker', '']
5492     if $token->{tag_name} eq 'caption';
5493    
5494 wakaba 1.52
5495 wakaba 1.54 {
5496     my $el;
5497    
5498     $el = $self->{document}->create_element_ns
5499 wakaba 1.52 (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
5500    
5501 wakaba 1.54 for my $attr_name (keys %{ $token->{attributes}}) {
5502     $el->set_attribute_ns (undef, [undef, $attr_name],
5503     $token->{attributes} ->{$attr_name}->{value});
5504 wakaba 1.52 }
5505    
5506 wakaba 1.54 $self->{open_elements}->[-1]->[0]->append_child ($el);
5507     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
5508     }
5509    
5510     $self->{insertion_mode} = {
5511 wakaba 1.56 caption => IN_CAPTION_IM,
5512     colgroup => IN_COLUMN_GROUP_IM,
5513     tbody => IN_TABLE_BODY_IM,
5514     tfoot => IN_TABLE_BODY_IM,
5515     thead => IN_TABLE_BODY_IM,
5516 wakaba 1.54 }->{$token->{tag_name}};
5517 wakaba 1.52 $token = $self->_get_next_token;
5518     redo B;
5519 wakaba 1.54 } else {
5520     die "$0: in table: <>: $token->{tag_name}";
5521     }
5522     } elsif ($token->{tag_name} eq 'table') {
5523     $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5524    
5525     ## As if </table>
5526     ## have a table element in table scope
5527     my $i;
5528     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5529     my $node = $self->{open_elements}->[$_];
5530     if ($node->[1] eq 'table') {
5531 wakaba 1.79
5532 wakaba 1.54 $i = $_;
5533     last INSCOPE;
5534     } elsif ({
5535 wakaba 1.83 #table => 1,
5536     html => 1,
5537 wakaba 1.54 }->{$node->[1]}) {
5538 wakaba 1.79
5539 wakaba 1.54 last INSCOPE;
5540     }
5541     } # INSCOPE
5542     unless (defined $i) {
5543 wakaba 1.79
5544 wakaba 1.83 ## TODO: The following is wrong, maybe.
5545 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:table');
5546     ## Ignore tokens </table><table>
5547 wakaba 1.52 $token = $self->_get_next_token;
5548     redo B;
5549     }
5550    
5551 wakaba 1.54 ## generate implied end tags
5552 wakaba 1.86 while ({
5553     dd => 1, dt => 1, li => 1, p => 1,
5554     }->{$self->{open_elements}->[-1]->[1]}) {
5555 wakaba 1.79
5556 wakaba 1.86 pop @{$self->{open_elements}};
5557 wakaba 1.54 }
5558    
5559     if ($self->{open_elements}->[-1]->[1] ne 'table') {
5560 wakaba 1.79
5561 wakaba 1.83 ## ISSUE: Can this case be reached?
5562 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5563 wakaba 1.79 } else {
5564    
5565 wakaba 1.54 }
5566    
5567     splice @{$self->{open_elements}}, $i;
5568    
5569     $self->_reset_insertion_mode;
5570 wakaba 1.52
5571 wakaba 1.54 ## reprocess
5572     redo B;
5573 wakaba 1.60 } else {
5574 wakaba 1.79
5575 wakaba 1.60 $self->{parse_error}-> (type => 'in table:'.$token->{tag_name});
5576    
5577     $insert = $insert_to_foster;
5578     #
5579     }
5580     } elsif ($token->{type} == END_TAG_TOKEN) {
5581 wakaba 1.54 if ($token->{tag_name} eq 'tr' and
5582 wakaba 1.56 $self->{insertion_mode} == IN_ROW_IM) {
5583 wakaba 1.54 ## have an element in table scope
5584     my $i;
5585     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5586     my $node = $self->{open_elements}->[$_];
5587     if ($node->[1] eq $token->{tag_name}) {
5588 wakaba 1.79
5589 wakaba 1.54 $i = $_;
5590     last INSCOPE;
5591     } elsif ({
5592     table => 1, html => 1,
5593     }->{$node->[1]}) {
5594 wakaba 1.79
5595 wakaba 1.54 last INSCOPE;
5596     }
5597     } # INSCOPE
5598     unless (defined $i) {
5599 wakaba 1.79
5600 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
5601     ## Ignore the token
5602     $token = $self->_get_next_token;
5603     redo B;
5604 wakaba 1.79 } else {
5605    
5606 wakaba 1.54 }
5607    
5608     ## Clear back to table row context
5609     while (not {
5610     tr => 1, html => 1,
5611     }->{$self->{open_elements}->[-1]->[1]}) {
5612 wakaba 1.79
5613 wakaba 1.83 ## ISSUE: Can this state be reached?
5614 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5615     pop @{$self->{open_elements}};
5616     }
5617    
5618     pop @{$self->{open_elements}}; # tr
5619 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_BODY_IM;
5620 wakaba 1.54 $token = $self->_get_next_token;
5621     redo B;
5622     } elsif ($token->{tag_name} eq 'table') {
5623 wakaba 1.56 if ($self->{insertion_mode} == IN_ROW_IM) {
5624 wakaba 1.54 ## As if </tr>
5625     ## have an element in table scope
5626     my $i;
5627     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5628     my $node = $self->{open_elements}->[$_];
5629     if ($node->[1] eq 'tr') {
5630 wakaba 1.79
5631 wakaba 1.54 $i = $_;
5632     last INSCOPE;
5633     } elsif ({
5634     table => 1, html => 1,
5635     }->{$node->[1]}) {
5636 wakaba 1.79
5637 wakaba 1.54 last INSCOPE;
5638     }
5639     } # INSCOPE
5640     unless (defined $i) {
5641 wakaba 1.79
5642 wakaba 1.83 ## TODO: The following is wrong.
5643 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{type});
5644     ## Ignore the token
5645     $token = $self->_get_next_token;
5646     redo B;
5647     }
5648    
5649     ## Clear back to table row context
5650     while (not {
5651     tr => 1, html => 1,
5652     }->{$self->{open_elements}->[-1]->[1]}) {
5653 wakaba 1.79
5654 wakaba 1.83 ## ISSUE: Can this state be reached?
5655 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5656     pop @{$self->{open_elements}};
5657     }
5658    
5659     pop @{$self->{open_elements}}; # tr
5660 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_BODY_IM;
5661 wakaba 1.54 ## reprocess in the "in table body" insertion mode...
5662     }
5663    
5664 wakaba 1.56 if ($self->{insertion_mode} == IN_TABLE_BODY_IM) {
5665 wakaba 1.54 ## have an element in table scope
5666     my $i;
5667     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5668     my $node = $self->{open_elements}->[$_];
5669     if ({
5670     tbody => 1, thead => 1, tfoot => 1,
5671     }->{$node->[1]}) {
5672 wakaba 1.79
5673 wakaba 1.54 $i = $_;
5674     last INSCOPE;
5675     } elsif ({
5676     table => 1, html => 1,
5677     }->{$node->[1]}) {
5678 wakaba 1.79
5679 wakaba 1.54 last INSCOPE;
5680     }
5681     } # INSCOPE
5682     unless (defined $i) {
5683 wakaba 1.79
5684 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
5685     ## Ignore the token
5686     $token = $self->_get_next_token;
5687     redo B;
5688     }
5689    
5690     ## Clear back to table body context
5691     while (not {
5692     tbody => 1, tfoot => 1, thead => 1, html => 1,
5693     }->{$self->{open_elements}->[-1]->[1]}) {
5694 wakaba 1.79
5695 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5696     pop @{$self->{open_elements}};
5697     }
5698    
5699     ## As if <{current node}>
5700     ## have an element in table scope
5701     ## true by definition
5702    
5703     ## Clear back to table body context
5704     ## nop by definition
5705    
5706     pop @{$self->{open_elements}};
5707 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_IM;
5708 wakaba 1.54 ## reprocess in the "in table" insertion mode...
5709     }
5710 wakaba 1.52
5711 wakaba 1.54 ## have a table element in table scope
5712     my $i;
5713     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5714     my $node = $self->{open_elements}->[$_];
5715     if ($node->[1] eq $token->{tag_name}) {
5716 wakaba 1.79
5717 wakaba 1.54 $i = $_;
5718     last INSCOPE;
5719     } elsif ({
5720     table => 1, html => 1,
5721     }->{$node->[1]}) {
5722 wakaba 1.79
5723 wakaba 1.54 last INSCOPE;
5724     }
5725     } # INSCOPE
5726     unless (defined $i) {
5727 wakaba 1.79
5728 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
5729     ## Ignore the token
5730     $token = $self->_get_next_token;
5731     redo B;
5732 wakaba 1.51 }
5733    
5734 wakaba 1.54 ## generate implied end tags
5735 wakaba 1.86 while ({
5736     dd => 1, dt => 1, li => 1, p => 1,
5737     }->{$self->{open_elements}->[-1]->[1]}) {
5738 wakaba 1.79
5739 wakaba 1.83 ## ISSUE: Can this case be reached?
5740 wakaba 1.86 pop @{$self->{open_elements}};
5741 wakaba 1.51 }
5742    
5743 wakaba 1.54 if ($self->{open_elements}->[-1]->[1] ne 'table') {
5744 wakaba 1.79
5745 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5746 wakaba 1.79 } else {
5747    
5748     }
5749 wakaba 1.54
5750     splice @{$self->{open_elements}}, $i;
5751    
5752     $self->_reset_insertion_mode;
5753 wakaba 1.1
5754     $token = $self->_get_next_token;
5755 wakaba 1.25 redo B;
5756 wakaba 1.54 } elsif ({
5757     tbody => 1, tfoot => 1, thead => 1,
5758     }->{$token->{tag_name}} and
5759 wakaba 1.58 $self->{insertion_mode} & ROW_IMS) {
5760 wakaba 1.56 if ($self->{insertion_mode} == IN_ROW_IM) {
5761 wakaba 1.54 ## have an element in table scope
5762     my $i;
5763     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5764     my $node = $self->{open_elements}->[$_];
5765     if ($node->[1] eq $token->{tag_name}) {
5766 wakaba 1.79
5767 wakaba 1.54 $i = $_;
5768     last INSCOPE;
5769     } elsif ({
5770     table => 1, html => 1,
5771     }->{$node->[1]}) {
5772 wakaba 1.79
5773 wakaba 1.54 last INSCOPE;
5774     }
5775     } # INSCOPE
5776     unless (defined $i) {
5777 wakaba 1.79
5778 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
5779     ## Ignore the token
5780     $token = $self->_get_next_token;
5781     redo B;
5782     }
5783    
5784     ## As if </tr>
5785     ## have an element in table scope
5786     my $i;
5787     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5788     my $node = $self->{open_elements}->[$_];
5789     if ($node->[1] eq 'tr') {
5790 wakaba 1.79
5791 wakaba 1.54 $i = $_;
5792     last INSCOPE;
5793     } elsif ({
5794     table => 1, html => 1,
5795     }->{$node->[1]}) {
5796 wakaba 1.79
5797 wakaba 1.54 last INSCOPE;
5798     }
5799     } # INSCOPE
5800     unless (defined $i) {
5801 wakaba 1.79
5802 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:tr');
5803     ## Ignore the token
5804     $token = $self->_get_next_token;
5805     redo B;
5806     }
5807    
5808     ## Clear back to table row context
5809     while (not {
5810     tr => 1, html => 1,
5811     }->{$self->{open_elements}->[-1]->[1]}) {
5812 wakaba 1.79
5813 wakaba 1.83 ## ISSUE: Can this case be reached?
5814 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5815     pop @{$self->{open_elements}};
5816     }
5817    
5818     pop @{$self->{open_elements}}; # tr
5819 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_BODY_IM;
5820 wakaba 1.54 ## reprocess in the "in table body" insertion mode...
5821 wakaba 1.34 }
5822    
5823 wakaba 1.54 ## have an element in table scope
5824     my $i;
5825     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5826     my $node = $self->{open_elements}->[$_];
5827     if ($node->[1] eq $token->{tag_name}) {
5828 wakaba 1.79
5829 wakaba 1.54 $i = $_;
5830     last INSCOPE;
5831     } elsif ({
5832     table => 1, html => 1,
5833     }->{$node->[1]}) {
5834 wakaba 1.79
5835 wakaba 1.54 last INSCOPE;
5836 wakaba 1.34 }
5837 wakaba 1.54 } # INSCOPE
5838     unless (defined $i) {
5839 wakaba 1.79
5840 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
5841     ## Ignore the token
5842     $token = $self->_get_next_token;
5843     redo B;
5844 wakaba 1.34 }
5845    
5846 wakaba 1.54 ## Clear back to table body context
5847     while (not {
5848     tbody => 1, tfoot => 1, thead => 1, html => 1,
5849     }->{$self->{open_elements}->[-1]->[1]}) {
5850 wakaba 1.79
5851 wakaba 1.83 ## ISSUE: Can this case be reached?
5852 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5853 wakaba 1.51 pop @{$self->{open_elements}};
5854 wakaba 1.25 }
5855 wakaba 1.51
5856 wakaba 1.54 pop @{$self->{open_elements}};
5857 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_IM;
5858 wakaba 1.54 $token = $self->_get_next_token;
5859     redo B;
5860     } elsif ({
5861     body => 1, caption => 1, col => 1, colgroup => 1,
5862     html => 1, td => 1, th => 1,
5863 wakaba 1.56 tr => 1, # $self->{insertion_mode} == IN_ROW_IM
5864     tbody => 1, tfoot => 1, thead => 1, # $self->{insertion_mode} == IN_TABLE_IM
5865 wakaba 1.54 }->{$token->{tag_name}}) {
5866 wakaba 1.79
5867 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
5868     ## Ignore the token
5869     $token = $self->_get_next_token;
5870 wakaba 1.1 redo B;
5871 wakaba 1.60 } else {
5872 wakaba 1.79
5873 wakaba 1.60 $self->{parse_error}-> (type => 'in table:/'.$token->{tag_name});
5874 wakaba 1.54
5875 wakaba 1.60 $insert = $insert_to_foster;
5876     #
5877     }
5878     } else {
5879     die "$0: $token->{type}: Unknown token type";
5880     }
5881 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_COLUMN_GROUP_IM) {
5882 wakaba 1.57 if ($token->{type} == CHARACTER_TOKEN) {
5883 wakaba 1.54 if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
5884     $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
5885     unless (length $token->{data}) {
5886 wakaba 1.79
5887 wakaba 1.54 $token = $self->_get_next_token;
5888     redo B;
5889 wakaba 1.25 }
5890 wakaba 1.54 }
5891    
5892 wakaba 1.79
5893 wakaba 1.54 #
5894 wakaba 1.57 } elsif ($token->{type} == START_TAG_TOKEN) {
5895 wakaba 1.54 if ($token->{tag_name} eq 'col') {
5896    
5897 wakaba 1.79
5898 wakaba 1.25 {
5899     my $el;
5900    
5901 wakaba 1.1 $el = $self->{document}->create_element_ns
5902     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
5903    
5904 wakaba 1.25 for my $attr_name (keys %{ $token->{attributes}}) {
5905 wakaba 1.1 $el->set_attribute_ns (undef, [undef, $attr_name],
5906 wakaba 1.25 $token->{attributes} ->{$attr_name}->{value});
5907 wakaba 1.1 }
5908    
5909 wakaba 1.25 $self->{open_elements}->[-1]->[0]->append_child ($el);
5910     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
5911     }
5912    
5913 wakaba 1.54 pop @{$self->{open_elements}};
5914     $token = $self->_get_next_token;
5915     redo B;
5916     } else {
5917 wakaba 1.79
5918 wakaba 1.54 #
5919     }
5920 wakaba 1.57 } elsif ($token->{type} == END_TAG_TOKEN) {
5921 wakaba 1.54 if ($token->{tag_name} eq 'colgroup') {
5922     if ($self->{open_elements}->[-1]->[1] eq 'html') {
5923 wakaba 1.79
5924 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:colgroup');
5925 wakaba 1.25 ## Ignore the token
5926 wakaba 1.42 $token = $self->_get_next_token;
5927 wakaba 1.25 redo B;
5928 wakaba 1.24 } else {
5929 wakaba 1.79
5930 wakaba 1.54 pop @{$self->{open_elements}}; # colgroup
5931 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_IM;
5932 wakaba 1.54 $token = $self->_get_next_token;
5933     redo B;
5934 wakaba 1.25 }
5935 wakaba 1.54 } elsif ($token->{tag_name} eq 'col') {
5936 wakaba 1.79
5937 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:col');
5938     ## Ignore the token
5939     $token = $self->_get_next_token;
5940     redo B;
5941     } else {
5942 wakaba 1.79
5943 wakaba 1.54 #
5944     }
5945     } else {
5946 wakaba 1.83 die "$0: $token->{type}: Unknown token type";
5947 wakaba 1.54 }
5948 wakaba 1.51
5949 wakaba 1.54 ## As if </colgroup>
5950     if ($self->{open_elements}->[-1]->[1] eq 'html') {
5951 wakaba 1.79
5952 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:colgroup');
5953     ## Ignore the token
5954     $token = $self->_get_next_token;
5955     redo B;
5956     } else {
5957 wakaba 1.79
5958 wakaba 1.54 pop @{$self->{open_elements}}; # colgroup
5959 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_IM;
5960 wakaba 1.54 ## reprocess
5961     redo B;
5962     }
5963 wakaba 1.56 } elsif ($self->{insertion_mode} == IN_SELECT_IM) {
5964 wakaba 1.60 if ($token->{type} == CHARACTER_TOKEN) {
5965 wakaba 1.79
5966 wakaba 1.60 $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});
5967     $token = $self->_get_next_token;
5968     redo B;
5969     } elsif ($token->{type} == START_TAG_TOKEN) {
5970 wakaba 1.54 if ($token->{tag_name} eq 'option') {
5971     if ($self->{open_elements}->[-1]->[1] eq 'option') {
5972 wakaba 1.79
5973 wakaba 1.54 ## As if </option>
5974 wakaba 1.51 pop @{$self->{open_elements}};
5975 wakaba 1.79 } else {
5976    
5977 wakaba 1.51 }
5978    
5979 wakaba 1.1
5980     {
5981     my $el;
5982    
5983     $el = $self->{document}->create_element_ns
5984 wakaba 1.51 (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
5985 wakaba 1.1
5986     for my $attr_name (keys %{ $token->{attributes}}) {
5987     $el->set_attribute_ns (undef, [undef, $attr_name],
5988     $token->{attributes} ->{$attr_name}->{value});
5989     }
5990    
5991 wakaba 1.3 $self->{open_elements}->[-1]->[0]->append_child ($el);
5992 wakaba 1.51 push @{$self->{open_elements}}, [$el, $token->{tag_name}];
5993 wakaba 1.1 }
5994    
5995     $token = $self->_get_next_token;
5996     redo B;
5997 wakaba 1.54 } elsif ($token->{tag_name} eq 'optgroup') {
5998     if ($self->{open_elements}->[-1]->[1] eq 'option') {
5999 wakaba 1.79
6000 wakaba 1.54 ## As if </option>
6001 wakaba 1.51 pop @{$self->{open_elements}};
6002 wakaba 1.79 } else {
6003    
6004 wakaba 1.51 }
6005 wakaba 1.54
6006     if ($self->{open_elements}->[-1]->[1] eq 'optgroup') {
6007 wakaba 1.79
6008 wakaba 1.54 ## As if </optgroup>
6009 wakaba 1.51 pop @{$self->{open_elements}};
6010 wakaba 1.79 } else {
6011    
6012 wakaba 1.51 }
6013    
6014    
6015 wakaba 1.1 {
6016     my $el;
6017    
6018     $el = $self->{document}->create_element_ns
6019 wakaba 1.54 (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
6020 wakaba 1.1
6021 wakaba 1.54 for my $attr_name (keys %{ $token->{attributes}}) {
6022     $el->set_attribute_ns (undef, [undef, $attr_name],
6023     $token->{attributes} ->{$attr_name}->{value});
6024     }
6025    
6026 wakaba 1.3 $self->{open_elements}->[-1]->[0]->append_child ($el);
6027 wakaba 1.54 push @{$self->{open_elements}}, [$el, $token->{tag_name}];
6028 wakaba 1.1 }
6029    
6030 wakaba 1.54 $token = $self->_get_next_token;
6031     redo B;
6032     } elsif ($token->{tag_name} eq 'select') {
6033 wakaba 1.83 ## TODO: The type below is not good - <select> is replaced by </select>
6034 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:select');
6035     ## As if </select> instead
6036     ## have an element in table scope
6037     my $i;
6038     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
6039     my $node = $self->{open_elements}->[$_];
6040     if ($node->[1] eq $token->{tag_name}) {
6041 wakaba 1.79
6042 wakaba 1.54 $i = $_;
6043     last INSCOPE;
6044     } elsif ({
6045     table => 1, html => 1,
6046     }->{$node->[1]}) {
6047 wakaba 1.79
6048 wakaba 1.54 last INSCOPE;
6049 wakaba 1.44 }
6050 wakaba 1.54 } # INSCOPE
6051     unless (defined $i) {
6052 wakaba 1.79
6053 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:select');
6054     ## Ignore the token
6055     $token = $self->_get_next_token;
6056 wakaba 1.44 redo B;
6057     }
6058 wakaba 1.54
6059 wakaba 1.79
6060 wakaba 1.54 splice @{$self->{open_elements}}, $i;
6061    
6062     $self->_reset_insertion_mode;
6063    
6064     $token = $self->_get_next_token;
6065     redo B;
6066 wakaba 1.60 } else {
6067 wakaba 1.79
6068 wakaba 1.60 $self->{parse_error}-> (type => 'in select:'.$token->{tag_name});
6069     ## Ignore the token
6070     $token = $self->_get_next_token;
6071     redo B;
6072     }
6073     } elsif ($token->{type} == END_TAG_TOKEN) {
6074 wakaba 1.54 if ($token->{tag_name} eq 'optgroup') {
6075     if ($self->{open_elements}->[-1]->[1] eq 'option' and
6076     $self->{open_elements}->[-2]->[1] eq 'optgroup') {
6077 wakaba 1.79
6078 wakaba 1.54 ## As if </option>
6079     splice @{$self->{open_elements}}, -2;
6080     } elsif ($self->{open_elements}->[-1]->[1] eq 'optgroup') {
6081 wakaba 1.79
6082 wakaba 1.54 pop @{$self->{open_elements}};
6083     } else {
6084 wakaba 1.79
6085 wakaba 1.44 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
6086 wakaba 1.43 ## Ignore the token
6087 wakaba 1.54 }
6088     $token = $self->_get_next_token;
6089     redo B;
6090     } elsif ($token->{tag_name} eq 'option') {
6091     if ($self->{open_elements}->[-1]->[1] eq 'option') {
6092 wakaba 1.79
6093 wakaba 1.54 pop @{$self->{open_elements}};
6094 wakaba 1.44 } else {
6095 wakaba 1.79
6096 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
6097     ## Ignore the token
6098 wakaba 1.43 }
6099 wakaba 1.54 $token = $self->_get_next_token;
6100     redo B;
6101     } elsif ($token->{tag_name} eq 'select') {
6102     ## have an element in table scope
6103     my $i;
6104     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
6105     my $node = $self->{open_elements}->[$_];
6106     if ($node->[1] eq $token->{tag_name}) {
6107 wakaba 1.79
6108 wakaba 1.54 $i = $_;
6109     last INSCOPE;
6110     } elsif ({
6111     table => 1, html => 1,
6112     }->{$node->[1]}) {
6113 wakaba 1.79
6114 wakaba 1.54 last INSCOPE;
6115 wakaba 1.44 }
6116 wakaba 1.54 } # INSCOPE
6117     unless (defined $i) {
6118 wakaba 1.79
6119 wakaba 1.44 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
6120     ## Ignore the token
6121     $token = $self->_get_next_token;
6122 wakaba 1.43 redo B;
6123     }
6124 wakaba 1.54
6125 wakaba 1.79
6126 wakaba 1.54 splice @{$self->{open_elements}}, $i;
6127    
6128     $self->_reset_insertion_mode;
6129    
6130     $token = $self->_get_next_token;
6131     redo B;
6132 wakaba 1.44 } elsif ({
6133 wakaba 1.54 caption => 1, table => 1, tbody => 1,
6134     tfoot => 1, thead => 1, tr => 1, td => 1, th => 1,
6135     }->{$token->{tag_name}}) {
6136 wakaba 1.83 ## TODO: The following is wrong?
6137 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
6138    
6139 wakaba 1.44 ## have an element in table scope
6140 wakaba 1.43 my $i;
6141     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
6142     my $node = $self->{open_elements}->[$_];
6143     if ($node->[1] eq $token->{tag_name}) {
6144 wakaba 1.79
6145 wakaba 1.43 $i = $_;
6146     last INSCOPE;
6147     } elsif ({
6148     table => 1, html => 1,
6149     }->{$node->[1]}) {
6150 wakaba 1.79
6151 wakaba 1.43 last INSCOPE;
6152     }
6153     } # INSCOPE
6154     unless (defined $i) {
6155 wakaba 1.79
6156 wakaba 1.43 ## Ignore the token
6157     $token = $self->_get_next_token;
6158     redo B;
6159     }
6160 wakaba 1.54
6161     ## As if </select>
6162     ## have an element in table scope
6163     undef $i;
6164 wakaba 1.43 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
6165     my $node = $self->{open_elements}->[$_];
6166 wakaba 1.54 if ($node->[1] eq 'select') {
6167 wakaba 1.79
6168 wakaba 1.43 $i = $_;
6169     last INSCOPE;
6170     } elsif ({
6171     table => 1, html => 1,
6172     }->{$node->[1]}) {
6173 wakaba 1.83 ## ISSUE: Can this state be reached?
6174 wakaba 1.79
6175 wakaba 1.43 last INSCOPE;
6176     }
6177     } # INSCOPE
6178     unless (defined $i) {
6179 wakaba 1.79
6180 wakaba 1.83 ## TODO: The following error type is correct?
6181 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:select');
6182     ## Ignore the </select> token
6183     $token = $self->_get_next_token; ## TODO: ok?
6184 wakaba 1.43 redo B;
6185     }
6186 wakaba 1.54
6187 wakaba 1.79
6188 wakaba 1.54 splice @{$self->{open_elements}}, $i;
6189    
6190     $self->_reset_insertion_mode;
6191    
6192     ## reprocess
6193     redo B;
6194 wakaba 1.60 } else {
6195 wakaba 1.79
6196 wakaba 1.60 $self->{parse_error}-> (type => 'in select:/'.$token->{tag_name});
6197 wakaba 1.54 ## Ignore the token
6198     $token = $self->_get_next_token;
6199     redo B;
6200 wakaba 1.60 }
6201     } else {
6202     die "$0: $token->{type}: Unknown token type";
6203     }
6204 wakaba 1.58 } elsif ($self->{insertion_mode} & BODY_AFTER_IMS) {
6205 wakaba 1.57 if ($token->{type} == CHARACTER_TOKEN) {
6206 wakaba 1.54 if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
6207     my $data = $1;
6208     ## As if in body
6209     $reconstruct_active_formatting_elements->($insert_to_current);
6210    
6211     $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
6212    
6213     unless (length $token->{data}) {
6214 wakaba 1.79
6215 wakaba 1.54 $token = $self->_get_next_token;
6216     redo B;
6217     }
6218     }
6219    
6220 wakaba 1.56 if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
6221 wakaba 1.79
6222 wakaba 1.54 $self->{parse_error}-> (type => 'after html:#character');
6223    
6224 wakaba 1.85 ## Reprocess in the "after body" insertion mode.
6225 wakaba 1.79 } else {
6226    
6227 wakaba 1.54 }
6228    
6229     ## "after body" insertion mode
6230     $self->{parse_error}-> (type => 'after body:#character');
6231    
6232 wakaba 1.56 $self->{insertion_mode} = IN_BODY_IM;
6233 wakaba 1.54 ## reprocess
6234     redo B;
6235 wakaba 1.57 } elsif ($token->{type} == START_TAG_TOKEN) {
6236 wakaba 1.56 if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
6237 wakaba 1.79
6238 wakaba 1.54 $self->{parse_error}-> (type => 'after html:'.$token->{tag_name});
6239    
6240 wakaba 1.85 ## Reprocess in the "after body" insertion mode.
6241 wakaba 1.79 } else {
6242    
6243 wakaba 1.54 }
6244    
6245     ## "after body" insertion mode
6246     $self->{parse_error}-> (type => 'after body:'.$token->{tag_name});
6247    
6248 wakaba 1.56 $self->{insertion_mode} = IN_BODY_IM;
6249 wakaba 1.54 ## reprocess
6250     redo B;
6251 wakaba 1.57 } elsif ($token->{type} == END_TAG_TOKEN) {
6252 wakaba 1.56 if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
6253 wakaba 1.79
6254 wakaba 1.54 $self->{parse_error}-> (type => 'after html:/'.$token->{tag_name});
6255    
6256 wakaba 1.56 $self->{insertion_mode} = AFTER_BODY_IM;
6257 wakaba 1.85 ## Reprocess in the "after body" insertion mode.
6258 wakaba 1.79 } else {
6259    
6260 wakaba 1.54 }
6261    
6262     ## "after body" insertion mode
6263     if ($token->{tag_name} eq 'html') {
6264     if (defined $self->{inner_html_node}) {
6265 wakaba 1.79
6266 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:html');
6267     ## Ignore the token
6268     $token = $self->_get_next_token;
6269     redo B;
6270     } else {
6271 wakaba 1.79
6272 wakaba 1.56 $self->{insertion_mode} = AFTER_HTML_BODY_IM;
6273 wakaba 1.54 $token = $self->_get_next_token;
6274     redo B;
6275     }
6276     } else {
6277 wakaba 1.79
6278 wakaba 1.54 $self->{parse_error}-> (type => 'after body:/'.$token->{tag_name});
6279    
6280 wakaba 1.56 $self->{insertion_mode} = IN_BODY_IM;
6281 wakaba 1.54 ## reprocess
6282     redo B;
6283     }
6284     } else {
6285     die "$0: $token->{type}: Unknown token type";
6286     }
6287 wakaba 1.58 } elsif ($self->{insertion_mode} & FRAME_IMS) {
6288 wakaba 1.57 if ($token->{type} == CHARACTER_TOKEN) {
6289 wakaba 1.54 if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
6290     $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
6291    
6292     unless (length $token->{data}) {
6293 wakaba 1.79
6294 wakaba 1.54 $token = $self->_get_next_token;
6295     redo B;
6296     }
6297     }
6298    
6299     if ($token->{data} =~ s/^[^\x09\x0A\x0B\x0C\x20]+//) {
6300 wakaba 1.56 if ($self->{insertion_mode} == IN_FRAMESET_IM) {
6301 wakaba 1.79
6302 wakaba 1.54 $self->{parse_error}-> (type => 'in frameset:#character');
6303 wakaba 1.56 } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) {
6304 wakaba 1.79
6305 wakaba 1.54 $self->{parse_error}-> (type => 'after frameset:#character');
6306     } else { # "after html frameset"
6307 wakaba 1.79
6308 wakaba 1.54 $self->{parse_error}-> (type => 'after html:#character');
6309    
6310 wakaba 1.56 $self->{insertion_mode} = AFTER_FRAMESET_IM;
6311 wakaba 1.85 ## Reprocess in the "after frameset" insertion mode.
6312 wakaba 1.54 $self->{parse_error}-> (type => 'after frameset:#character');
6313     }
6314    
6315     ## Ignore the token.
6316     if (length $token->{data}) {
6317 wakaba 1.79
6318 wakaba 1.54 ## reprocess the rest of characters
6319     } else {
6320 wakaba 1.79
6321 wakaba 1.54 $token = $self->_get_next_token;
6322     }
6323     redo B;
6324     }
6325    
6326     die qq[$0: Character "$token->{data}"];
6327 wakaba 1.57 } elsif ($token->{type} == START_TAG_TOKEN) {
6328 wakaba 1.56 if ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
6329 wakaba 1.79
6330 wakaba 1.54 $self->{parse_error}-> (type => 'after html:'.$token->{tag_name});
6331    
6332 wakaba 1.79 $self->{insertion_mode} = AFTER_FRAMESET_IM;
6333 wakaba 1.85 ## Process in the "after frameset" insertion mode.
6334 wakaba 1.79 } else {
6335    
6336     }
6337    
6338 wakaba 1.54 if ($token->{tag_name} eq 'frameset' and
6339 wakaba 1.56 $self->{insertion_mode} == IN_FRAMESET_IM) {
6340 wakaba 1.54
6341 wakaba 1.79
6342 wakaba 1.54 {
6343     my $el;
6344    
6345     $el = $self->{document}->create_element_ns
6346     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
6347    
6348     for my $attr_name (keys %{ $token->{attributes}}) {
6349     $el->set_attribute_ns (undef, [undef, $attr_name],
6350     $token->{attributes} ->{$attr_name}->{value});
6351     }
6352    
6353     $self->{open_elements}->[-1]->[0]->append_child ($el);
6354     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
6355     }
6356    
6357     $token = $self->_get_next_token;
6358     redo B;
6359     } elsif ($token->{tag_name} eq 'frame' and
6360 wakaba 1.56 $self->{insertion_mode} == IN_FRAMESET_IM) {
6361 wakaba 1.54
6362 wakaba 1.79
6363 wakaba 1.54 {
6364     my $el;
6365    
6366     $el = $self->{document}->create_element_ns
6367     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
6368    
6369     for my $attr_name (keys %{ $token->{attributes}}) {
6370     $el->set_attribute_ns (undef, [undef, $attr_name],
6371     $token->{attributes} ->{$attr_name}->{value});
6372     }
6373    
6374     $self->{open_elements}->[-1]->[0]->append_child ($el);
6375     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
6376     }
6377    
6378     pop @{$self->{open_elements}};
6379     $token = $self->_get_next_token;
6380     redo B;
6381     } elsif ($token->{tag_name} eq 'noframes') {
6382 wakaba 1.79
6383 wakaba 1.54 ## NOTE: As if in body.
6384     $parse_rcdata->(CDATA_CONTENT_MODEL, $insert_to_current);
6385     redo B;
6386     } else {
6387 wakaba 1.56 if ($self->{insertion_mode} == IN_FRAMESET_IM) {
6388 wakaba 1.79
6389 wakaba 1.54 $self->{parse_error}-> (type => 'in frameset:'.$token->{tag_name});
6390     } else {
6391 wakaba 1.79
6392 wakaba 1.54 $self->{parse_error}-> (type => 'after frameset:'.$token->{tag_name});
6393     }
6394     ## Ignore the token
6395     $token = $self->_get_next_token;
6396     redo B;
6397     }
6398 wakaba 1.57 } elsif ($token->{type} == END_TAG_TOKEN) {
6399 wakaba 1.56 if ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
6400 wakaba 1.79
6401 wakaba 1.54 $self->{parse_error}-> (type => 'after html:/'.$token->{tag_name});
6402    
6403 wakaba 1.56 $self->{insertion_mode} = AFTER_FRAMESET_IM;
6404 wakaba 1.85 ## Process in the "after frameset" insertion mode.
6405 wakaba 1.79 } else {
6406    
6407 wakaba 1.54 }
6408    
6409     if ($token->{tag_name} eq 'frameset' and
6410 wakaba 1.56 $self->{insertion_mode} == IN_FRAMESET_IM) {
6411 wakaba 1.54 if ($self->{open_elements}->[-1]->[1] eq 'html' and
6412     @{$self->{open_elements}} == 1) {
6413 wakaba 1.79
6414 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
6415     ## Ignore the token
6416     $token = $self->_get_next_token;
6417     } else {
6418 wakaba 1.79
6419 wakaba 1.54 pop @{$self->{open_elements}};
6420     $token = $self->_get_next_token;
6421     }
6422 wakaba 1.43
6423 wakaba 1.54 if (not defined $self->{inner_html_node} and
6424     $self->{open_elements}->[-1]->[1] ne 'frameset') {
6425 wakaba 1.79
6426 wakaba 1.56 $self->{insertion_mode} = AFTER_FRAMESET_IM;
6427 wakaba 1.79 } else {
6428    
6429 wakaba 1.54 }
6430     redo B;
6431     } elsif ($token->{tag_name} eq 'html' and
6432 wakaba 1.56 $self->{insertion_mode} == AFTER_FRAMESET_IM) {
6433 wakaba 1.79
6434 wakaba 1.56 $self->{insertion_mode} = AFTER_HTML_FRAMESET_IM;
6435 wakaba 1.54 $token = $self->_get_next_token;
6436     redo B;
6437     } else {
6438 wakaba 1.56 if ($self->{insertion_mode} == IN_FRAMESET_IM) {
6439 wakaba 1.79
6440 wakaba 1.54 $self->{parse_error}-> (type => 'in frameset:/'.$token->{tag_name});
6441     } else {
6442 wakaba 1.79
6443 wakaba 1.54 $self->{parse_error}-> (type => 'after frameset:/'.$token->{tag_name});
6444     }
6445     ## Ignore the token
6446     $token = $self->_get_next_token;
6447     redo B;
6448     }
6449     } else {
6450     die "$0: $token->{type}: Unknown token type";
6451     }
6452 wakaba 1.43
6453 wakaba 1.54 ## ISSUE: An issue in spec here
6454     } else {
6455     die "$0: $self->{insertion_mode}: Unknown insertion mode";
6456     }
6457 wakaba 1.43
6458 wakaba 1.54 ## "in body" insertion mode
6459 wakaba 1.57 if ($token->{type} == START_TAG_TOKEN) {
6460 wakaba 1.54 if ($token->{tag_name} eq 'script') {
6461 wakaba 1.79
6462 wakaba 1.54 ## NOTE: This is an "as if in head" code clone
6463     $script_start_tag->($insert);
6464 wakaba 1.55 redo B;
6465 wakaba 1.54 } elsif ($token->{tag_name} eq 'style') {
6466 wakaba 1.79
6467 wakaba 1.54 ## NOTE: This is an "as if in head" code clone
6468     $parse_rcdata->(CDATA_CONTENT_MODEL, $insert);
6469 wakaba 1.55 redo B;
6470 wakaba 1.54 } elsif ({
6471     base => 1, link => 1,
6472     }->{$token->{tag_name}}) {
6473 wakaba 1.79
6474 wakaba 1.54 ## NOTE: This is an "as if in head" code clone, only "-t" differs
6475    
6476     {
6477     my $el;
6478    
6479     $el = $self->{document}->create_element_ns
6480     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
6481    
6482     for my $attr_name (keys %{ $token->{attributes}}) {
6483     $el->set_attribute_ns (undef, [undef, $attr_name],
6484     $token->{attributes} ->{$attr_name}->{value});
6485     }
6486    
6487     $insert->($el);
6488     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
6489     }
6490    
6491     pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
6492     $token = $self->_get_next_token;
6493 wakaba 1.55 redo B;
6494 wakaba 1.54 } elsif ($token->{tag_name} eq 'meta') {
6495     ## NOTE: This is an "as if in head" code clone, only "-t" differs
6496    
6497     {
6498     my $el;
6499    
6500     $el = $self->{document}->create_element_ns
6501     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
6502    
6503     for my $attr_name (keys %{ $token->{attributes}}) {
6504     $el->set_attribute_ns (undef, [undef, $attr_name],
6505     $token->{attributes} ->{$attr_name}->{value});
6506     }
6507    
6508     $insert->($el);
6509     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
6510     }
6511    
6512 wakaba 1.68 my $meta_el = pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
6513 wakaba 1.43
6514 wakaba 1.54 unless ($self->{confident}) {
6515     if ($token->{attributes}->{charset}) { ## TODO: And if supported
6516 wakaba 1.79
6517 wakaba 1.65 $self->{change_encoding}
6518     ->($self, $token->{attributes}->{charset}->{value});
6519 wakaba 1.68
6520     $meta_el->[0]->get_attribute_node_ns (undef, 'charset')
6521     ->set_user_data (manakai_has_reference =>
6522     $token->{attributes}->{charset}
6523     ->{has_reference});
6524 wakaba 1.65 } elsif ($token->{attributes}->{content}) {
6525 wakaba 1.54 ## ISSUE: Algorithm name in the spec was incorrect so that not linked to the definition.
6526 wakaba 1.65 if ($token->{attributes}->{content}->{value}
6527 wakaba 1.71 =~ /\A[^;]*;[\x09-\x0D\x20]*[Cc][Hh][Aa][Rr][Ss][Ee][Tt]
6528     [\x09-\x0D\x20]*=
6529 wakaba 1.54 [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'|
6530     ([^"'\x09-\x0D\x20][^\x09-\x0D\x20]*))/x) {
6531 wakaba 1.79
6532 wakaba 1.65 $self->{change_encoding}
6533     ->($self, defined $1 ? $1 : defined $2 ? $2 : $3);
6534 wakaba 1.69 $meta_el->[0]->get_attribute_node_ns (undef, 'content')
6535     ->set_user_data (manakai_has_reference =>
6536     $token->{attributes}->{content}
6537     ->{has_reference});
6538 wakaba 1.65 }
6539 wakaba 1.54 }
6540 wakaba 1.68 } else {
6541     if ($token->{attributes}->{charset}) {
6542 wakaba 1.79
6543 wakaba 1.68 $meta_el->[0]->get_attribute_node_ns (undef, 'charset')
6544     ->set_user_data (manakai_has_reference =>
6545     $token->{attributes}->{charset}
6546     ->{has_reference});
6547     }
6548 wakaba 1.69 if ($token->{attributes}->{content}) {
6549 wakaba 1.79
6550 wakaba 1.69 $meta_el->[0]->get_attribute_node_ns (undef, 'content')
6551     ->set_user_data (manakai_has_reference =>
6552     $token->{attributes}->{content}
6553     ->{has_reference});
6554     }
6555 wakaba 1.54 }
6556 wakaba 1.43
6557 wakaba 1.54 $token = $self->_get_next_token;
6558 wakaba 1.55 redo B;
6559 wakaba 1.54 } elsif ($token->{tag_name} eq 'title') {
6560 wakaba 1.79
6561 wakaba 1.54 $self->{parse_error}-> (type => 'in body:title');
6562     ## NOTE: This is an "as if in head" code clone
6563     $parse_rcdata->(RCDATA_CONTENT_MODEL, sub {
6564     if (defined $self->{head_element}) {
6565 wakaba 1.79
6566 wakaba 1.54 $self->{head_element}->append_child ($_[0]);
6567 wakaba 1.1 } else {
6568 wakaba 1.79
6569 wakaba 1.54 $insert->($_[0]);
6570 wakaba 1.1 }
6571 wakaba 1.54 });
6572 wakaba 1.55 redo B;
6573 wakaba 1.54 } elsif ($token->{tag_name} eq 'body') {
6574     $self->{parse_error}-> (type => 'in body:body');
6575 wakaba 1.1
6576 wakaba 1.54 if (@{$self->{open_elements}} == 1 or
6577     $self->{open_elements}->[1]->[1] ne 'body') {
6578 wakaba 1.79
6579 wakaba 1.54 ## Ignore the token
6580     } else {
6581     my $body_el = $self->{open_elements}->[1]->[0];
6582     for my $attr_name (keys %{$token->{attributes}}) {
6583     unless ($body_el->has_attribute_ns (undef, $attr_name)) {
6584 wakaba 1.79
6585 wakaba 1.54 $body_el->set_attribute_ns
6586     (undef, [undef, $attr_name],
6587     $token->{attributes}->{$attr_name}->{value});
6588 wakaba 1.1 }
6589 wakaba 1.54 }
6590     }
6591     $token = $self->_get_next_token;
6592 wakaba 1.55 redo B;
6593 wakaba 1.54 } elsif ({
6594     address => 1, blockquote => 1, center => 1, dir => 1,
6595 wakaba 1.85 div => 1, dl => 1, fieldset => 1,
6596     h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,
6597     listing => 1, menu => 1, ol => 1, p => 1, ul => 1,
6598 wakaba 1.54 pre => 1,
6599     }->{$token->{tag_name}}) {
6600     ## has a p element in scope
6601     INSCOPE: for (reverse @{$self->{open_elements}}) {
6602     if ($_->[1] eq 'p') {
6603 wakaba 1.79
6604 wakaba 1.54 unshift @{$self->{token}}, $token;
6605 wakaba 1.57 $token = {type => END_TAG_TOKEN, tag_name => 'p'};
6606 wakaba 1.55 redo B;
6607 wakaba 1.54 } elsif ({
6608     table => 1, caption => 1, td => 1, th => 1,
6609     button => 1, marquee => 1, object => 1, html => 1,
6610     }->{$_->[1]}) {
6611 wakaba 1.79
6612 wakaba 1.54 last INSCOPE;
6613     }
6614     } # INSCOPE
6615    
6616    
6617 wakaba 1.48 {
6618     my $el;
6619    
6620     $el = $self->{document}->create_element_ns
6621 wakaba 1.54 (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
6622 wakaba 1.48
6623 wakaba 1.54 for my $attr_name (keys %{ $token->{attributes}}) {
6624     $el->set_attribute_ns (undef, [undef, $attr_name],
6625     $token->{attributes} ->{$attr_name}->{value});
6626     }
6627    
6628     $insert->($el);
6629     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
6630 wakaba 1.48 }
6631    
6632 wakaba 1.54 if ($token->{tag_name} eq 'pre') {
6633     $token = $self->_get_next_token;
6634 wakaba 1.57 if ($token->{type} == CHARACTER_TOKEN) {
6635 wakaba 1.54 $token->{data} =~ s/^\x0A//;
6636     unless (length $token->{data}) {
6637 wakaba 1.79
6638 wakaba 1.54 $token = $self->_get_next_token;
6639 wakaba 1.79 } else {
6640    
6641 wakaba 1.54 }
6642 wakaba 1.79 } else {
6643    
6644 wakaba 1.54 }
6645     } else {
6646 wakaba 1.79
6647 wakaba 1.54 $token = $self->_get_next_token;
6648     }
6649 wakaba 1.55 redo B;
6650 wakaba 1.54 } elsif ($token->{tag_name} eq 'form') {
6651     if (defined $self->{form_element}) {
6652 wakaba 1.79
6653 wakaba 1.54 $self->{parse_error}-> (type => 'in form:form');
6654     ## Ignore the token
6655     $token = $self->_get_next_token;
6656 wakaba 1.55 redo B;
6657 wakaba 1.54 } else {
6658     ## has a p element in scope
6659     INSCOPE: for (reverse @{$self->{open_elements}}) {
6660     if ($_->[1] eq 'p') {
6661 wakaba 1.79
6662 wakaba 1.54 unshift @{$self->{token}}, $token;
6663 wakaba 1.57 $token = {type => END_TAG_TOKEN, tag_name => 'p'};
6664 wakaba 1.55 redo B;
6665 wakaba 1.54 } elsif ({
6666     table => 1, caption => 1, td => 1, th => 1,
6667     button => 1, marquee => 1, object => 1, html => 1,
6668     }->{$_->[1]}) {
6669 wakaba 1.79
6670 wakaba 1.54 last INSCOPE;
6671     }
6672     } # INSCOPE
6673    
6674    
6675 wakaba 1.1 {
6676     my $el;
6677    
6678     $el = $self->{document}->create_element_ns
6679     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
6680    
6681     for my $attr_name (keys %{ $token->{attributes}}) {
6682     $el->set_attribute_ns (undef, [undef, $attr_name],
6683     $token->{attributes} ->{$attr_name}->{value});
6684     }
6685    
6686 wakaba 1.54 $insert->($el);
6687 wakaba 1.3 push @{$self->{open_elements}}, [$el, $token->{tag_name}];
6688 wakaba 1.1 }
6689    
6690 wakaba 1.54 $self->{form_element} = $self->{open_elements}->[-1]->[0];
6691     $token = $self->_get_next_token;
6692 wakaba 1.55 redo B;
6693 wakaba 1.54 }
6694     } elsif ($token->{tag_name} eq 'li') {
6695     ## has a p element in scope
6696     INSCOPE: for (reverse @{$self->{open_elements}}) {
6697     if ($_->[1] eq 'p') {
6698 wakaba 1.79
6699 wakaba 1.54 unshift @{$self->{token}}, $token;
6700 wakaba 1.57 $token = {type => END_TAG_TOKEN, tag_name => 'p'};
6701 wakaba 1.55 redo B;
6702 wakaba 1.54 } elsif ({
6703     table => 1, caption => 1, td => 1, th => 1,
6704     button => 1, marquee => 1, object => 1, html => 1,
6705     }->{$_->[1]}) {
6706 wakaba 1.79
6707 wakaba 1.54 last INSCOPE;
6708     }
6709     } # INSCOPE
6710    
6711     ## Step 1
6712     my $i = -1;
6713     my $node = $self->{open_elements}->[$i];
6714     LI: {
6715     ## Step 2
6716     if ($node->[1] eq 'li') {
6717     if ($i != -1) {
6718 wakaba 1.79
6719 wakaba 1.54 $self->{parse_error}-> (type => 'end tag missing:'.
6720     $self->{open_elements}->[-1]->[1]);
6721 wakaba 1.79 } else {
6722    
6723 wakaba 1.54 }
6724     splice @{$self->{open_elements}}, $i;
6725     last LI;
6726 wakaba 1.79 } else {
6727    
6728 wakaba 1.54 }
6729    
6730     ## Step 3
6731     if (not $formatting_category->{$node->[1]} and
6732     #not $phrasing_category->{$node->[1]} and
6733     ($special_category->{$node->[1]} or
6734     $scoping_category->{$node->[1]}) and
6735     $node->[1] ne 'address' and $node->[1] ne 'div') {
6736 wakaba 1.79
6737 wakaba 1.54 last LI;
6738     }
6739    
6740 wakaba 1.79
6741 wakaba 1.54 ## Step 4
6742     $i--;
6743     $node = $self->{open_elements}->[$i];
6744     redo LI;
6745     } # LI
6746    
6747    
6748 wakaba 1.48 {
6749     my $el;
6750    
6751     $el = $self->{document}->create_element_ns
6752 wakaba 1.54 (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
6753 wakaba 1.48
6754 wakaba 1.54 for my $attr_name (keys %{ $token->{attributes}}) {
6755     $el->set_attribute_ns (undef, [undef, $attr_name],
6756     $token->{attributes} ->{$attr_name}->{value});
6757     }
6758    
6759     $insert->($el);
6760     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
6761 wakaba 1.48 }
6762    
6763 wakaba 1.54 $token = $self->_get_next_token;
6764 wakaba 1.55 redo B;
6765 wakaba 1.54 } elsif ($token->{tag_name} eq 'dd' or $token->{tag_name} eq 'dt') {
6766     ## has a p element in scope
6767     INSCOPE: for (reverse @{$self->{open_elements}}) {
6768     if ($_->[1] eq 'p') {
6769 wakaba 1.79
6770 wakaba 1.54 unshift @{$self->{token}}, $token;
6771 wakaba 1.57 $token = {type => END_TAG_TOKEN, tag_name => 'p'};
6772 wakaba 1.55 redo B;
6773 wakaba 1.54 } elsif ({
6774     table => 1, caption => 1, td => 1, th => 1,
6775     button => 1, marquee => 1, object => 1, html => 1,
6776     }->{$_->[1]}) {
6777 wakaba 1.79
6778 wakaba 1.54 last INSCOPE;
6779     }
6780     } # INSCOPE
6781    
6782     ## Step 1
6783     my $i = -1;
6784     my $node = $self->{open_elements}->[$i];
6785     LI: {
6786     ## Step 2
6787     if ($node->[1] eq 'dt' or $node->[1] eq 'dd') {
6788     if ($i != -1) {
6789 wakaba 1.79
6790 wakaba 1.54 $self->{parse_error}-> (type => 'end tag missing:'.
6791     $self->{open_elements}->[-1]->[1]);
6792 wakaba 1.79 } else {
6793    
6794 wakaba 1.54 }
6795     splice @{$self->{open_elements}}, $i;
6796     last LI;
6797 wakaba 1.79 } else {
6798    
6799 wakaba 1.54 }
6800    
6801     ## Step 3
6802     if (not $formatting_category->{$node->[1]} and
6803     #not $phrasing_category->{$node->[1]} and
6804     ($special_category->{$node->[1]} or
6805     $scoping_category->{$node->[1]}) and
6806     $node->[1] ne 'address' and $node->[1] ne 'div') {
6807 wakaba 1.79
6808 wakaba 1.54 last LI;
6809     }
6810    
6811 wakaba 1.79
6812 wakaba 1.54 ## Step 4
6813     $i--;
6814     $node = $self->{open_elements}->[$i];
6815     redo LI;
6816     } # LI
6817    
6818    
6819 wakaba 1.49 {
6820     my $el;
6821    
6822     $el = $self->{document}->create_element_ns
6823     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
6824    
6825     for my $attr_name (keys %{ $token->{attributes}}) {
6826     $el->set_attribute_ns (undef, [undef, $attr_name],
6827     $token->{attributes} ->{$attr_name}->{value});
6828     }
6829    
6830 wakaba 1.54 $insert->($el);
6831 wakaba 1.49 push @{$self->{open_elements}}, [$el, $token->{tag_name}];
6832     }
6833    
6834 wakaba 1.54 $token = $self->_get_next_token;
6835 wakaba 1.55 redo B;
6836 wakaba 1.54 } elsif ($token->{tag_name} eq 'plaintext') {
6837     ## has a p element in scope
6838     INSCOPE: for (reverse @{$self->{open_elements}}) {
6839     if ($_->[1] eq 'p') {
6840 wakaba 1.79
6841 wakaba 1.54 unshift @{$self->{token}}, $token;
6842 wakaba 1.57 $token = {type => END_TAG_TOKEN, tag_name => 'p'};
6843 wakaba 1.55 redo B;
6844 wakaba 1.54 } elsif ({
6845     table => 1, caption => 1, td => 1, th => 1,
6846     button => 1, marquee => 1, object => 1, html => 1,
6847     }->{$_->[1]}) {
6848 wakaba 1.79
6849 wakaba 1.54 last INSCOPE;
6850     }
6851     } # INSCOPE
6852    
6853    
6854 wakaba 1.1 {
6855     my $el;
6856    
6857     $el = $self->{document}->create_element_ns
6858 wakaba 1.54 (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
6859 wakaba 1.1
6860 wakaba 1.54 for my $attr_name (keys %{ $token->{attributes}}) {
6861     $el->set_attribute_ns (undef, [undef, $attr_name],
6862     $token->{attributes} ->{$attr_name}->{value});
6863     }
6864    
6865     $insert->($el);
6866     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
6867 wakaba 1.1 }
6868    
6869 wakaba 1.54
6870     $self->{content_model} = PLAINTEXT_CONTENT_MODEL;
6871    
6872     $token = $self->_get_next_token;
6873 wakaba 1.55 redo B;
6874 wakaba 1.54 } elsif ($token->{tag_name} eq 'a') {
6875     AFE: for my $i (reverse 0..$#$active_formatting_elements) {
6876     my $node = $active_formatting_elements->[$i];
6877     if ($node->[1] eq 'a') {
6878 wakaba 1.79
6879 wakaba 1.54 $self->{parse_error}-> (type => 'in a:a');
6880    
6881     unshift @{$self->{token}}, $token;
6882 wakaba 1.57 $token = {type => END_TAG_TOKEN, tag_name => 'a'};
6883 wakaba 1.54 $formatting_end_tag->($token->{tag_name});
6884    
6885     AFE2: for (reverse 0..$#$active_formatting_elements) {
6886     if ($active_formatting_elements->[$_]->[0] eq $node->[0]) {
6887 wakaba 1.79
6888 wakaba 1.54 splice @$active_formatting_elements, $_, 1;
6889     last AFE2;
6890 wakaba 1.49 }
6891 wakaba 1.54 } # AFE2
6892     OE: for (reverse 0..$#{$self->{open_elements}}) {
6893     if ($self->{open_elements}->[$_]->[0] eq $node->[0]) {
6894 wakaba 1.79
6895 wakaba 1.54 splice @{$self->{open_elements}}, $_, 1;
6896     last OE;
6897 wakaba 1.49 }
6898 wakaba 1.54 } # OE
6899     last AFE;
6900     } elsif ($node->[0] eq '#marker') {
6901 wakaba 1.79
6902 wakaba 1.54 last AFE;
6903     }
6904     } # AFE
6905    
6906     $reconstruct_active_formatting_elements->($insert_to_current);
6907 wakaba 1.49
6908 wakaba 1.54
6909     {
6910     my $el;
6911    
6912     $el = $self->{document}->create_element_ns
6913     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
6914    
6915     for my $attr_name (keys %{ $token->{attributes}}) {
6916     $el->set_attribute_ns (undef, [undef, $attr_name],
6917     $token->{attributes} ->{$attr_name}->{value});
6918     }
6919    
6920     $insert->($el);
6921     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
6922     }
6923    
6924     push @$active_formatting_elements, $self->{open_elements}->[-1];
6925 wakaba 1.48
6926 wakaba 1.54 $token = $self->_get_next_token;
6927 wakaba 1.55 redo B;
6928 wakaba 1.54 } elsif ({
6929     b => 1, big => 1, em => 1, font => 1, i => 1,
6930     s => 1, small => 1, strile => 1,
6931     strong => 1, tt => 1, u => 1,
6932     }->{$token->{tag_name}}) {
6933 wakaba 1.79
6934 wakaba 1.54 $reconstruct_active_formatting_elements->($insert_to_current);
6935    
6936    
6937     {
6938     my $el;
6939    
6940     $el = $self->{document}->create_element_ns
6941     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
6942    
6943     for my $attr_name (keys %{ $token->{attributes}}) {
6944     $el->set_attribute_ns (undef, [undef, $attr_name],
6945     $token->{attributes} ->{$attr_name}->{value});
6946     }
6947    
6948     $insert->($el);
6949     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
6950     }
6951    
6952     push @$active_formatting_elements, $self->{open_elements}->[-1];
6953    
6954     $token = $self->_get_next_token;
6955 wakaba 1.55 redo B;
6956 wakaba 1.54 } elsif ($token->{tag_name} eq 'nobr') {
6957     $reconstruct_active_formatting_elements->($insert_to_current);
6958 wakaba 1.1
6959 wakaba 1.54 ## has a |nobr| element in scope
6960     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
6961     my $node = $self->{open_elements}->[$_];
6962     if ($node->[1] eq 'nobr') {
6963 wakaba 1.79
6964 wakaba 1.60 $self->{parse_error}-> (type => 'in nobr:nobr');
6965 wakaba 1.54 unshift @{$self->{token}}, $token;
6966 wakaba 1.57 $token = {type => END_TAG_TOKEN, tag_name => 'nobr'};
6967 wakaba 1.55 redo B;
6968 wakaba 1.54 } elsif ({
6969     table => 1, caption => 1, td => 1, th => 1,
6970     button => 1, marquee => 1, object => 1, html => 1,
6971     }->{$node->[1]}) {
6972 wakaba 1.79
6973 wakaba 1.54 last INSCOPE;
6974     }
6975     } # INSCOPE
6976    
6977    
6978     {
6979     my $el;
6980    
6981     $el = $self->{document}->create_element_ns
6982     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
6983    
6984     for my $attr_name (keys %{ $token->{attributes}}) {
6985     $el->set_attribute_ns (undef, [undef, $attr_name],
6986     $token->{attributes} ->{$attr_name}->{value});
6987     }
6988    
6989     $insert->($el);
6990     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
6991     }
6992    
6993     push @$active_formatting_elements, $self->{open_elements}->[-1];
6994    
6995     $token = $self->_get_next_token;
6996 wakaba 1.55 redo B;
6997 wakaba 1.54 } elsif ($token->{tag_name} eq 'button') {
6998     ## has a button element in scope
6999     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
7000     my $node = $self->{open_elements}->[$_];
7001     if ($node->[1] eq 'button') {
7002 wakaba 1.79
7003 wakaba 1.54 $self->{parse_error}-> (type => 'in button:button');
7004     unshift @{$self->{token}}, $token;
7005 wakaba 1.57 $token = {type => END_TAG_TOKEN, tag_name => 'button'};
7006 wakaba 1.55 redo B;
7007 wakaba 1.54 } elsif ({
7008     table => 1, caption => 1, td => 1, th => 1,
7009     button => 1, marquee => 1, object => 1, html => 1,
7010     }->{$node->[1]}) {
7011 wakaba 1.79
7012 wakaba 1.54 last INSCOPE;
7013 wakaba 1.1 }
7014 wakaba 1.54 } # INSCOPE
7015    
7016     $reconstruct_active_formatting_elements->($insert_to_current);
7017    
7018    
7019     {
7020     my $el;
7021    
7022     $el = $self->{document}->create_element_ns
7023     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
7024    
7025     for my $attr_name (keys %{ $token->{attributes}}) {
7026     $el->set_attribute_ns (undef, [undef, $attr_name],
7027     $token->{attributes} ->{$attr_name}->{value});
7028     }
7029    
7030     $insert->($el);
7031     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
7032     }
7033    
7034 wakaba 1.86
7035     ## TODO: associate with $self->{form_element} if defined
7036    
7037 wakaba 1.54 push @$active_formatting_elements, ['#marker', ''];
7038 wakaba 1.1
7039 wakaba 1.54 $token = $self->_get_next_token;
7040 wakaba 1.55 redo B;
7041 wakaba 1.54 } elsif ($token->{tag_name} eq 'marquee' or
7042     $token->{tag_name} eq 'object') {
7043 wakaba 1.79
7044 wakaba 1.54 $reconstruct_active_formatting_elements->($insert_to_current);
7045    
7046    
7047 wakaba 1.1 {
7048     my $el;
7049    
7050     $el = $self->{document}->create_element_ns
7051     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
7052    
7053     for my $attr_name (keys %{ $token->{attributes}}) {
7054     $el->set_attribute_ns (undef, [undef, $attr_name],
7055     $token->{attributes} ->{$attr_name}->{value});
7056     }
7057    
7058 wakaba 1.54 $insert->($el);
7059 wakaba 1.3 push @{$self->{open_elements}}, [$el, $token->{tag_name}];
7060 wakaba 1.1 }
7061    
7062 wakaba 1.54 push @$active_formatting_elements, ['#marker', ''];
7063    
7064     $token = $self->_get_next_token;
7065 wakaba 1.55 redo B;
7066 wakaba 1.54 } elsif ($token->{tag_name} eq 'xmp') {
7067 wakaba 1.79
7068 wakaba 1.54 $reconstruct_active_formatting_elements->($insert_to_current);
7069     $parse_rcdata->(CDATA_CONTENT_MODEL, $insert);
7070 wakaba 1.55 redo B;
7071 wakaba 1.54 } elsif ($token->{tag_name} eq 'table') {
7072     ## has a p element in scope
7073     INSCOPE: for (reverse @{$self->{open_elements}}) {
7074     if ($_->[1] eq 'p') {
7075 wakaba 1.79
7076 wakaba 1.54 unshift @{$self->{token}}, $token;
7077 wakaba 1.57 $token = {type => END_TAG_TOKEN, tag_name => 'p'};
7078 wakaba 1.55 redo B;
7079 wakaba 1.54 } elsif ({
7080     table => 1, caption => 1, td => 1, th => 1,
7081     button => 1, marquee => 1, object => 1, html => 1,
7082     }->{$_->[1]}) {
7083 wakaba 1.79
7084 wakaba 1.54 last INSCOPE;
7085 wakaba 1.1 }
7086 wakaba 1.54 } # INSCOPE
7087    
7088    
7089     {
7090     my $el;
7091    
7092     $el = $self->{document}->create_element_ns
7093     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
7094    
7095     for my $attr_name (keys %{ $token->{attributes}}) {
7096     $el->set_attribute_ns (undef, [undef, $attr_name],
7097     $token->{attributes} ->{$attr_name}->{value});
7098     }
7099    
7100     $insert->($el);
7101     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
7102     }
7103    
7104    
7105 wakaba 1.56 $self->{insertion_mode} = IN_TABLE_IM;
7106 wakaba 1.54
7107     $token = $self->_get_next_token;
7108 wakaba 1.55 redo B;
7109 wakaba 1.54 } elsif ({
7110     area => 1, basefont => 1, bgsound => 1, br => 1,
7111     embed => 1, img => 1, param => 1, spacer => 1, wbr => 1,
7112     image => 1,
7113     }->{$token->{tag_name}}) {
7114     if ($token->{tag_name} eq 'image') {
7115 wakaba 1.79
7116 wakaba 1.54 $self->{parse_error}-> (type => 'image');
7117     $token->{tag_name} = 'img';
7118 wakaba 1.79 } else {
7119    
7120 wakaba 1.54 }
7121 wakaba 1.1
7122 wakaba 1.54 ## NOTE: There is an "as if <br>" code clone.
7123     $reconstruct_active_formatting_elements->($insert_to_current);
7124    
7125    
7126     {
7127     my $el;
7128    
7129     $el = $self->{document}->create_element_ns
7130     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
7131    
7132     for my $attr_name (keys %{ $token->{attributes}}) {
7133     $el->set_attribute_ns (undef, [undef, $attr_name],
7134     $token->{attributes} ->{$attr_name}->{value});
7135     }
7136    
7137     $insert->($el);
7138     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
7139     }
7140    
7141     pop @{$self->{open_elements}};
7142    
7143     $token = $self->_get_next_token;
7144 wakaba 1.55 redo B;
7145 wakaba 1.54 } elsif ($token->{tag_name} eq 'hr') {
7146     ## has a p element in scope
7147     INSCOPE: for (reverse @{$self->{open_elements}}) {
7148     if ($_->[1] eq 'p') {
7149 wakaba 1.79
7150 wakaba 1.54 unshift @{$self->{token}}, $token;
7151 wakaba 1.57 $token = {type => END_TAG_TOKEN, tag_name => 'p'};
7152 wakaba 1.55 redo B;
7153 wakaba 1.54 } elsif ({
7154     table => 1, caption => 1, td => 1, th => 1,
7155     button => 1, marquee => 1, object => 1, html => 1,
7156     }->{$_->[1]}) {
7157 wakaba 1.79
7158 wakaba 1.54 last INSCOPE;
7159 wakaba 1.1 }
7160 wakaba 1.54 } # INSCOPE
7161    
7162    
7163 wakaba 1.1 {
7164     my $el;
7165    
7166     $el = $self->{document}->create_element_ns
7167     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
7168    
7169     for my $attr_name (keys %{ $token->{attributes}}) {
7170     $el->set_attribute_ns (undef, [undef, $attr_name],
7171     $token->{attributes} ->{$attr_name}->{value});
7172     }
7173    
7174 wakaba 1.54 $insert->($el);
7175 wakaba 1.3 push @{$self->{open_elements}}, [$el, $token->{tag_name}];
7176 wakaba 1.1 }
7177    
7178 wakaba 1.54 pop @{$self->{open_elements}};
7179    
7180     $token = $self->_get_next_token;
7181 wakaba 1.55 redo B;
7182 wakaba 1.54 } elsif ($token->{tag_name} eq 'input') {
7183 wakaba 1.79
7184 wakaba 1.54 $reconstruct_active_formatting_elements->($insert_to_current);
7185    
7186    
7187 wakaba 1.1 {
7188     my $el;
7189    
7190     $el = $self->{document}->create_element_ns
7191     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
7192    
7193     for my $attr_name (keys %{ $token->{attributes}}) {
7194     $el->set_attribute_ns (undef, [undef, $attr_name],
7195     $token->{attributes} ->{$attr_name}->{value});
7196     }
7197    
7198 wakaba 1.54 $insert->($el);
7199 wakaba 1.3 push @{$self->{open_elements}}, [$el, $token->{tag_name}];
7200 wakaba 1.1 }
7201    
7202 wakaba 1.54 ## TODO: associate with $self->{form_element} if defined
7203     pop @{$self->{open_elements}};
7204    
7205     $token = $self->_get_next_token;
7206 wakaba 1.55 redo B;
7207 wakaba 1.54 } elsif ($token->{tag_name} eq 'isindex') {
7208     $self->{parse_error}-> (type => 'isindex');
7209    
7210     if (defined $self->{form_element}) {
7211 wakaba 1.79
7212 wakaba 1.54 ## Ignore the token
7213     $token = $self->_get_next_token;
7214 wakaba 1.55 redo B;
7215 wakaba 1.54 } else {
7216     my $at = $token->{attributes};
7217     my $form_attrs;
7218     $form_attrs->{action} = $at->{action} if $at->{action};
7219     my $prompt_attr = $at->{prompt};
7220     $at->{name} = {name => 'name', value => 'isindex'};
7221     delete $at->{action};
7222     delete $at->{prompt};
7223     my @tokens = (
7224 wakaba 1.57 {type => START_TAG_TOKEN, tag_name => 'form',
7225 wakaba 1.54 attributes => $form_attrs},
7226 wakaba 1.57 {type => START_TAG_TOKEN, tag_name => 'hr'},
7227     {type => START_TAG_TOKEN, tag_name => 'p'},
7228     {type => START_TAG_TOKEN, tag_name => 'label'},
7229 wakaba 1.54 );
7230     if ($prompt_attr) {
7231 wakaba 1.79
7232 wakaba 1.57 push @tokens, {type => CHARACTER_TOKEN, data => $prompt_attr->{value}};
7233 wakaba 1.1 } else {
7234 wakaba 1.79
7235 wakaba 1.57 push @tokens, {type => CHARACTER_TOKEN,
7236 wakaba 1.54 data => 'This is a searchable index. Insert your search keywords here: '}; # SHOULD
7237     ## TODO: make this configurable
7238 wakaba 1.1 }
7239 wakaba 1.54 push @tokens,
7240 wakaba 1.57 {type => START_TAG_TOKEN, tag_name => 'input', attributes => $at},
7241     #{type => CHARACTER_TOKEN, data => ''}, # SHOULD
7242     {type => END_TAG_TOKEN, tag_name => 'label'},
7243     {type => END_TAG_TOKEN, tag_name => 'p'},
7244     {type => START_TAG_TOKEN, tag_name => 'hr'},
7245     {type => END_TAG_TOKEN, tag_name => 'form'};
7246 wakaba 1.54 $token = shift @tokens;
7247     unshift @{$self->{token}}, (@tokens);
7248 wakaba 1.55 redo B;
7249 wakaba 1.54 }
7250     } elsif ($token->{tag_name} eq 'textarea') {
7251     my $tag_name = $token->{tag_name};
7252     my $el;
7253    
7254     $el = $self->{document}->create_element_ns
7255     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
7256    
7257     for my $attr_name (keys %{ $token->{attributes}}) {
7258     $el->set_attribute_ns (undef, [undef, $attr_name],
7259     $token->{attributes} ->{$attr_name}->{value});
7260     }
7261    
7262    
7263     ## TODO: $self->{form_element} if defined
7264     $self->{content_model} = RCDATA_CONTENT_MODEL;
7265     delete $self->{escape}; # MUST
7266    
7267     $insert->($el);
7268    
7269     my $text = '';
7270     $token = $self->_get_next_token;
7271 wakaba 1.57 if ($token->{type} == CHARACTER_TOKEN) {
7272 wakaba 1.54 $token->{data} =~ s/^\x0A//;
7273 wakaba 1.53 unless (length $token->{data}) {
7274 wakaba 1.79
7275 wakaba 1.53 $token = $self->_get_next_token;
7276 wakaba 1.79 } else {
7277    
7278 wakaba 1.53 }
7279 wakaba 1.79 } else {
7280    
7281 wakaba 1.53 }
7282 wakaba 1.57 while ($token->{type} == CHARACTER_TOKEN) {
7283 wakaba 1.79
7284 wakaba 1.54 $text .= $token->{data};
7285     $token = $self->_get_next_token;
7286     }
7287     if (length $text) {
7288 wakaba 1.79
7289 wakaba 1.54 $el->manakai_append_text ($text);
7290     }
7291    
7292     $self->{content_model} = PCDATA_CONTENT_MODEL;
7293    
7294 wakaba 1.57 if ($token->{type} == END_TAG_TOKEN and
7295 wakaba 1.54 $token->{tag_name} eq $tag_name) {
7296 wakaba 1.79
7297 wakaba 1.54 ## Ignore the token
7298     } else {
7299 wakaba 1.79
7300 wakaba 1.54 $self->{parse_error}-> (type => 'in RCDATA:#'.$token->{type});
7301     }
7302     $token = $self->_get_next_token;
7303 wakaba 1.55 redo B;
7304 wakaba 1.54 } elsif ({
7305     iframe => 1,
7306     noembed => 1,
7307     noframes => 1,
7308     noscript => 0, ## TODO: 1 if scripting is enabled
7309     }->{$token->{tag_name}}) {
7310 wakaba 1.79
7311 wakaba 1.60 ## NOTE: There is an "as if in body" code clone.
7312 wakaba 1.54 $parse_rcdata->(CDATA_CONTENT_MODEL, $insert);
7313 wakaba 1.55 redo B;
7314 wakaba 1.54 } elsif ($token->{tag_name} eq 'select') {
7315 wakaba 1.79
7316 wakaba 1.54 $reconstruct_active_formatting_elements->($insert_to_current);
7317    
7318    
7319     {
7320     my $el;
7321    
7322     $el = $self->{document}->create_element_ns
7323     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
7324    
7325     for my $attr_name (keys %{ $token->{attributes}}) {
7326     $el->set_attribute_ns (undef, [undef, $attr_name],
7327     $token->{attributes} ->{$attr_name}->{value});
7328     }
7329    
7330     $insert->($el);
7331     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
7332     }
7333    
7334 wakaba 1.86
7335     ## TODO: associate with $self->{form_element} if defined
7336 wakaba 1.54
7337 wakaba 1.56 $self->{insertion_mode} = IN_SELECT_IM;
7338 wakaba 1.54 $token = $self->_get_next_token;
7339 wakaba 1.55 redo B;
7340 wakaba 1.54 } elsif ({
7341     caption => 1, col => 1, colgroup => 1, frame => 1,
7342     frameset => 1, head => 1, option => 1, optgroup => 1,
7343     tbody => 1, td => 1, tfoot => 1, th => 1,
7344     thead => 1, tr => 1,
7345     }->{$token->{tag_name}}) {
7346 wakaba 1.79
7347 wakaba 1.54 $self->{parse_error}-> (type => 'in body:'.$token->{tag_name});
7348     ## Ignore the token
7349     $token = $self->_get_next_token;
7350 wakaba 1.55 redo B;
7351 wakaba 1.54
7352     ## ISSUE: An issue on HTML5 new elements in the spec.
7353     } else {
7354 wakaba 1.79
7355 wakaba 1.54 $reconstruct_active_formatting_elements->($insert_to_current);
7356 wakaba 1.53
7357 wakaba 1.54
7358     {
7359     my $el;
7360    
7361     $el = $self->{document}->create_element_ns
7362     (q<http://www.w3.org/1999/xhtml>, [undef, $token->{tag_name}]);
7363    
7364     for my $attr_name (keys %{ $token->{attributes}}) {
7365     $el->set_attribute_ns (undef, [undef, $attr_name],
7366     $token->{attributes} ->{$attr_name}->{value});
7367 wakaba 1.53 }
7368 wakaba 1.54
7369     $insert->($el);
7370     push @{$self->{open_elements}}, [$el, $token->{tag_name}];
7371     }
7372    
7373 wakaba 1.53
7374 wakaba 1.54 $token = $self->_get_next_token;
7375 wakaba 1.55 redo B;
7376 wakaba 1.54 }
7377 wakaba 1.57 } elsif ($token->{type} == END_TAG_TOKEN) {
7378 wakaba 1.54 if ($token->{tag_name} eq 'body') {
7379     if (@{$self->{open_elements}} > 1 and
7380     $self->{open_elements}->[1]->[1] eq 'body') {
7381     for (@{$self->{open_elements}}) {
7382     unless ({
7383     dd => 1, dt => 1, li => 1, p => 1, td => 1,
7384     th => 1, tr => 1, body => 1, html => 1,
7385     tbody => 1, tfoot => 1, thead => 1,
7386     }->{$_->[1]}) {
7387 wakaba 1.79
7388 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$_->[1]);
7389 wakaba 1.79 } else {
7390    
7391 wakaba 1.54 }
7392     }
7393 wakaba 1.53
7394 wakaba 1.56 $self->{insertion_mode} = AFTER_BODY_IM;
7395 wakaba 1.54 $token = $self->_get_next_token;
7396 wakaba 1.55 redo B;
7397 wakaba 1.54 } else {
7398 wakaba 1.79
7399 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
7400     ## Ignore the token
7401     $token = $self->_get_next_token;
7402 wakaba 1.55 redo B;
7403 wakaba 1.53 }
7404 wakaba 1.54 } elsif ($token->{tag_name} eq 'html') {
7405     if (@{$self->{open_elements}} > 1 and $self->{open_elements}->[1]->[1] eq 'body') {
7406     ## ISSUE: There is an issue in the spec.
7407     if ($self->{open_elements}->[-1]->[1] ne 'body') {
7408 wakaba 1.79
7409 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[1]->[1]);
7410 wakaba 1.79 } else {
7411    
7412 wakaba 1.54 }
7413 wakaba 1.56 $self->{insertion_mode} = AFTER_BODY_IM;
7414 wakaba 1.54 ## reprocess
7415 wakaba 1.55 redo B;
7416 wakaba 1.54 } else {
7417 wakaba 1.79
7418 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
7419     ## Ignore the token
7420     $token = $self->_get_next_token;
7421 wakaba 1.55 redo B;
7422 wakaba 1.53 }
7423 wakaba 1.54 } elsif ({
7424     address => 1, blockquote => 1, center => 1, dir => 1,
7425     div => 1, dl => 1, fieldset => 1, listing => 1,
7426     menu => 1, ol => 1, pre => 1, ul => 1,
7427     dd => 1, dt => 1, li => 1,
7428     button => 1, marquee => 1, object => 1,
7429     }->{$token->{tag_name}}) {
7430     ## has an element in scope
7431     my $i;
7432     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
7433     my $node = $self->{open_elements}->[$_];
7434     if ($node->[1] eq $token->{tag_name}) {
7435 wakaba 1.79
7436 wakaba 1.54 $i = $_;
7437 wakaba 1.87 last INSCOPE;
7438 wakaba 1.54 } elsif ({
7439     table => 1, caption => 1, td => 1, th => 1,
7440     button => 1, marquee => 1, object => 1, html => 1,
7441     }->{$node->[1]}) {
7442 wakaba 1.79
7443 wakaba 1.54 last INSCOPE;
7444     }
7445     } # INSCOPE
7446 wakaba 1.89
7447     unless (defined $i) { # has an element in scope
7448    
7449     $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
7450     } else {
7451     ## Step 1. generate implied end tags
7452     while ({
7453     dd => ($token->{tag_name} ne 'dd'),
7454     dt => ($token->{tag_name} ne 'dt'),
7455     li => ($token->{tag_name} ne 'li'),
7456     p => 1,
7457     }->{$self->{open_elements}->[-1]->[1]}) {
7458    
7459     pop @{$self->{open_elements}};
7460     }
7461    
7462     ## Step 2.
7463     if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {
7464 wakaba 1.79
7465 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
7466 wakaba 1.1 } else {
7467 wakaba 1.79
7468 wakaba 1.1 }
7469 wakaba 1.89
7470     ## Step 3.
7471 wakaba 1.54 splice @{$self->{open_elements}}, $i;
7472 wakaba 1.89
7473     ## Step 4.
7474     $clear_up_to_marker->()
7475     if {
7476     button => 1, marquee => 1, object => 1,
7477     }->{$token->{tag_name}};
7478 wakaba 1.54 }
7479     $token = $self->_get_next_token;
7480 wakaba 1.55 redo B;
7481 wakaba 1.54 } elsif ($token->{tag_name} eq 'form') {
7482     ## has an element in scope
7483     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
7484     my $node = $self->{open_elements}->[$_];
7485     if ($node->[1] eq $token->{tag_name}) {
7486     ## generate implied end tags
7487 wakaba 1.86 while ({
7488     dd => 1, dt => 1, li => 1, p => 1,
7489     }->{$self->{open_elements}->[-1]->[1]}) {
7490 wakaba 1.79
7491 wakaba 1.86 pop @{$self->{open_elements}};
7492 wakaba 1.54 }
7493 wakaba 1.86
7494 wakaba 1.79
7495 wakaba 1.54 last INSCOPE;
7496     } elsif ({
7497     table => 1, caption => 1, td => 1, th => 1,
7498     button => 1, marquee => 1, object => 1, html => 1,
7499     }->{$node->[1]}) {
7500 wakaba 1.79
7501 wakaba 1.54 last INSCOPE;
7502 wakaba 1.36 }
7503 wakaba 1.54 } # INSCOPE
7504    
7505     if ($self->{open_elements}->[-1]->[1] eq $token->{tag_name}) {
7506 wakaba 1.79
7507 wakaba 1.54 pop @{$self->{open_elements}};
7508     } else {
7509 wakaba 1.79
7510 wakaba 1.60 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
7511 wakaba 1.36 }
7512    
7513 wakaba 1.54 undef $self->{form_element};
7514     $token = $self->_get_next_token;
7515 wakaba 1.55 redo B;
7516 wakaba 1.54 } elsif ({
7517     h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,
7518     }->{$token->{tag_name}}) {
7519     ## has an element in scope
7520     my $i;
7521     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
7522     my $node = $self->{open_elements}->[$_];
7523     if ({
7524     h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,
7525     }->{$node->[1]}) {
7526     ## generate implied end tags
7527 wakaba 1.86 while ({
7528     dd => 1, dt => 1, li => 1, p => 1,
7529     }->{$self->{open_elements}->[-1]->[1]}) {
7530 wakaba 1.79
7531 wakaba 1.86 pop @{$self->{open_elements}};
7532 wakaba 1.54 }
7533 wakaba 1.79
7534    
7535 wakaba 1.54 $i = $_;
7536     last INSCOPE;
7537     } elsif ({
7538     table => 1, caption => 1, td => 1, th => 1,
7539     button => 1, marquee => 1, object => 1, html => 1,
7540     }->{$node->[1]}) {
7541 wakaba 1.79
7542 wakaba 1.54 last INSCOPE;
7543 wakaba 1.53 }
7544 wakaba 1.54 } # INSCOPE
7545    
7546     if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {
7547 wakaba 1.79
7548 wakaba 1.60 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
7549 wakaba 1.79 } else {
7550    
7551 wakaba 1.53 }
7552    
7553 wakaba 1.54 splice @{$self->{open_elements}}, $i if defined $i;
7554     $token = $self->_get_next_token;
7555 wakaba 1.55 redo B;
7556 wakaba 1.87 } elsif ($token->{tag_name} eq 'p') {
7557     ## has an element in scope
7558     my $i;
7559     INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
7560     my $node = $self->{open_elements}->[$_];
7561     if ($node->[1] eq $token->{tag_name}) {
7562    
7563     $i = $_;
7564 wakaba 1.88 last INSCOPE;
7565 wakaba 1.87 } elsif ({
7566     table => 1, caption => 1, td => 1, th => 1,
7567     button => 1, marquee => 1, object => 1, html => 1,
7568     }->{$node->[1]}) {
7569    
7570     last INSCOPE;
7571     }
7572     } # INSCOPE
7573    
7574     if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {
7575     if (defined $i) {
7576    
7577     $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
7578     } else {
7579    
7580     $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
7581     }
7582     }
7583    
7584     if (defined $i) {
7585    
7586     splice @{$self->{open_elements}}, $i;
7587     } else {
7588    
7589     ## As if <p>, then reprocess the current token
7590     my $el;
7591    
7592     $el = $self->{document}->create_element_ns
7593     (q<http://www.w3.org/1999/xhtml>, [undef, 'p']);
7594    
7595     $insert->($el);
7596     }
7597     $token = $self->_get_next_token;
7598     redo B;
7599 wakaba 1.54 } elsif ({
7600     a => 1,
7601     b => 1, big => 1, em => 1, font => 1, i => 1,
7602     nobr => 1, s => 1, small => 1, strile => 1,
7603     strong => 1, tt => 1, u => 1,
7604     }->{$token->{tag_name}}) {
7605 wakaba 1.79
7606 wakaba 1.54 $formatting_end_tag->($token->{tag_name});
7607 wakaba 1.55 redo B;
7608 wakaba 1.54 } elsif ($token->{tag_name} eq 'br') {
7609 wakaba 1.79
7610 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:br');
7611 wakaba 1.53
7612 wakaba 1.54 ## As if <br>
7613     $reconstruct_active_formatting_elements->($insert_to_current);
7614    
7615     my $el;
7616    
7617 wakaba 1.1 $el = $self->{document}->create_element_ns
7618 wakaba 1.54 (q<http://www.w3.org/1999/xhtml>, [undef, 'br']);
7619 wakaba 1.1
7620 wakaba 1.54 $insert->($el);
7621    
7622     ## Ignore the token.
7623     $token = $self->_get_next_token;
7624 wakaba 1.55 redo B;
7625 wakaba 1.54 } elsif ({
7626     caption => 1, col => 1, colgroup => 1, frame => 1,
7627     frameset => 1, head => 1, option => 1, optgroup => 1,
7628     tbody => 1, td => 1, tfoot => 1, th => 1,
7629     thead => 1, tr => 1,
7630     area => 1, basefont => 1, bgsound => 1,
7631     embed => 1, hr => 1, iframe => 1, image => 1,
7632     img => 1, input => 1, isindex => 1, noembed => 1,
7633     noframes => 1, param => 1, select => 1, spacer => 1,
7634     table => 1, textarea => 1, wbr => 1,
7635     noscript => 0, ## TODO: if scripting is enabled
7636     }->{$token->{tag_name}}) {
7637 wakaba 1.79
7638 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
7639     ## Ignore the token
7640     $token = $self->_get_next_token;
7641 wakaba 1.55 redo B;
7642 wakaba 1.54
7643     ## ISSUE: Issue on HTML5 new elements in spec
7644    
7645     } else {
7646     ## Step 1
7647     my $node_i = -1;
7648     my $node = $self->{open_elements}->[$node_i];
7649    
7650     ## Step 2
7651     S2: {
7652     if ($node->[1] eq $token->{tag_name}) {
7653     ## Step 1
7654     ## generate implied end tags
7655 wakaba 1.86 while ({
7656     dd => 1, dt => 1, li => 1, p => 1,
7657     }->{$self->{open_elements}->[-1]->[1]}) {
7658 wakaba 1.79
7659 wakaba 1.83 ## ISSUE: Can this case be reached?
7660 wakaba 1.86 pop @{$self->{open_elements}};
7661 wakaba 1.54 }
7662    
7663     ## Step 2
7664     if ($token->{tag_name} ne $self->{open_elements}->[-1]->[1]) {
7665 wakaba 1.79
7666 wakaba 1.60 ## NOTE: <x><y></x>
7667 wakaba 1.54 $self->{parse_error}-> (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
7668 wakaba 1.79 } else {
7669    
7670 wakaba 1.54 }
7671    
7672     ## Step 3
7673     splice @{$self->{open_elements}}, $node_i;
7674 wakaba 1.53
7675 wakaba 1.36 $token = $self->_get_next_token;
7676 wakaba 1.54 last S2;
7677 wakaba 1.1 } else {
7678 wakaba 1.54 ## Step 3
7679     if (not $formatting_category->{$node->[1]} and
7680     #not $phrasing_category->{$node->[1]} and
7681     ($special_category->{$node->[1]} or
7682     $scoping_category->{$node->[1]})) {
7683 wakaba 1.79
7684 wakaba 1.54 $self->{parse_error}-> (type => 'unmatched end tag:'.$token->{tag_name});
7685     ## Ignore the token
7686     $token = $self->_get_next_token;
7687     last S2;
7688     }
7689 wakaba 1.79
7690    
7691 wakaba 1.1 }
7692 wakaba 1.54
7693     ## Step 4
7694     $node_i--;
7695     $node = $self->{open_elements}->[$node_i];
7696    
7697     ## Step 5;
7698     redo S2;
7699     } # S2
7700 wakaba 1.55 redo B;
7701 wakaba 1.1 }
7702     }
7703 wakaba 1.54 redo B;
7704 wakaba 1.1 } # B
7705    
7706     ## Stop parsing # MUST
7707    
7708     ## TODO: script stuffs
7709 wakaba 1.3 } # _tree_construct_main
7710    
7711     sub set_inner_html ($$$) {
7712     my $class = shift;
7713     my $node = shift;
7714     my $s = \$_[0];
7715     my $onerror = $_[1];
7716    
7717 wakaba 1.65 ## ISSUE: Should {confident} be true?
7718    
7719 wakaba 1.3 my $nt = $node->node_type;
7720     if ($nt == 9) {
7721     # MUST
7722    
7723     ## Step 1 # MUST
7724     ## TODO: If the document has an active parser, ...
7725     ## ISSUE: There is an issue in the spec.
7726    
7727     ## Step 2 # MUST
7728     my @cn = @{$node->child_nodes};
7729     for (@cn) {
7730     $node->remove_child ($_);
7731     }
7732    
7733     ## Step 3, 4, 5 # MUST
7734     $class->parse_string ($$s => $node, $onerror);
7735     } elsif ($nt == 1) {
7736     ## TODO: If non-html element
7737    
7738     ## NOTE: Most of this code is copied from |parse_string|
7739    
7740     ## Step 1 # MUST
7741 wakaba 1.14 my $this_doc = $node->owner_document;
7742     my $doc = $this_doc->implementation->create_document;
7743 wakaba 1.18 $doc->manakai_is_html (1);
7744 wakaba 1.3 my $p = $class->new;
7745     $p->{document} = $doc;
7746    
7747 wakaba 1.84 ## Step 8 # MUST
7748 wakaba 1.3 my $i = 0;
7749     my $line = 1;
7750     my $column = 0;
7751 wakaba 1.76 $p->{set_next_char} = sub {
7752 wakaba 1.3 my $self = shift;
7753 wakaba 1.14
7754 wakaba 1.76 pop @{$self->{prev_char}};
7755     unshift @{$self->{prev_char}}, $self->{next_char};
7756 wakaba 1.14
7757 wakaba 1.76 $self->{next_char} = -1 and return if $i >= length $$s;
7758     $self->{next_char} = ord substr $$s, $i++, 1;
7759 wakaba 1.3 $column++;
7760 wakaba 1.4
7761 wakaba 1.76 if ($self->{next_char} == 0x000A) { # LF
7762 wakaba 1.4 $line++;
7763     $column = 0;
7764 wakaba 1.79
7765 wakaba 1.76 } elsif ($self->{next_char} == 0x000D) { # CR
7766 wakaba 1.15 $i++ if substr ($$s, $i, 1) eq "\x0A";
7767 wakaba 1.76 $self->{next_char} = 0x000A; # LF # MUST
7768 wakaba 1.3 $line++;
7769 wakaba 1.4 $column = 0;
7770 wakaba 1.79
7771 wakaba 1.76 } elsif ($self->{next_char} > 0x10FFFF) {
7772     $self->{next_char} = 0xFFFD; # REPLACEMENT CHARACTER # MUST
7773 wakaba 1.79
7774 wakaba 1.76 } elsif ($self->{next_char} == 0x0000) { # NULL
7775 wakaba 1.79
7776 wakaba 1.14 $self->{parse_error}-> (type => 'NULL');
7777 wakaba 1.76 $self->{next_char} = 0xFFFD; # REPLACEMENT CHARACTER # MUST
7778 wakaba 1.3 }
7779     };
7780 wakaba 1.76 $p->{prev_char} = [-1, -1, -1];
7781     $p->{next_char} = -1;
7782 wakaba 1.3
7783     my $ponerror = $onerror || sub {
7784     my (%opt) = @_;
7785     warn "Parse error ($opt{type}) at line $opt{line} column $opt{column}\n";
7786     };
7787     $p->{parse_error} = sub {
7788     $ponerror->(@_, line => $line, column => $column);
7789     };
7790    
7791     $p->_initialize_tokenizer;
7792     $p->_initialize_tree_constructor;
7793    
7794     ## Step 2
7795 wakaba 1.71 my $node_ln = $node->manakai_local_name;
7796 wakaba 1.41 $p->{content_model} = {
7797     title => RCDATA_CONTENT_MODEL,
7798     textarea => RCDATA_CONTENT_MODEL,
7799     style => CDATA_CONTENT_MODEL,
7800     script => CDATA_CONTENT_MODEL,
7801     xmp => CDATA_CONTENT_MODEL,
7802     iframe => CDATA_CONTENT_MODEL,
7803     noembed => CDATA_CONTENT_MODEL,
7804     noframes => CDATA_CONTENT_MODEL,
7805     noscript => CDATA_CONTENT_MODEL,
7806     plaintext => PLAINTEXT_CONTENT_MODEL,
7807     }->{$node_ln};
7808     $p->{content_model} = PCDATA_CONTENT_MODEL
7809     unless defined $p->{content_model};
7810     ## ISSUE: What is "the name of the element"? local name?
7811 wakaba 1.3
7812     $p->{inner_html_node} = [$node, $node_ln];
7813    
7814 wakaba 1.84 ## Step 3
7815 wakaba 1.3 my $root = $doc->create_element_ns
7816     ('http://www.w3.org/1999/xhtml', [undef, 'html']);
7817    
7818 wakaba 1.84 ## Step 4 # MUST
7819 wakaba 1.3 $doc->append_child ($root);
7820    
7821 wakaba 1.84 ## Step 5 # MUST
7822 wakaba 1.3 push @{$p->{open_elements}}, [$root, 'html'];
7823    
7824     undef $p->{head_element};
7825    
7826 wakaba 1.84 ## Step 6 # MUST
7827 wakaba 1.3 $p->_reset_insertion_mode;
7828    
7829 wakaba 1.84 ## Step 7 # MUST
7830 wakaba 1.3 my $anode = $node;
7831     AN: while (defined $anode) {
7832     if ($anode->node_type == 1) {
7833     my $nsuri = $anode->namespace_uri;
7834     if (defined $nsuri and $nsuri eq 'http://www.w3.org/1999/xhtml') {
7835 wakaba 1.71 if ($anode->manakai_local_name eq 'form') {
7836 wakaba 1.79
7837 wakaba 1.3 $p->{form_element} = $anode;
7838     last AN;
7839     }
7840     }
7841     }
7842     $anode = $anode->parent_node;
7843     } # AN
7844    
7845 wakaba 1.84 ## Step 9 # MUST
7846 wakaba 1.3 {
7847     my $self = $p;
7848     $token = $self->_get_next_token;
7849     }
7850     $p->_tree_construction_main;
7851    
7852 wakaba 1.84 ## Step 10 # MUST
7853 wakaba 1.3 my @cn = @{$node->child_nodes};
7854     for (@cn) {
7855     $node->remove_child ($_);
7856     }
7857     ## ISSUE: mutation events? read-only?
7858    
7859 wakaba 1.84 ## Step 11 # MUST
7860 wakaba 1.3 @cn = @{$root->child_nodes};
7861     for (@cn) {
7862 wakaba 1.14 $this_doc->adopt_node ($_);
7863 wakaba 1.3 $node->append_child ($_);
7864     }
7865 wakaba 1.14 ## ISSUE: mutation events?
7866 wakaba 1.3
7867     $p->_terminate_tree_constructor;
7868     } else {
7869     die "$0: |set_inner_html| is not defined for node of type $nt";
7870     }
7871     } # set_inner_html
7872    
7873     } # tree construction stage
7874 wakaba 1.1
7875 wakaba 1.65 package Whatpm::HTML::RestartParser;
7876     push our @ISA, 'Error';
7877    
7878 wakaba 1.1 1;
7879 wakaba 1.90 # $Date: 2008/03/08 02:48:20 $
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.24