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

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

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 1.13 by wakaba, Sat Jun 23 05:29:48 2007 UTC revision 1.57 by wakaba, Sat Aug 11 08:08:12 2007 UTC
# Line 2  package Whatpm::HTML; Line 2  package Whatpm::HTML;
2  use strict;  use strict;
3  our $VERSION=do{my @r=(q$Revision$=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};  our $VERSION=do{my @r=(q$Revision$=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
4    
5  ## This is an early version of an HTML parser.  ## ISSUE:
6    ## var doc = implementation.createDocument (null, null, null);
7    ## doc.write ('');
8    ## alert (doc.compatMode);
9    
10    ## ISSUE: HTML5 revision 967 says that the encoding layer MUST NOT
11    ## strip BOM and the HTML layer MUST ignore it.  Whether we can do it
12    ## is not yet clear.
13    ## "{U+FEFF}..." in UTF-16BE/UTF-16LE is three or four characters?
14    ## "{U+FEFF}..." in GB18030?
15    
16  my $permitted_slash_tag_name = {  my $permitted_slash_tag_name = {
17    base => 1,    base => 1,
# Line 18  my $permitted_slash_tag_name = { Line 27  my $permitted_slash_tag_name = {
27    input => 1,    input => 1,
28  };  };
29    
 my $entity_char = {  
   AElig => "\x{00C6}",  
   Aacute => "\x{00C1}",  
   Acirc => "\x{00C2}",  
   Agrave => "\x{00C0}",  
   Alpha => "\x{0391}",  
   Aring => "\x{00C5}",  
   Atilde => "\x{00C3}",  
   Auml => "\x{00C4}",  
   Beta => "\x{0392}",  
   Ccedil => "\x{00C7}",  
   Chi => "\x{03A7}",  
   Dagger => "\x{2021}",  
   Delta => "\x{0394}",  
   ETH => "\x{00D0}",  
   Eacute => "\x{00C9}",  
   Ecirc => "\x{00CA}",  
   Egrave => "\x{00C8}",  
   Epsilon => "\x{0395}",  
   Eta => "\x{0397}",  
   Euml => "\x{00CB}",  
   Gamma => "\x{0393}",  
   Iacute => "\x{00CD}",  
   Icirc => "\x{00CE}",  
   Igrave => "\x{00CC}",  
   Iota => "\x{0399}",  
   Iuml => "\x{00CF}",  
   Kappa => "\x{039A}",  
   Lambda => "\x{039B}",  
   Mu => "\x{039C}",  
   Ntilde => "\x{00D1}",  
   Nu => "\x{039D}",  
   OElig => "\x{0152}",  
   Oacute => "\x{00D3}",  
   Ocirc => "\x{00D4}",  
   Ograve => "\x{00D2}",  
   Omega => "\x{03A9}",  
   Omicron => "\x{039F}",  
   Oslash => "\x{00D8}",  
   Otilde => "\x{00D5}",  
   Ouml => "\x{00D6}",  
   Phi => "\x{03A6}",  
   Pi => "\x{03A0}",  
   Prime => "\x{2033}",  
   Psi => "\x{03A8}",  
   Rho => "\x{03A1}",  
   Scaron => "\x{0160}",  
   Sigma => "\x{03A3}",  
   THORN => "\x{00DE}",  
   Tau => "\x{03A4}",  
   Theta => "\x{0398}",  
   Uacute => "\x{00DA}",  
   Ucirc => "\x{00DB}",  
   Ugrave => "\x{00D9}",  
   Upsilon => "\x{03A5}",  
   Uuml => "\x{00DC}",  
   Xi => "\x{039E}",  
   Yacute => "\x{00DD}",  
   Yuml => "\x{0178}",  
   Zeta => "\x{0396}",  
   aacute => "\x{00E1}",  
   acirc => "\x{00E2}",  
   acute => "\x{00B4}",  
   aelig => "\x{00E6}",  
   agrave => "\x{00E0}",  
   alefsym => "\x{2135}",  
   alpha => "\x{03B1}",  
   amp => "\x{0026}",  
   AMP => "\x{0026}",  
   and => "\x{2227}",  
   ang => "\x{2220}",  
   apos => "\x{0027}",  
   aring => "\x{00E5}",  
   asymp => "\x{2248}",  
   atilde => "\x{00E3}",  
   auml => "\x{00E4}",  
   bdquo => "\x{201E}",  
   beta => "\x{03B2}",  
   brvbar => "\x{00A6}",  
   bull => "\x{2022}",  
   cap => "\x{2229}",  
   ccedil => "\x{00E7}",  
   cedil => "\x{00B8}",  
   cent => "\x{00A2}",  
   chi => "\x{03C7}",  
   circ => "\x{02C6}",  
   clubs => "\x{2663}",  
   cong => "\x{2245}",  
   copy => "\x{00A9}",  
   COPY => "\x{00A9}",  
   crarr => "\x{21B5}",  
   cup => "\x{222A}",  
   curren => "\x{00A4}",  
   dArr => "\x{21D3}",  
   dagger => "\x{2020}",  
   darr => "\x{2193}",  
   deg => "\x{00B0}",  
   delta => "\x{03B4}",  
   diams => "\x{2666}",  
   divide => "\x{00F7}",  
   eacute => "\x{00E9}",  
   ecirc => "\x{00EA}",  
   egrave => "\x{00E8}",  
   empty => "\x{2205}",  
   emsp => "\x{2003}",  
   ensp => "\x{2002}",  
   epsilon => "\x{03B5}",  
   equiv => "\x{2261}",  
   eta => "\x{03B7}",  
   eth => "\x{00F0}",  
   euml => "\x{00EB}",  
   euro => "\x{20AC}",  
   exist => "\x{2203}",  
   fnof => "\x{0192}",  
   forall => "\x{2200}",  
   frac12 => "\x{00BD}",  
   frac14 => "\x{00BC}",  
   frac34 => "\x{00BE}",  
   frasl => "\x{2044}",  
   gamma => "\x{03B3}",  
   ge => "\x{2265}",  
   gt => "\x{003E}",  
   GT => "\x{003E}",  
   hArr => "\x{21D4}",  
   harr => "\x{2194}",  
   hearts => "\x{2665}",  
   hellip => "\x{2026}",  
   iacute => "\x{00ED}",  
   icirc => "\x{00EE}",  
   iexcl => "\x{00A1}",  
   igrave => "\x{00EC}",  
   image => "\x{2111}",  
   infin => "\x{221E}",  
   int => "\x{222B}",  
   iota => "\x{03B9}",  
   iquest => "\x{00BF}",  
   isin => "\x{2208}",  
   iuml => "\x{00EF}",  
   kappa => "\x{03BA}",  
   lArr => "\x{21D0}",  
   lambda => "\x{03BB}",  
   lang => "\x{2329}",  
   laquo => "\x{00AB}",  
   larr => "\x{2190}",  
   lceil => "\x{2308}",  
   ldquo => "\x{201C}",  
   le => "\x{2264}",  
   lfloor => "\x{230A}",  
   lowast => "\x{2217}",  
   loz => "\x{25CA}",  
   lrm => "\x{200E}",  
   lsaquo => "\x{2039}",  
   lsquo => "\x{2018}",  
   lt => "\x{003C}",  
   LT => "\x{003C}",  
   macr => "\x{00AF}",  
   mdash => "\x{2014}",  
   micro => "\x{00B5}",  
   middot => "\x{00B7}",  
   minus => "\x{2212}",  
   mu => "\x{03BC}",  
   nabla => "\x{2207}",  
   nbsp => "\x{00A0}",  
   ndash => "\x{2013}",  
   ne => "\x{2260}",  
   ni => "\x{220B}",  
   not => "\x{00AC}",  
   notin => "\x{2209}",  
   nsub => "\x{2284}",  
   ntilde => "\x{00F1}",  
   nu => "\x{03BD}",  
   oacute => "\x{00F3}",  
   ocirc => "\x{00F4}",  
   oelig => "\x{0153}",  
   ograve => "\x{00F2}",  
   oline => "\x{203E}",  
   omega => "\x{03C9}",  
   omicron => "\x{03BF}",  
   oplus => "\x{2295}",  
   or => "\x{2228}",  
   ordf => "\x{00AA}",  
   ordm => "\x{00BA}",  
   oslash => "\x{00F8}",  
   otilde => "\x{00F5}",  
   otimes => "\x{2297}",  
   ouml => "\x{00F6}",  
   para => "\x{00B6}",  
   part => "\x{2202}",  
   permil => "\x{2030}",  
   perp => "\x{22A5}",  
   phi => "\x{03C6}",  
   pi => "\x{03C0}",  
   piv => "\x{03D6}",  
   plusmn => "\x{00B1}",  
   pound => "\x{00A3}",  
   prime => "\x{2032}",  
   prod => "\x{220F}",  
   prop => "\x{221D}",  
   psi => "\x{03C8}",  
   quot => "\x{0022}",  
   QUOT => "\x{0022}",  
   rArr => "\x{21D2}",  
   radic => "\x{221A}",  
   rang => "\x{232A}",  
   raquo => "\x{00BB}",  
   rarr => "\x{2192}",  
   rceil => "\x{2309}",  
   rdquo => "\x{201D}",  
   real => "\x{211C}",  
   reg => "\x{00AE}",  
   REG => "\x{00AE}",  
   rfloor => "\x{230B}",  
   rho => "\x{03C1}",  
   rlm => "\x{200F}",  
   rsaquo => "\x{203A}",  
   rsquo => "\x{2019}",  
   sbquo => "\x{201A}",  
   scaron => "\x{0161}",  
   sdot => "\x{22C5}",  
   sect => "\x{00A7}",  
   shy => "\x{00AD}",  
   sigma => "\x{03C3}",  
   sigmaf => "\x{03C2}",  
   sim => "\x{223C}",  
   spades => "\x{2660}",  
   sub => "\x{2282}",  
   sube => "\x{2286}",  
   sum => "\x{2211}",  
   sup => "\x{2283}",  
   sup1 => "\x{00B9}",  
   sup2 => "\x{00B2}",  
   sup3 => "\x{00B3}",  
   supe => "\x{2287}",  
   szlig => "\x{00DF}",  
   tau => "\x{03C4}",  
   there4 => "\x{2234}",  
   theta => "\x{03B8}",  
   thetasym => "\x{03D1}",  
   thinsp => "\x{2009}",  
   thorn => "\x{00FE}",  
   tilde => "\x{02DC}",  
   times => "\x{00D7}",  
   trade => "\x{2122}",  
   uArr => "\x{21D1}",  
   uacute => "\x{00FA}",  
   uarr => "\x{2191}",  
   ucirc => "\x{00FB}",  
   ugrave => "\x{00F9}",  
   uml => "\x{00A8}",  
   upsih => "\x{03D2}",  
   upsilon => "\x{03C5}",  
   uuml => "\x{00FC}",  
   weierp => "\x{2118}",  
   xi => "\x{03BE}",  
   yacute => "\x{00FD}",  
   yen => "\x{00A5}",  
   yuml => "\x{00FF}",  
   zeta => "\x{03B6}",  
   zwj => "\x{200D}",  
   zwnj => "\x{200C}",  
 }; # $entity_char  
   
30  my $c1_entity_char = {  my $c1_entity_char = {
31    0x80 => 0x20AC,    0x80 => 0x20AC,
32    0x81 => 0xFFFD,    0x81 => 0xFFFD,
# Line 361  sub parse_string ($$$;$) { Line 108  sub parse_string ($$$;$) {
108        $line++;        $line++;
109        $column = 0;        $column = 0;
110      } elsif ($self->{next_input_character} == 0x000D) { # CR      } elsif ($self->{next_input_character} == 0x000D) { # CR
111        if ($i >= length $$s) {        $i++ if substr ($$s, $i, 1) eq "\x0A";
         #  
       } else {  
         my $next_char = ord substr $$s, $i++, 1;  
         if ($next_char == 0x000A) { # LF  
           #  
         } else {  
           push @{$self->{char}}, $next_char;  
         }  
       }  
112        $self->{next_input_character} = 0x000A; # LF # MUST        $self->{next_input_character} = 0x000A; # LF # MUST
113        $line++;        $line++;
114        $column = 0;        $column = 0;
# Line 412  sub new ($) { Line 150  sub new ($) {
150    return $self;    return $self;
151  } # new  } # new
152    
153    sub CM_ENTITY () { 0b001 } # & markup in data
154    sub CM_LIMITED_MARKUP () { 0b010 } # < markup in data (limited)
155    sub CM_FULL_MARKUP () { 0b100 } # < markup in data (any)
156    
157    sub PLAINTEXT_CONTENT_MODEL () { 0 }
158    sub CDATA_CONTENT_MODEL () { CM_LIMITED_MARKUP }
159    sub RCDATA_CONTENT_MODEL () { CM_ENTITY | CM_LIMITED_MARKUP }
160    sub PCDATA_CONTENT_MODEL () { CM_ENTITY | CM_FULL_MARKUP }
161    
162    sub DATA_STATE () { 0 }
163    sub ENTITY_DATA_STATE () { 1 }
164    sub TAG_OPEN_STATE () { 2 }
165    sub CLOSE_TAG_OPEN_STATE () { 3 }
166    sub TAG_NAME_STATE () { 4 }
167    sub BEFORE_ATTRIBUTE_NAME_STATE () { 5 }
168    sub ATTRIBUTE_NAME_STATE () { 6 }
169    sub AFTER_ATTRIBUTE_NAME_STATE () { 7 }
170    sub BEFORE_ATTRIBUTE_VALUE_STATE () { 8 }
171    sub ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE () { 9 }
172    sub ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE () { 10 }
173    sub ATTRIBUTE_VALUE_UNQUOTED_STATE () { 11 }
174    sub ENTITY_IN_ATTRIBUTE_VALUE_STATE () { 12 }
175    sub MARKUP_DECLARATION_OPEN_STATE () { 13 }
176    sub COMMENT_START_STATE () { 14 }
177    sub COMMENT_START_DASH_STATE () { 15 }
178    sub COMMENT_STATE () { 16 }
179    sub COMMENT_END_STATE () { 17 }
180    sub COMMENT_END_DASH_STATE () { 18 }
181    sub BOGUS_COMMENT_STATE () { 19 }
182    sub DOCTYPE_STATE () { 20 }
183    sub BEFORE_DOCTYPE_NAME_STATE () { 21 }
184    sub DOCTYPE_NAME_STATE () { 22 }
185    sub AFTER_DOCTYPE_NAME_STATE () { 23 }
186    sub BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE () { 24 }
187    sub DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE () { 25 }
188    sub DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE () { 26 }
189    sub AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE () { 27 }
190    sub BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE () { 28 }
191    sub DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE () { 29 }
192    sub DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE () { 30 }
193    sub AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE () { 31 }
194    sub BOGUS_DOCTYPE_STATE () { 32 }
195    
196    sub DOCTYPE_TOKEN () { 1 }
197    sub COMMENT_TOKEN () { 2 }
198    sub START_TAG_TOKEN () { 3 }
199    sub END_TAG_TOKEN () { 4 }
200    sub END_OF_FILE_TOKEN () { 5 }
201    sub CHARACTER_TOKEN () { 6 }
202    
203    sub AFTER_HTML_IMS () { 0b100 }
204    sub HEAD_IMS ()       { 0b1000 }
205    sub BODY_IMS ()       { 0b10000 }
206    sub BODY_TABLE_IMS () { 0b100000 }
207    sub TABLE_IMS ()      { 0b1000000 }
208    sub ROW_IMS ()        { 0b10000000 }
209    sub BODY_AFTER_IMS () { 0b100000000 }
210    sub FRAME_IMS ()      { 0b1000000000 }
211    
212    sub AFTER_HTML_BODY_IM () { AFTER_HTML_IMS | BODY_AFTER_IMS }
213    sub AFTER_HTML_FRAMESET_IM () { AFTER_HTML_IMS | FRAME_IMS }
214    sub IN_HEAD_IM () { HEAD_IMS | 0b00 }
215    sub IN_HEAD_NOSCRIPT_IM () { HEAD_IMS | 0b01 }
216    sub AFTER_HEAD_IM () { HEAD_IMS | 0b10 }
217    sub BEFORE_HEAD_IM () { HEAD_IMS | 0b11 }
218    sub IN_BODY_IM () { BODY_IMS }
219    sub IN_CELL_IM () { BODY_IMS | BODY_TABLE_IMS | 0b01 }
220    sub IN_CAPTION_IM () { BODY_IMS | BODY_TABLE_IMS | 0b10 }
221    sub IN_ROW_IM () { TABLE_IMS | ROW_IMS | 0b01 }
222    sub IN_TABLE_BODY_IM () { TABLE_IMS | ROW_IMS | 0b10 }
223    sub IN_TABLE_IM () { TABLE_IMS }
224    sub AFTER_BODY_IM () { BODY_AFTER_IMS }
225    sub IN_FRAMESET_IM () { FRAME_IMS | 0b01 }
226    sub AFTER_FRAMESET_IM () { FRAME_IMS | 0b10 }
227    sub IN_SELECT_IM () { 0b01 }
228    sub IN_COLUMN_GROUP_IM () { 0b10 }
229    
230  ## Implementations MUST act as if state machine in the spec  ## Implementations MUST act as if state machine in the spec
231    
232  sub _initialize_tokenizer ($) {  sub _initialize_tokenizer ($) {
233    my $self = shift;    my $self = shift;
234    $self->{state} = 'data'; # MUST    $self->{state} = DATA_STATE; # MUST
235    $self->{content_model_flag} = 'PCDATA'; # be    $self->{content_model} = PCDATA_CONTENT_MODEL; # be
236    undef $self->{current_token}; # start tag, end tag, comment, or DOCTYPE    undef $self->{current_token}; # start tag, end tag, comment, or DOCTYPE
237    undef $self->{current_attribute};    undef $self->{current_attribute};
238    undef $self->{last_emitted_start_tag_name};    undef $self->{last_emitted_start_tag_name};
# Line 426  sub _initialize_tokenizer ($) { Line 241  sub _initialize_tokenizer ($) {
241    # $self->{next_input_character}    # $self->{next_input_character}
242    !!!next-input-character;    !!!next-input-character;
243    $self->{token} = [];    $self->{token} = [];
244      # $self->{escape}
245  } # _initialize_tokenizer  } # _initialize_tokenizer
246    
247  ## A token has:  ## A token has:
248  ##   ->{type} eq 'DOCTYPE', 'start tag', 'end tag', 'comment',  ##   ->{type} == DOCTYPE_TOKEN, START_TAG_TOKEN, END_TAG_TOKEN, COMMENT_TOKEN,
249  ##       'character', or 'end-of-file'  ##       CHARACTER_TOKEN, or END_OF_FILE_TOKEN
250  ##   ->{name} (DOCTYPE, start tag (tagname), end tag (tagname))  ##   ->{name} (DOCTYPE_TOKEN)
251      ## ISSUE: the spec need s/tagname/tag name/  ##   ->{tag_name} (START_TAG_TOKEN, END_TAG_TOKEN)
252  ##   ->{error} == 1 or 0 (DOCTYPE)  ##   ->{public_identifier} (DOCTYPE_TOKEN)
253  ##   ->{attributes} isa HASH (start tag, end tag)  ##   ->{system_identifier} (DOCTYPE_TOKEN)
254  ##   ->{data} (comment, character)  ##   ->{correct} == 1 or 0 (DOCTYPE_TOKEN)
255    ##   ->{attributes} isa HASH (START_TAG_TOKEN, END_TAG_TOKEN)
256  ## Macros  ##   ->{data} (COMMENT_TOKEN, CHARACTER_TOKEN)
 ##   Macros MUST be preceded by three EXCLAMATION MARKs.  
 ##   emit ($token)  
 ##     Emits the specified token.  
257    
258  ## Emitted token MUST immediately be handled by the tree construction state.  ## Emitted token MUST immediately be handled by the tree construction state.
259    
# Line 457  sub _get_next_token ($) { Line 270  sub _get_next_token ($) {
270    }    }
271    
272    A: {    A: {
273      if ($self->{state} eq 'data') {      if ($self->{state} == DATA_STATE) {
274        if ($self->{next_input_character} == 0x0026) { # &        if ($self->{next_input_character} == 0x0026) { # &
275          if ($self->{content_model_flag} eq 'PCDATA' or          if ($self->{content_model} & CM_ENTITY) { # PCDATA | RCDATA
276              $self->{content_model_flag} eq 'RCDATA') {            $self->{state} = ENTITY_DATA_STATE;
           $self->{state} = 'entity data';  
277            !!!next-input-character;            !!!next-input-character;
278            redo A;            redo A;
279          } else {          } else {
280            #            #
281          }          }
282        } elsif ($self->{next_input_character} == 0x002D) { # -        } elsif ($self->{next_input_character} == 0x002D) { # -
283          if ($self->{content_model_flag} eq 'RCDATA' or          if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
             $self->{content_model_flag} eq 'CDATA') {  
284            unless ($self->{escape}) {            unless ($self->{escape}) {
285              if ($self->{prev_input_character}->[0] == 0x002D and # -              if ($self->{prev_input_character}->[0] == 0x002D and # -
286                  $self->{prev_input_character}->[1] == 0x0021 and # !                  $self->{prev_input_character}->[1] == 0x0021 and # !
# Line 481  sub _get_next_token ($) { Line 292  sub _get_next_token ($) {
292                    
293          #          #
294        } elsif ($self->{next_input_character} == 0x003C) { # <        } elsif ($self->{next_input_character} == 0x003C) { # <
295          if ($self->{content_model_flag} eq 'PCDATA' or          if ($self->{content_model} & CM_FULL_MARKUP or # PCDATA
296              (($self->{content_model_flag} eq 'CDATA' or              (($self->{content_model} & CM_LIMITED_MARKUP) and # CDATA | RCDATA
               $self->{content_model_flag} eq 'RCDATA') and  
297               not $self->{escape})) {               not $self->{escape})) {
298            $self->{state} = 'tag open';            $self->{state} = TAG_OPEN_STATE;
299            !!!next-input-character;            !!!next-input-character;
300            redo A;            redo A;
301          } else {          } else {
# Line 493  sub _get_next_token ($) { Line 303  sub _get_next_token ($) {
303          }          }
304        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
305          if ($self->{escape} and          if ($self->{escape} and
306              ($self->{content_model_flag} eq 'RCDATA' or              ($self->{content_model} & CM_LIMITED_MARKUP)) { # RCDATA | CDATA
              $self->{content_model_flag} eq 'CDATA')) {  
307            if ($self->{prev_input_character}->[0] == 0x002D and # -            if ($self->{prev_input_character}->[0] == 0x002D and # -
308                $self->{prev_input_character}->[1] == 0x002D) { # -                $self->{prev_input_character}->[1] == 0x002D) { # -
309              delete $self->{escape};              delete $self->{escape};
# Line 503  sub _get_next_token ($) { Line 312  sub _get_next_token ($) {
312                    
313          #          #
314        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
315          !!!emit ({type => 'end-of-file'});          !!!emit ({type => END_OF_FILE_TOKEN});
316          last A; ## TODO: ok?          last A; ## TODO: ok?
317        }        }
318        # Anything else        # Anything else
319        my $token = {type => 'character',        my $token = {type => CHARACTER_TOKEN,
320                     data => chr $self->{next_input_character}};                     data => chr $self->{next_input_character}};
321        ## Stay in the data state        ## Stay in the data state
322        !!!next-input-character;        !!!next-input-character;
# Line 515  sub _get_next_token ($) { Line 324  sub _get_next_token ($) {
324        !!!emit ($token);        !!!emit ($token);
325    
326        redo A;        redo A;
327      } elsif ($self->{state} eq 'entity data') {      } elsif ($self->{state} == ENTITY_DATA_STATE) {
328        ## (cannot happen in CDATA state)        ## (cannot happen in CDATA state)
329                
330        my $token = $self->_tokenize_attempt_to_consume_an_entity;        my $token = $self->_tokenize_attempt_to_consume_an_entity (0);
331    
332        $self->{state} = 'data';        $self->{state} = DATA_STATE;
333        # next-input-character is already done        # next-input-character is already done
334    
335        unless (defined $token) {        unless (defined $token) {
336          !!!emit ({type => 'character', data => '&'});          !!!emit ({type => CHARACTER_TOKEN, data => '&'});
337        } else {        } else {
338          !!!emit ($token);          !!!emit ($token);
339        }        }
340    
341        redo A;        redo A;
342      } elsif ($self->{state} eq 'tag open') {      } elsif ($self->{state} == TAG_OPEN_STATE) {
343        if ($self->{content_model_flag} eq 'RCDATA' or        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
           $self->{content_model_flag} eq 'CDATA') {  
344          if ($self->{next_input_character} == 0x002F) { # /          if ($self->{next_input_character} == 0x002F) { # /
345            !!!next-input-character;            !!!next-input-character;
346            $self->{state} = 'close tag open';            $self->{state} = CLOSE_TAG_OPEN_STATE;
347            redo A;            redo A;
348          } else {          } else {
349            ## reconsume            ## reconsume
350            $self->{state} = 'data';            $self->{state} = DATA_STATE;
351    
352            !!!emit ({type => 'character', data => '<'});            !!!emit ({type => CHARACTER_TOKEN, data => '<'});
353    
354            redo A;            redo A;
355          }          }
356        } elsif ($self->{content_model_flag} eq 'PCDATA') {        } elsif ($self->{content_model} & CM_FULL_MARKUP) { # PCDATA
357          if ($self->{next_input_character} == 0x0021) { # !          if ($self->{next_input_character} == 0x0021) { # !
358            $self->{state} = 'markup declaration open';            $self->{state} = MARKUP_DECLARATION_OPEN_STATE;
359            !!!next-input-character;            !!!next-input-character;
360            redo A;            redo A;
361          } elsif ($self->{next_input_character} == 0x002F) { # /          } elsif ($self->{next_input_character} == 0x002F) { # /
362            $self->{state} = 'close tag open';            $self->{state} = CLOSE_TAG_OPEN_STATE;
363            !!!next-input-character;            !!!next-input-character;
364            redo A;            redo A;
365          } elsif (0x0041 <= $self->{next_input_character} and          } elsif (0x0041 <= $self->{next_input_character} and
366                   $self->{next_input_character} <= 0x005A) { # A..Z                   $self->{next_input_character} <= 0x005A) { # A..Z
367            $self->{current_token}            $self->{current_token}
368              = {type => 'start tag',              = {type => START_TAG_TOKEN,
369                 tag_name => chr ($self->{next_input_character} + 0x0020)};                 tag_name => chr ($self->{next_input_character} + 0x0020)};
370            $self->{state} = 'tag name';            $self->{state} = TAG_NAME_STATE;
371            !!!next-input-character;            !!!next-input-character;
372            redo A;            redo A;
373          } elsif (0x0061 <= $self->{next_input_character} and          } elsif (0x0061 <= $self->{next_input_character} and
374                   $self->{next_input_character} <= 0x007A) { # a..z                   $self->{next_input_character} <= 0x007A) { # a..z
375            $self->{current_token} = {type => 'start tag',            $self->{current_token} = {type => START_TAG_TOKEN,
376                              tag_name => chr ($self->{next_input_character})};                              tag_name => chr ($self->{next_input_character})};
377            $self->{state} = 'tag name';            $self->{state} = TAG_NAME_STATE;
378            !!!next-input-character;            !!!next-input-character;
379            redo A;            redo A;
380          } elsif ($self->{next_input_character} == 0x003E) { # >          } elsif ($self->{next_input_character} == 0x003E) { # >
381            !!!parse-error (type => 'empty start tag');            !!!parse-error (type => 'empty start tag');
382            $self->{state} = 'data';            $self->{state} = DATA_STATE;
383            !!!next-input-character;            !!!next-input-character;
384    
385            !!!emit ({type => 'character', data => '<>'});            !!!emit ({type => CHARACTER_TOKEN, data => '<>'});
386    
387            redo A;            redo A;
388          } elsif ($self->{next_input_character} == 0x003F) { # ?          } elsif ($self->{next_input_character} == 0x003F) { # ?
389            !!!parse-error (type => 'pio');            !!!parse-error (type => 'pio');
390            $self->{state} = 'bogus comment';            $self->{state} = BOGUS_COMMENT_STATE;
391            ## $self->{next_input_character} is intentionally left as is            ## $self->{next_input_character} is intentionally left as is
392            redo A;            redo A;
393          } else {          } else {
394            !!!parse-error (type => 'bare stago');            !!!parse-error (type => 'bare stago');
395            $self->{state} = 'data';            $self->{state} = DATA_STATE;
396            ## reconsume            ## reconsume
397    
398            !!!emit ({type => 'character', data => '<'});            !!!emit ({type => CHARACTER_TOKEN, data => '<'});
399    
400            redo A;            redo A;
401          }          }
402        } else {        } else {
403          die "$0: $self->{content_model_flag}: Unknown content model flag";          die "$0: $self->{content_model} in tag open";
404        }        }
405      } elsif ($self->{state} eq 'close tag open') {      } elsif ($self->{state} == CLOSE_TAG_OPEN_STATE) {
406        if ($self->{content_model_flag} eq 'RCDATA' or        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
407            $self->{content_model_flag} eq 'CDATA') {          if (defined $self->{last_emitted_start_tag_name}) {
408          my @next_char;            ## NOTE: <http://krijnhoetmer.nl/irc-logs/whatwg/20070626#l-564>
409          TAGNAME: for (my $i = 0; $i < length $self->{last_emitted_start_tag_name}; $i++) {            my @next_char;
410              TAGNAME: for (my $i = 0; $i < length $self->{last_emitted_start_tag_name}; $i++) {
411                push @next_char, $self->{next_input_character};
412                my $c = ord substr ($self->{last_emitted_start_tag_name}, $i, 1);
413                my $C = 0x0061 <= $c && $c <= 0x007A ? $c - 0x0020 : $c;
414                if ($self->{next_input_character} == $c or $self->{next_input_character} == $C) {
415                  !!!next-input-character;
416                  next TAGNAME;
417                } else {
418                  $self->{next_input_character} = shift @next_char; # reconsume
419                  !!!back-next-input-character (@next_char);
420                  $self->{state} = DATA_STATE;
421    
422                  !!!emit ({type => CHARACTER_TOKEN, data => '</'});
423      
424                  redo A;
425                }
426              }
427            push @next_char, $self->{next_input_character};            push @next_char, $self->{next_input_character};
428            my $c = ord substr ($self->{last_emitted_start_tag_name}, $i, 1);        
429            my $C = 0x0061 <= $c && $c <= 0x007A ? $c - 0x0020 : $c;            unless ($self->{next_input_character} == 0x0009 or # HT
430            if ($self->{next_input_character} == $c or $self->{next_input_character} == $C) {                    $self->{next_input_character} == 0x000A or # LF
431              !!!next-input-character;                    $self->{next_input_character} == 0x000B or # VT
432              next TAGNAME;                    $self->{next_input_character} == 0x000C or # FF
433            } else {                    $self->{next_input_character} == 0x0020 or # SP
434              !!!parse-error (type => 'unmatched end tag');                    $self->{next_input_character} == 0x003E or # >
435                      $self->{next_input_character} == 0x002F or # /
436                      $self->{next_input_character} == -1) {
437              $self->{next_input_character} = shift @next_char; # reconsume              $self->{next_input_character} = shift @next_char; # reconsume
438              !!!back-next-input-character (@next_char);              !!!back-next-input-character (@next_char);
439              $self->{state} = 'data';              $self->{state} = DATA_STATE;
440                !!!emit ({type => CHARACTER_TOKEN, data => '</'});
             !!!emit ({type => 'character', data => '</'});  
   
441              redo A;              redo A;
442              } else {
443                $self->{next_input_character} = shift @next_char;
444                !!!back-next-input-character (@next_char);
445                # and consume...
446            }            }
         }  
         push @next_char, $self->{next_input_character};  
       
         unless ($self->{next_input_character} == 0x0009 or # HT  
                 $self->{next_input_character} == 0x000A or # LF  
                 $self->{next_input_character} == 0x000B or # VT  
                 $self->{next_input_character} == 0x000C or # FF  
                 $self->{next_input_character} == 0x0020 or # SP  
                 $self->{next_input_character} == 0x003E or # >  
                 $self->{next_input_character} == 0x002F or # /  
                 $self->{next_input_character} == 0x003C or # <  
                 $self->{next_input_character} == -1) {  
           !!!parse-error (type => 'unmatched end tag');  
           $self->{next_input_character} = shift @next_char; # reconsume  
           !!!back-next-input-character (@next_char);  
           $self->{state} = 'data';  
   
           !!!emit ({type => 'character', data => '</'});  
   
           redo A;  
447          } else {          } else {
448            $self->{next_input_character} = shift @next_char;            ## No start tag token has ever been emitted
449            !!!back-next-input-character (@next_char);            # next-input-character is already done
450            # and consume...            $self->{state} = DATA_STATE;
451              !!!emit ({type => CHARACTER_TOKEN, data => '</'});
452              redo A;
453          }          }
454        }        }
455                
456        if (0x0041 <= $self->{next_input_character} and        if (0x0041 <= $self->{next_input_character} and
457            $self->{next_input_character} <= 0x005A) { # A..Z            $self->{next_input_character} <= 0x005A) { # A..Z
458          $self->{current_token} = {type => 'end tag',          $self->{current_token} = {type => END_TAG_TOKEN,
459                            tag_name => chr ($self->{next_input_character} + 0x0020)};                            tag_name => chr ($self->{next_input_character} + 0x0020)};
460          $self->{state} = 'tag name';          $self->{state} = TAG_NAME_STATE;
461          !!!next-input-character;          !!!next-input-character;
462          redo A;          redo A;
463        } elsif (0x0061 <= $self->{next_input_character} and        } elsif (0x0061 <= $self->{next_input_character} and
464                 $self->{next_input_character} <= 0x007A) { # a..z                 $self->{next_input_character} <= 0x007A) { # a..z
465          $self->{current_token} = {type => 'end tag',          $self->{current_token} = {type => END_TAG_TOKEN,
466                            tag_name => chr ($self->{next_input_character})};                            tag_name => chr ($self->{next_input_character})};
467          $self->{state} = 'tag name';          $self->{state} = TAG_NAME_STATE;
468          !!!next-input-character;          !!!next-input-character;
469          redo A;          redo A;
470        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
471          !!!parse-error (type => 'empty end tag');          !!!parse-error (type => 'empty end tag');
472          $self->{state} = 'data';          $self->{state} = DATA_STATE;
473          !!!next-input-character;          !!!next-input-character;
474          redo A;          redo A;
475        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
476          !!!parse-error (type => 'bare etago');          !!!parse-error (type => 'bare etago');
477          $self->{state} = 'data';          $self->{state} = DATA_STATE;
478          # reconsume          # reconsume
479    
480          !!!emit ({type => 'character', data => '</'});          !!!emit ({type => CHARACTER_TOKEN, data => '</'});
481    
482          redo A;          redo A;
483        } else {        } else {
484          !!!parse-error (type => 'bogus end tag');          !!!parse-error (type => 'bogus end tag');
485          $self->{state} = 'bogus comment';          $self->{state} = BOGUS_COMMENT_STATE;
486          ## $self->{next_input_character} is intentionally left as is          ## $self->{next_input_character} is intentionally left as is
487          redo A;          redo A;
488        }        }
489      } elsif ($self->{state} eq 'tag name') {      } elsif ($self->{state} == TAG_NAME_STATE) {
490        if ($self->{next_input_character} == 0x0009 or # HT        if ($self->{next_input_character} == 0x0009 or # HT
491            $self->{next_input_character} == 0x000A or # LF            $self->{next_input_character} == 0x000A or # LF
492            $self->{next_input_character} == 0x000B or # VT            $self->{next_input_character} == 0x000B or # VT
493            $self->{next_input_character} == 0x000C or # FF            $self->{next_input_character} == 0x000C or # FF
494            $self->{next_input_character} == 0x0020) { # SP            $self->{next_input_character} == 0x0020) { # SP
495          $self->{state} = 'before attribute name';          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
496          !!!next-input-character;          !!!next-input-character;
497          redo A;          redo A;
498        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
499          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
500              $self->{current_token}->{first_start_tag}
501                  = not defined $self->{last_emitted_start_tag_name};
502            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
503          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
504            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
505            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
506              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
507            }            }
508          } else {          } else {
509            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
510          }          }
511          $self->{state} = 'data';          $self->{state} = DATA_STATE;
512          !!!next-input-character;          !!!next-input-character;
513    
514          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
515    
516          redo A;          redo A;
517        } elsif (0x0041 <= $self->{next_input_character} and        } elsif (0x0041 <= $self->{next_input_character} and
# Line 709  sub _get_next_token ($) { Line 521  sub _get_next_token ($) {
521          ## Stay in this state          ## Stay in this state
522          !!!next-input-character;          !!!next-input-character;
523          redo A;          redo A;
524        } elsif ($self->{next_input_character} == 0x003C or # <        } elsif ($self->{next_input_character} == -1) {
                $self->{next_input_character} == -1) {  
525          !!!parse-error (type => 'unclosed tag');          !!!parse-error (type => 'unclosed tag');
526          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
527              $self->{current_token}->{first_start_tag}
528                  = not defined $self->{last_emitted_start_tag_name};
529            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
530          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
531            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
532            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
533              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
534            }            }
535          } else {          } else {
536            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
537          }          }
538          $self->{state} = 'data';          $self->{state} = DATA_STATE;
539          # reconsume          # reconsume
540    
541          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
542    
543          redo A;          redo A;
544        } elsif ($self->{next_input_character} == 0x002F) { # /        } elsif ($self->{next_input_character} == 0x002F) { # /
545          !!!next-input-character;          !!!next-input-character;
546          if ($self->{next_input_character} == 0x003E and # >          if ($self->{next_input_character} == 0x003E and # >
547              $self->{current_token}->{type} eq 'start tag' and              $self->{current_token}->{type} == START_TAG_TOKEN and
548              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
549            # permitted slash            # permitted slash
550            #            #
551          } else {          } else {
552            !!!parse-error (type => 'nestc');            !!!parse-error (type => 'nestc');
553          }          }
554          $self->{state} = 'before attribute name';          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
555          # next-input-character is already done          # next-input-character is already done
556          redo A;          redo A;
557        } else {        } else {
# Line 749  sub _get_next_token ($) { Line 561  sub _get_next_token ($) {
561          !!!next-input-character;          !!!next-input-character;
562          redo A;          redo A;
563        }        }
564      } elsif ($self->{state} eq 'before attribute name') {      } elsif ($self->{state} == BEFORE_ATTRIBUTE_NAME_STATE) {
565        if ($self->{next_input_character} == 0x0009 or # HT        if ($self->{next_input_character} == 0x0009 or # HT
566            $self->{next_input_character} == 0x000A or # LF            $self->{next_input_character} == 0x000A or # LF
567            $self->{next_input_character} == 0x000B or # VT            $self->{next_input_character} == 0x000B or # VT
# Line 759  sub _get_next_token ($) { Line 571  sub _get_next_token ($) {
571          !!!next-input-character;          !!!next-input-character;
572          redo A;          redo A;
573        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
574          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
575              $self->{current_token}->{first_start_tag}
576                  = not defined $self->{last_emitted_start_tag_name};
577            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
578          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
579            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
580            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
581              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
582            }            }
583          } else {          } else {
584            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
585          }          }
586          $self->{state} = 'data';          $self->{state} = DATA_STATE;
587          !!!next-input-character;          !!!next-input-character;
588    
589          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
590    
591          redo A;          redo A;
592        } elsif (0x0041 <= $self->{next_input_character} and        } elsif (0x0041 <= $self->{next_input_character} and
593                 $self->{next_input_character} <= 0x005A) { # A..Z                 $self->{next_input_character} <= 0x005A) { # A..Z
594          $self->{current_attribute} = {name => chr ($self->{next_input_character} + 0x0020),          $self->{current_attribute} = {name => chr ($self->{next_input_character} + 0x0020),
595                                value => ''};                                value => ''};
596          $self->{state} = 'attribute name';          $self->{state} = ATTRIBUTE_NAME_STATE;
597          !!!next-input-character;          !!!next-input-character;
598          redo A;          redo A;
599        } elsif ($self->{next_input_character} == 0x002F) { # /        } elsif ($self->{next_input_character} == 0x002F) { # /
600          !!!next-input-character;          !!!next-input-character;
601          if ($self->{next_input_character} == 0x003E and # >          if ($self->{next_input_character} == 0x003E and # >
602              $self->{current_token}->{type} eq 'start tag' and              $self->{current_token}->{type} == START_TAG_TOKEN and
603              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
604            # permitted slash            # permitted slash
605            #            #
# Line 796  sub _get_next_token ($) { Line 609  sub _get_next_token ($) {
609          ## Stay in the state          ## Stay in the state
610          # next-input-character is already done          # next-input-character is already done
611          redo A;          redo A;
612        } elsif ($self->{next_input_character} == 0x003C or # <        } elsif ($self->{next_input_character} == -1) {
                $self->{next_input_character} == -1) {  
613          !!!parse-error (type => 'unclosed tag');          !!!parse-error (type => 'unclosed tag');
614          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
615              $self->{current_token}->{first_start_tag}
616                  = not defined $self->{last_emitted_start_tag_name};
617            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
618          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
619            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
620            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
621              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
622            }            }
623          } else {          } else {
624            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
625          }          }
626          $self->{state} = 'data';          $self->{state} = DATA_STATE;
627          # reconsume          # reconsume
628    
629          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
630    
631          redo A;          redo A;
632        } else {        } else {
633          $self->{current_attribute} = {name => chr ($self->{next_input_character}),          $self->{current_attribute} = {name => chr ($self->{next_input_character}),
634                                value => ''};                                value => ''};
635          $self->{state} = 'attribute name';          $self->{state} = ATTRIBUTE_NAME_STATE;
636          !!!next-input-character;          !!!next-input-character;
637          redo A;          redo A;
638        }        }
639      } elsif ($self->{state} eq 'attribute name') {      } elsif ($self->{state} == ATTRIBUTE_NAME_STATE) {
640        my $before_leave = sub {        my $before_leave = sub {
641          if (exists $self->{current_token}->{attributes} # start tag or end tag          if (exists $self->{current_token}->{attributes} # start tag or end tag
642              ->{$self->{current_attribute}->{name}}) { # MUST              ->{$self->{current_attribute}->{name}}) { # MUST
643            !!!parse-error (type => 'dupulicate attribute');            !!!parse-error (type => 'duplicate attribute:'.$self->{current_attribute}->{name});
644            ## Discard $self->{current_attribute} # MUST            ## Discard $self->{current_attribute} # MUST
645          } else {          } else {
646            $self->{current_token}->{attributes}->{$self->{current_attribute}->{name}}            $self->{current_token}->{attributes}->{$self->{current_attribute}->{name}}
# Line 841  sub _get_next_token ($) { Line 654  sub _get_next_token ($) {
654            $self->{next_input_character} == 0x000C or # FF            $self->{next_input_character} == 0x000C or # FF
655            $self->{next_input_character} == 0x0020) { # SP            $self->{next_input_character} == 0x0020) { # SP
656          $before_leave->();          $before_leave->();
657          $self->{state} = 'after attribute name';          $self->{state} = AFTER_ATTRIBUTE_NAME_STATE;
658          !!!next-input-character;          !!!next-input-character;
659          redo A;          redo A;
660        } elsif ($self->{next_input_character} == 0x003D) { # =        } elsif ($self->{next_input_character} == 0x003D) { # =
661          $before_leave->();          $before_leave->();
662          $self->{state} = 'before attribute value';          $self->{state} = BEFORE_ATTRIBUTE_VALUE_STATE;
663          !!!next-input-character;          !!!next-input-character;
664          redo A;          redo A;
665        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
666          $before_leave->();          $before_leave->();
667          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
668              $self->{current_token}->{first_start_tag}
669                  = not defined $self->{last_emitted_start_tag_name};
670            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
671          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
672            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
673            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
674              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
675            }            }
676          } else {          } else {
677            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
678          }          }
679          $self->{state} = 'data';          $self->{state} = DATA_STATE;
680          !!!next-input-character;          !!!next-input-character;
681    
682          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
683    
684          redo A;          redo A;
685        } elsif (0x0041 <= $self->{next_input_character} and        } elsif (0x0041 <= $self->{next_input_character} and
# Line 878  sub _get_next_token ($) { Line 692  sub _get_next_token ($) {
692          $before_leave->();          $before_leave->();
693          !!!next-input-character;          !!!next-input-character;
694          if ($self->{next_input_character} == 0x003E and # >          if ($self->{next_input_character} == 0x003E and # >
695              $self->{current_token}->{type} eq 'start tag' and              $self->{current_token}->{type} == START_TAG_TOKEN and
696              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
697            # permitted slash            # permitted slash
698            #            #
699          } else {          } else {
700            !!!parse-error (type => 'nestc');            !!!parse-error (type => 'nestc');
701          }          }
702          $self->{state} = 'before attribute name';          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
703          # next-input-character is already done          # next-input-character is already done
704          redo A;          redo A;
705        } elsif ($self->{next_input_character} == 0x003C or # <        } elsif ($self->{next_input_character} == -1) {
                $self->{next_input_character} == -1) {  
706          !!!parse-error (type => 'unclosed tag');          !!!parse-error (type => 'unclosed tag');
707          $before_leave->();          $before_leave->();
708          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
709              $self->{current_token}->{first_start_tag}
710                  = not defined $self->{last_emitted_start_tag_name};
711            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
712          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
713            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
714            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
715              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
716            }            }
717          } else {          } else {
718            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
719          }          }
720          $self->{state} = 'data';          $self->{state} = DATA_STATE;
721          # reconsume          # reconsume
722    
723          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
724    
725          redo A;          redo A;
726        } else {        } else {
# Line 915  sub _get_next_token ($) { Line 729  sub _get_next_token ($) {
729          !!!next-input-character;          !!!next-input-character;
730          redo A;          redo A;
731        }        }
732      } elsif ($self->{state} eq 'after attribute name') {      } elsif ($self->{state} == AFTER_ATTRIBUTE_NAME_STATE) {
733        if ($self->{next_input_character} == 0x0009 or # HT        if ($self->{next_input_character} == 0x0009 or # HT
734            $self->{next_input_character} == 0x000A or # LF            $self->{next_input_character} == 0x000A or # LF
735            $self->{next_input_character} == 0x000B or # VT            $self->{next_input_character} == 0x000B or # VT
# Line 925  sub _get_next_token ($) { Line 739  sub _get_next_token ($) {
739          !!!next-input-character;          !!!next-input-character;
740          redo A;          redo A;
741        } elsif ($self->{next_input_character} == 0x003D) { # =        } elsif ($self->{next_input_character} == 0x003D) { # =
742          $self->{state} = 'before attribute value';          $self->{state} = BEFORE_ATTRIBUTE_VALUE_STATE;
743          !!!next-input-character;          !!!next-input-character;
744          redo A;          redo A;
745        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
746          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
747              $self->{current_token}->{first_start_tag}
748                  = not defined $self->{last_emitted_start_tag_name};
749            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
750          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
751            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
752            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
753              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
754            }            }
755          } else {          } else {
756            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
757          }          }
758          $self->{state} = 'data';          $self->{state} = DATA_STATE;
759          !!!next-input-character;          !!!next-input-character;
760    
761          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
762    
763          redo A;          redo A;
764        } elsif (0x0041 <= $self->{next_input_character} and        } elsif (0x0041 <= $self->{next_input_character} and
765                 $self->{next_input_character} <= 0x005A) { # A..Z                 $self->{next_input_character} <= 0x005A) { # A..Z
766          $self->{current_attribute} = {name => chr ($self->{next_input_character} + 0x0020),          $self->{current_attribute} = {name => chr ($self->{next_input_character} + 0x0020),
767                                value => ''};                                value => ''};
768          $self->{state} = 'attribute name';          $self->{state} = ATTRIBUTE_NAME_STATE;
769          !!!next-input-character;          !!!next-input-character;
770          redo A;          redo A;
771        } elsif ($self->{next_input_character} == 0x002F) { # /        } elsif ($self->{next_input_character} == 0x002F) { # /
772          !!!next-input-character;          !!!next-input-character;
773          if ($self->{next_input_character} == 0x003E and # >          if ($self->{next_input_character} == 0x003E and # >
774              $self->{current_token}->{type} eq 'start tag' and              $self->{current_token}->{type} == START_TAG_TOKEN and
775              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
776            # permitted slash            # permitted slash
777            #            #
778          } else {          } else {
779            !!!parse-error (type => 'nestc');            !!!parse-error (type => 'nestc');
780              ## TODO: Different error type for <aa / bb> than <aa/>
781          }          }
782          $self->{state} = 'before attribute name';          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
783          # next-input-character is already done          # next-input-character is already done
784          redo A;          redo A;
785        } elsif ($self->{next_input_character} == 0x003C or # <        } elsif ($self->{next_input_character} == -1) {
                $self->{next_input_character} == -1) {  
786          !!!parse-error (type => 'unclosed tag');          !!!parse-error (type => 'unclosed tag');
787          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
788              $self->{current_token}->{first_start_tag}
789                  = not defined $self->{last_emitted_start_tag_name};
790            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
791          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
792            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
793            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
794              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
795            }            }
796          } else {          } else {
797            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
798          }          }
799          $self->{state} = 'data';          $self->{state} = DATA_STATE;
800          # reconsume          # reconsume
801    
802          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
803    
804          redo A;          redo A;
805        } else {        } else {
806          $self->{current_attribute} = {name => chr ($self->{next_input_character}),          $self->{current_attribute} = {name => chr ($self->{next_input_character}),
807                                value => ''};                                value => ''};
808          $self->{state} = 'attribute name';          $self->{state} = ATTRIBUTE_NAME_STATE;
809          !!!next-input-character;          !!!next-input-character;
810          redo A;                  redo A;        
811        }        }
812      } elsif ($self->{state} eq 'before attribute value') {      } elsif ($self->{state} == BEFORE_ATTRIBUTE_VALUE_STATE) {
813        if ($self->{next_input_character} == 0x0009 or # HT        if ($self->{next_input_character} == 0x0009 or # HT
814            $self->{next_input_character} == 0x000A or # LF            $self->{next_input_character} == 0x000A or # LF
815            $self->{next_input_character} == 0x000B or # VT            $self->{next_input_character} == 0x000B or # VT
# Line 1003  sub _get_next_token ($) { Line 819  sub _get_next_token ($) {
819          !!!next-input-character;          !!!next-input-character;
820          redo A;          redo A;
821        } elsif ($self->{next_input_character} == 0x0022) { # "        } elsif ($self->{next_input_character} == 0x0022) { # "
822          $self->{state} = 'attribute value (double-quoted)';          $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
823          !!!next-input-character;          !!!next-input-character;
824          redo A;          redo A;
825        } elsif ($self->{next_input_character} == 0x0026) { # &        } elsif ($self->{next_input_character} == 0x0026) { # &
826          $self->{state} = 'attribute value (unquoted)';          $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
827          ## reconsume          ## reconsume
828          redo A;          redo A;
829        } elsif ($self->{next_input_character} == 0x0027) { # '        } elsif ($self->{next_input_character} == 0x0027) { # '
830          $self->{state} = 'attribute value (single-quoted)';          $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
831          !!!next-input-character;          !!!next-input-character;
832          redo A;          redo A;
833        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
834          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
835              $self->{current_token}->{first_start_tag}
836                  = not defined $self->{last_emitted_start_tag_name};
837            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
838          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
839            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
840            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
841              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
842            }            }
843          } else {          } else {
844            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
845          }          }
846          $self->{state} = 'data';          $self->{state} = DATA_STATE;
847          !!!next-input-character;          !!!next-input-character;
848    
849          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
850    
851          redo A;          redo A;
852        } elsif ($self->{next_input_character} == 0x003C or # <        } elsif ($self->{next_input_character} == -1) {
                $self->{next_input_character} == -1) {  
853          !!!parse-error (type => 'unclosed tag');          !!!parse-error (type => 'unclosed tag');
854          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
855              $self->{current_token}->{first_start_tag}
856                  = not defined $self->{last_emitted_start_tag_name};
857            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
858          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
859            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
860            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
861              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
862            }            }
863          } else {          } else {
864            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
865          }          }
866          $self->{state} = 'data';          $self->{state} = DATA_STATE;
867          ## reconsume          ## reconsume
868    
869          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
870    
871          redo A;          redo A;
872        } else {        } else {
873          $self->{current_attribute}->{value} .= chr ($self->{next_input_character});          $self->{current_attribute}->{value} .= chr ($self->{next_input_character});
874          $self->{state} = 'attribute value (unquoted)';          $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
875          !!!next-input-character;          !!!next-input-character;
876          redo A;          redo A;
877        }        }
878      } elsif ($self->{state} eq 'attribute value (double-quoted)') {      } elsif ($self->{state} == ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE) {
879        if ($self->{next_input_character} == 0x0022) { # "        if ($self->{next_input_character} == 0x0022) { # "
880          $self->{state} = 'before attribute name';          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
881          !!!next-input-character;          !!!next-input-character;
882          redo A;          redo A;
883        } elsif ($self->{next_input_character} == 0x0026) { # &        } elsif ($self->{next_input_character} == 0x0026) { # &
884          $self->{last_attribute_value_state} = 'attribute value (double-quoted)';          $self->{last_attribute_value_state} = $self->{state};
885          $self->{state} = 'entity in attribute value';          $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;
886          !!!next-input-character;          !!!next-input-character;
887          redo A;          redo A;
888        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
889          !!!parse-error (type => 'unclosed attribute value');          !!!parse-error (type => 'unclosed attribute value');
890          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
891              $self->{current_token}->{first_start_tag}
892                  = not defined $self->{last_emitted_start_tag_name};
893            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
894          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
895            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
896            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
897              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
898            }            }
899          } else {          } else {
900            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
901          }          }
902          $self->{state} = 'data';          $self->{state} = DATA_STATE;
903          ## reconsume          ## reconsume
904    
905          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
906    
907          redo A;          redo A;
908        } else {        } else {
# Line 1093  sub _get_next_token ($) { Line 911  sub _get_next_token ($) {
911          !!!next-input-character;          !!!next-input-character;
912          redo A;          redo A;
913        }        }
914      } elsif ($self->{state} eq 'attribute value (single-quoted)') {      } elsif ($self->{state} == ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE) {
915        if ($self->{next_input_character} == 0x0027) { # '        if ($self->{next_input_character} == 0x0027) { # '
916          $self->{state} = 'before attribute name';          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
917          !!!next-input-character;          !!!next-input-character;
918          redo A;          redo A;
919        } elsif ($self->{next_input_character} == 0x0026) { # &        } elsif ($self->{next_input_character} == 0x0026) { # &
920          $self->{last_attribute_value_state} = 'attribute value (single-quoted)';          $self->{last_attribute_value_state} = $self->{state};
921          $self->{state} = 'entity in attribute value';          $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;
922          !!!next-input-character;          !!!next-input-character;
923          redo A;          redo A;
924        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
925          !!!parse-error (type => 'unclosed attribute value');          !!!parse-error (type => 'unclosed attribute value');
926          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
927              $self->{current_token}->{first_start_tag}
928                  = not defined $self->{last_emitted_start_tag_name};
929            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
930          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
931            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
932            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
933              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
934            }            }
935          } else {          } else {
936            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
937          }          }
938          $self->{state} = 'data';          $self->{state} = DATA_STATE;
939          ## reconsume          ## reconsume
940    
941          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
942    
943          redo A;          redo A;
944        } else {        } else {
# Line 1128  sub _get_next_token ($) { Line 947  sub _get_next_token ($) {
947          !!!next-input-character;          !!!next-input-character;
948          redo A;          redo A;
949        }        }
950      } elsif ($self->{state} eq 'attribute value (unquoted)') {      } elsif ($self->{state} == ATTRIBUTE_VALUE_UNQUOTED_STATE) {
951        if ($self->{next_input_character} == 0x0009 or # HT        if ($self->{next_input_character} == 0x0009 or # HT
952            $self->{next_input_character} == 0x000A or # LF            $self->{next_input_character} == 0x000A or # LF
953            $self->{next_input_character} == 0x000B or # HT            $self->{next_input_character} == 0x000B or # HT
954            $self->{next_input_character} == 0x000C or # FF            $self->{next_input_character} == 0x000C or # FF
955            $self->{next_input_character} == 0x0020) { # SP            $self->{next_input_character} == 0x0020) { # SP
956          $self->{state} = 'before attribute name';          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
957          !!!next-input-character;          !!!next-input-character;
958          redo A;          redo A;
959        } elsif ($self->{next_input_character} == 0x0026) { # &        } elsif ($self->{next_input_character} == 0x0026) { # &
960          $self->{last_attribute_value_state} = 'attribute value (unquoted)';          $self->{last_attribute_value_state} = $self->{state};
961          $self->{state} = 'entity in attribute value';          $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;
962          !!!next-input-character;          !!!next-input-character;
963          redo A;          redo A;
964        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
965          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
966              $self->{current_token}->{first_start_tag}
967                  = not defined $self->{last_emitted_start_tag_name};
968            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
969          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
970            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
971            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
972              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
973            }            }
974          } else {          } else {
975            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
976          }          }
977          $self->{state} = 'data';          $self->{state} = DATA_STATE;
978          !!!next-input-character;          !!!next-input-character;
979    
980          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
981    
982          redo A;          redo A;
983        } elsif ($self->{next_input_character} == 0x003C or # <        } elsif ($self->{next_input_character} == -1) {
                $self->{next_input_character} == -1) {  
984          !!!parse-error (type => 'unclosed tag');          !!!parse-error (type => 'unclosed tag');
985          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
986              $self->{current_token}->{first_start_tag}
987                  = not defined $self->{last_emitted_start_tag_name};
988            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
989          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
990            $self->{content_model_flag} = 'PCDATA'; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
991            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
992              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
993            }            }
994          } else {          } else {
995            die "$0: $self->{current_token}->{type}: Unknown token type";            die "$0: $self->{current_token}->{type}: Unknown token type";
996          }          }
997          $self->{state} = 'data';          $self->{state} = DATA_STATE;
998          ## reconsume          ## reconsume
999    
1000          !!!emit ($self->{current_token}); # start tag or end tag          !!!emit ($self->{current_token}); # start tag or end tag
         undef $self->{current_token};  
1001    
1002          redo A;          redo A;
1003        } else {        } else {
# Line 1186  sub _get_next_token ($) { Line 1006  sub _get_next_token ($) {
1006          !!!next-input-character;          !!!next-input-character;
1007          redo A;          redo A;
1008        }        }
1009      } elsif ($self->{state} eq 'entity in attribute value') {      } elsif ($self->{state} == ENTITY_IN_ATTRIBUTE_VALUE_STATE) {
1010        my $token = $self->_tokenize_attempt_to_consume_an_entity;        my $token = $self->_tokenize_attempt_to_consume_an_entity (1);
1011    
1012        unless (defined $token) {        unless (defined $token) {
1013          $self->{current_attribute}->{value} .= '&';          $self->{current_attribute}->{value} .= '&';
# Line 1199  sub _get_next_token ($) { Line 1019  sub _get_next_token ($) {
1019        $self->{state} = $self->{last_attribute_value_state};        $self->{state} = $self->{last_attribute_value_state};
1020        # next-input-character is already done        # next-input-character is already done
1021        redo A;        redo A;
1022      } elsif ($self->{state} eq 'bogus comment') {      } elsif ($self->{state} == BOGUS_COMMENT_STATE) {
1023        ## (only happen if PCDATA state)        ## (only happen if PCDATA state)
1024                
1025        my $token = {type => 'comment', data => ''};        my $token = {type => COMMENT_TOKEN, data => ''};
1026    
1027        BC: {        BC: {
1028          if ($self->{next_input_character} == 0x003E) { # >          if ($self->{next_input_character} == 0x003E) { # >
1029            $self->{state} = 'data';            $self->{state} = DATA_STATE;
1030            !!!next-input-character;            !!!next-input-character;
1031    
1032            !!!emit ($token);            !!!emit ($token);
1033    
1034            redo A;            redo A;
1035          } elsif ($self->{next_input_character} == -1) {          } elsif ($self->{next_input_character} == -1) {
1036            $self->{state} = 'data';            $self->{state} = DATA_STATE;
1037            ## reconsume            ## reconsume
1038    
1039            !!!emit ($token);            !!!emit ($token);
# Line 1225  sub _get_next_token ($) { Line 1045  sub _get_next_token ($) {
1045            redo BC;            redo BC;
1046          }          }
1047        } # BC        } # BC
1048      } elsif ($self->{state} eq 'markup declaration open') {      } elsif ($self->{state} == MARKUP_DECLARATION_OPEN_STATE) {
1049        ## (only happen if PCDATA state)        ## (only happen if PCDATA state)
1050    
1051        my @next_char;        my @next_char;
# Line 1235  sub _get_next_token ($) { Line 1055  sub _get_next_token ($) {
1055          !!!next-input-character;          !!!next-input-character;
1056          push @next_char, $self->{next_input_character};          push @next_char, $self->{next_input_character};
1057          if ($self->{next_input_character} == 0x002D) { # -          if ($self->{next_input_character} == 0x002D) { # -
1058            $self->{current_token} = {type => 'comment', data => ''};            $self->{current_token} = {type => COMMENT_TOKEN, data => ''};
1059            $self->{state} = 'comment';            $self->{state} = COMMENT_START_STATE;
1060            !!!next-input-character;            !!!next-input-character;
1061            redo A;            redo A;
1062          }          }
# Line 1267  sub _get_next_token ($) { Line 1087  sub _get_next_token ($) {
1087                    if ($self->{next_input_character} == 0x0045 or # E                    if ($self->{next_input_character} == 0x0045 or # E
1088                        $self->{next_input_character} == 0x0065) { # e                        $self->{next_input_character} == 0x0065) { # e
1089                      ## ISSUE: What a stupid code this is!                      ## ISSUE: What a stupid code this is!
1090                      $self->{state} = 'DOCTYPE';                      $self->{state} = DOCTYPE_STATE;
1091                      !!!next-input-character;                      !!!next-input-character;
1092                      redo A;                      redo A;
1093                    }                    }
# Line 1278  sub _get_next_token ($) { Line 1098  sub _get_next_token ($) {
1098          }          }
1099        }        }
1100    
1101        !!!parse-error (type => 'bogus comment open');        !!!parse-error (type => 'bogus comment');
1102        $self->{next_input_character} = shift @next_char;        $self->{next_input_character} = shift @next_char;
1103        !!!back-next-input-character (@next_char);        !!!back-next-input-character (@next_char);
1104        $self->{state} = 'bogus comment';        $self->{state} = BOGUS_COMMENT_STATE;
1105        redo A;        redo A;
1106                
1107        ## ISSUE: typos in spec: chacacters, is is a parse error        ## ISSUE: typos in spec: chacacters, is is a parse error
1108        ## 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?        ## 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?
1109      } elsif ($self->{state} eq 'comment') {      } elsif ($self->{state} == COMMENT_START_STATE) {
1110        if ($self->{next_input_character} == 0x002D) { # -        if ($self->{next_input_character} == 0x002D) { # -
1111          $self->{state} = 'comment dash';          $self->{state} = COMMENT_START_DASH_STATE;
1112          !!!next-input-character;          !!!next-input-character;
1113          redo A;          redo A;
1114          } elsif ($self->{next_input_character} == 0x003E) { # >
1115            !!!parse-error (type => 'bogus comment');
1116            $self->{state} = DATA_STATE;
1117            !!!next-input-character;
1118    
1119            !!!emit ($self->{current_token}); # comment
1120    
1121            redo A;
1122        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
1123          !!!parse-error (type => 'unclosed comment');          !!!parse-error (type => 'unclosed comment');
1124          $self->{state} = 'data';          $self->{state} = DATA_STATE;
1125            ## reconsume
1126    
1127            !!!emit ($self->{current_token}); # comment
1128    
1129            redo A;
1130          } else {
1131            $self->{current_token}->{data} # comment
1132                .= chr ($self->{next_input_character});
1133            $self->{state} = COMMENT_STATE;
1134            !!!next-input-character;
1135            redo A;
1136          }
1137        } elsif ($self->{state} == COMMENT_START_DASH_STATE) {
1138          if ($self->{next_input_character} == 0x002D) { # -
1139            $self->{state} = COMMENT_END_STATE;
1140            !!!next-input-character;
1141            redo A;
1142          } elsif ($self->{next_input_character} == 0x003E) { # >
1143            !!!parse-error (type => 'bogus comment');
1144            $self->{state} = DATA_STATE;
1145            !!!next-input-character;
1146    
1147            !!!emit ($self->{current_token}); # comment
1148    
1149            redo A;
1150          } elsif ($self->{next_input_character} == -1) {
1151            !!!parse-error (type => 'unclosed comment');
1152            $self->{state} = DATA_STATE;
1153            ## reconsume
1154    
1155            !!!emit ($self->{current_token}); # comment
1156    
1157            redo A;
1158          } else {
1159            $self->{current_token}->{data} # comment
1160                .= '-' . chr ($self->{next_input_character});
1161            $self->{state} = COMMENT_STATE;
1162            !!!next-input-character;
1163            redo A;
1164          }
1165        } elsif ($self->{state} == COMMENT_STATE) {
1166          if ($self->{next_input_character} == 0x002D) { # -
1167            $self->{state} = COMMENT_END_DASH_STATE;
1168            !!!next-input-character;
1169            redo A;
1170          } elsif ($self->{next_input_character} == -1) {
1171            !!!parse-error (type => 'unclosed comment');
1172            $self->{state} = DATA_STATE;
1173          ## reconsume          ## reconsume
1174    
1175          !!!emit ($self->{current_token}); # comment          !!!emit ($self->{current_token}); # comment
         undef $self->{current_token};  
1176    
1177          redo A;          redo A;
1178        } else {        } else {
# Line 1306  sub _get_next_token ($) { Line 1181  sub _get_next_token ($) {
1181          !!!next-input-character;          !!!next-input-character;
1182          redo A;          redo A;
1183        }        }
1184      } elsif ($self->{state} eq 'comment dash') {      } elsif ($self->{state} == COMMENT_END_DASH_STATE) {
1185        if ($self->{next_input_character} == 0x002D) { # -        if ($self->{next_input_character} == 0x002D) { # -
1186          $self->{state} = 'comment end';          $self->{state} = COMMENT_END_STATE;
1187          !!!next-input-character;          !!!next-input-character;
1188          redo A;          redo A;
1189        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
1190          !!!parse-error (type => 'unclosed comment');          !!!parse-error (type => 'unclosed comment');
1191          $self->{state} = 'data';          $self->{state} = DATA_STATE;
1192          ## reconsume          ## reconsume
1193    
1194          !!!emit ($self->{current_token}); # comment          !!!emit ($self->{current_token}); # comment
         undef $self->{current_token};  
1195    
1196          redo A;          redo A;
1197        } else {        } else {
1198          $self->{current_token}->{data} .= '-' . chr ($self->{next_input_character}); # comment          $self->{current_token}->{data} .= '-' . chr ($self->{next_input_character}); # comment
1199          $self->{state} = 'comment';          $self->{state} = COMMENT_STATE;
1200          !!!next-input-character;          !!!next-input-character;
1201          redo A;          redo A;
1202        }        }
1203      } elsif ($self->{state} eq 'comment end') {      } elsif ($self->{state} == COMMENT_END_STATE) {
1204        if ($self->{next_input_character} == 0x003E) { # >        if ($self->{next_input_character} == 0x003E) { # >
1205          $self->{state} = 'data';          $self->{state} = DATA_STATE;
1206          !!!next-input-character;          !!!next-input-character;
1207    
1208          !!!emit ($self->{current_token}); # comment          !!!emit ($self->{current_token}); # comment
         undef $self->{current_token};  
1209    
1210          redo A;          redo A;
1211        } elsif ($self->{next_input_character} == 0x002D) { # -        } elsif ($self->{next_input_character} == 0x002D) { # -
# Line 1343  sub _get_next_token ($) { Line 1216  sub _get_next_token ($) {
1216          redo A;          redo A;
1217        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
1218          !!!parse-error (type => 'unclosed comment');          !!!parse-error (type => 'unclosed comment');
1219          $self->{state} = 'data';          $self->{state} = DATA_STATE;
1220          ## reconsume          ## reconsume
1221    
1222          !!!emit ($self->{current_token}); # comment          !!!emit ($self->{current_token}); # comment
         undef $self->{current_token};  
1223    
1224          redo A;          redo A;
1225        } else {        } else {
1226          !!!parse-error (type => 'dash in comment');          !!!parse-error (type => 'dash in comment');
1227          $self->{current_token}->{data} .= '--' . chr ($self->{next_input_character}); # comment          $self->{current_token}->{data} .= '--' . chr ($self->{next_input_character}); # comment
1228          $self->{state} = 'comment';          $self->{state} = COMMENT_STATE;
1229          !!!next-input-character;          !!!next-input-character;
1230          redo A;          redo A;
1231        }        }
1232      } elsif ($self->{state} eq 'DOCTYPE') {      } elsif ($self->{state} == DOCTYPE_STATE) {
1233        if ($self->{next_input_character} == 0x0009 or # HT        if ($self->{next_input_character} == 0x0009 or # HT
1234            $self->{next_input_character} == 0x000A or # LF            $self->{next_input_character} == 0x000A or # LF
1235            $self->{next_input_character} == 0x000B or # VT            $self->{next_input_character} == 0x000B or # VT
1236            $self->{next_input_character} == 0x000C or # FF            $self->{next_input_character} == 0x000C or # FF
1237            $self->{next_input_character} == 0x0020) { # SP            $self->{next_input_character} == 0x0020) { # SP
1238          $self->{state} = 'before DOCTYPE name';          $self->{state} = BEFORE_DOCTYPE_NAME_STATE;
1239          !!!next-input-character;          !!!next-input-character;
1240          redo A;          redo A;
1241        } else {        } else {
1242          !!!parse-error (type => 'no space before DOCTYPE name');          !!!parse-error (type => 'no space before DOCTYPE name');
1243          $self->{state} = 'before DOCTYPE name';          $self->{state} = BEFORE_DOCTYPE_NAME_STATE;
1244          ## reconsume          ## reconsume
1245          redo A;          redo A;
1246        }        }
1247      } elsif ($self->{state} eq 'before DOCTYPE name') {      } elsif ($self->{state} == BEFORE_DOCTYPE_NAME_STATE) {
1248        if ($self->{next_input_character} == 0x0009 or # HT        if ($self->{next_input_character} == 0x0009 or # HT
1249            $self->{next_input_character} == 0x000A or # LF            $self->{next_input_character} == 0x000A or # LF
1250            $self->{next_input_character} == 0x000B or # VT            $self->{next_input_character} == 0x000B or # VT
# Line 1381  sub _get_next_token ($) { Line 1253  sub _get_next_token ($) {
1253          ## Stay in the state          ## Stay in the state
1254          !!!next-input-character;          !!!next-input-character;
1255          redo A;          redo A;
       } elsif (0x0061 <= $self->{next_input_character} and  
                $self->{next_input_character} <= 0x007A) { # a..z  
 ## ISSUE: "Set the token's name name to the" in the spec  
         $self->{current_token} = {type => 'DOCTYPE',  
                           name => chr ($self->{next_input_character} - 0x0020),  
                           error => 1};  
         $self->{state} = 'DOCTYPE name';  
         !!!next-input-character;  
         redo A;  
1256        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
1257          !!!parse-error (type => 'no DOCTYPE name');          !!!parse-error (type => 'no DOCTYPE name');
1258          $self->{state} = 'data';          $self->{state} = DATA_STATE;
1259          !!!next-input-character;          !!!next-input-character;
1260    
1261          !!!emit ({type => 'DOCTYPE', name => '', error => 1});          !!!emit ({type => DOCTYPE_TOKEN}); # incorrect
1262    
1263          redo A;          redo A;
1264        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
1265          !!!parse-error (type => 'no DOCTYPE name');          !!!parse-error (type => 'no DOCTYPE name');
1266          $self->{state} = 'data';          $self->{state} = DATA_STATE;
1267          ## reconsume          ## reconsume
1268    
1269          !!!emit ({type => 'DOCTYPE', name => '', error => 1});          !!!emit ({type => DOCTYPE_TOKEN}); # incorrect
1270    
1271          redo A;          redo A;
1272        } else {        } else {
1273          $self->{current_token} = {type => 'DOCTYPE',          $self->{current_token}
1274                            name => chr ($self->{next_input_character}),              = {type => DOCTYPE_TOKEN,
1275                            error => 1};                 name => chr ($self->{next_input_character}),
1276                   correct => 1};
1277  ## ISSUE: "Set the token's name name to the" in the spec  ## ISSUE: "Set the token's name name to the" in the spec
1278          $self->{state} = 'DOCTYPE name';          $self->{state} = DOCTYPE_NAME_STATE;
1279          !!!next-input-character;          !!!next-input-character;
1280          redo A;          redo A;
1281        }        }
1282      } elsif ($self->{state} eq 'DOCTYPE name') {      } elsif ($self->{state} == DOCTYPE_NAME_STATE) {
1283    ## ISSUE: Redundant "First," in the spec.
1284        if ($self->{next_input_character} == 0x0009 or # HT        if ($self->{next_input_character} == 0x0009 or # HT
1285            $self->{next_input_character} == 0x000A or # LF            $self->{next_input_character} == 0x000A or # LF
1286            $self->{next_input_character} == 0x000B or # VT            $self->{next_input_character} == 0x000B or # VT
1287            $self->{next_input_character} == 0x000C or # FF            $self->{next_input_character} == 0x000C or # FF
1288            $self->{next_input_character} == 0x0020) { # SP            $self->{next_input_character} == 0x0020) { # SP
1289          $self->{current_token}->{error} = ($self->{current_token}->{name} ne 'HTML'); # DOCTYPE          $self->{state} = AFTER_DOCTYPE_NAME_STATE;
         $self->{state} = 'after DOCTYPE name';  
1290          !!!next-input-character;          !!!next-input-character;
1291          redo A;          redo A;
1292        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
1293          $self->{current_token}->{error} = ($self->{current_token}->{name} ne 'HTML'); # DOCTYPE          $self->{state} = DATA_STATE;
         $self->{state} = 'data';  
1294          !!!next-input-character;          !!!next-input-character;
1295    
1296          !!!emit ($self->{current_token}); # DOCTYPE          !!!emit ($self->{current_token}); # DOCTYPE
         undef $self->{current_token};  
1297    
1298          redo A;          redo A;
       } elsif (0x0061 <= $self->{next_input_character} and  
                $self->{next_input_character} <= 0x007A) { # a..z  
         $self->{current_token}->{name} .= chr ($self->{next_input_character} - 0x0020); # DOCTYPE  
         #$self->{current_token}->{error} = ($self->{current_token}->{name} ne 'HTML');  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
1299        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
1300          !!!parse-error (type => 'unclosed DOCTYPE');          !!!parse-error (type => 'unclosed DOCTYPE');
1301          $self->{current_token}->{error} = ($self->{current_token}->{name} ne 'HTML'); # DOCTYPE          $self->{state} = DATA_STATE;
         $self->{state} = 'data';  
1302          ## reconsume          ## reconsume
1303    
1304          !!!emit ($self->{current_token});          delete $self->{current_token}->{correct};
1305          undef $self->{current_token};          !!!emit ($self->{current_token}); # DOCTYPE
1306    
1307          redo A;          redo A;
1308        } else {        } else {
1309          $self->{current_token}->{name}          $self->{current_token}->{name}
1310            .= chr ($self->{next_input_character}); # DOCTYPE            .= chr ($self->{next_input_character}); # DOCTYPE
         #$self->{current_token}->{error} = ($self->{current_token}->{name} ne 'HTML');  
1311          ## Stay in the state          ## Stay in the state
1312          !!!next-input-character;          !!!next-input-character;
1313          redo A;          redo A;
1314        }        }
1315      } elsif ($self->{state} eq 'after DOCTYPE name') {      } elsif ($self->{state} == AFTER_DOCTYPE_NAME_STATE) {
1316        if ($self->{next_input_character} == 0x0009 or # HT        if ($self->{next_input_character} == 0x0009 or # HT
1317            $self->{next_input_character} == 0x000A or # LF            $self->{next_input_character} == 0x000A or # LF
1318            $self->{next_input_character} == 0x000B or # VT            $self->{next_input_character} == 0x000B or # VT
# Line 1469  sub _get_next_token ($) { Line 1322  sub _get_next_token ($) {
1322          !!!next-input-character;          !!!next-input-character;
1323          redo A;          redo A;
1324        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
1325          $self->{state} = 'data';          $self->{state} = DATA_STATE;
1326            !!!next-input-character;
1327    
1328            !!!emit ($self->{current_token}); # DOCTYPE
1329    
1330            redo A;
1331          } elsif ($self->{next_input_character} == -1) {
1332            !!!parse-error (type => 'unclosed DOCTYPE');
1333            $self->{state} = DATA_STATE;
1334            ## reconsume
1335    
1336            delete $self->{current_token}->{correct};
1337            !!!emit ($self->{current_token}); # DOCTYPE
1338    
1339            redo A;
1340          } elsif ($self->{next_input_character} == 0x0050 or # P
1341                   $self->{next_input_character} == 0x0070) { # p
1342            !!!next-input-character;
1343            if ($self->{next_input_character} == 0x0055 or # U
1344                $self->{next_input_character} == 0x0075) { # u
1345              !!!next-input-character;
1346              if ($self->{next_input_character} == 0x0042 or # B
1347                  $self->{next_input_character} == 0x0062) { # b
1348                !!!next-input-character;
1349                if ($self->{next_input_character} == 0x004C or # L
1350                    $self->{next_input_character} == 0x006C) { # l
1351                  !!!next-input-character;
1352                  if ($self->{next_input_character} == 0x0049 or # I
1353                      $self->{next_input_character} == 0x0069) { # i
1354                    !!!next-input-character;
1355                    if ($self->{next_input_character} == 0x0043 or # C
1356                        $self->{next_input_character} == 0x0063) { # c
1357                      $self->{state} = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
1358                      !!!next-input-character;
1359                      redo A;
1360                    }
1361                  }
1362                }
1363              }
1364            }
1365    
1366            #
1367          } elsif ($self->{next_input_character} == 0x0053 or # S
1368                   $self->{next_input_character} == 0x0073) { # s
1369            !!!next-input-character;
1370            if ($self->{next_input_character} == 0x0059 or # Y
1371                $self->{next_input_character} == 0x0079) { # y
1372              !!!next-input-character;
1373              if ($self->{next_input_character} == 0x0053 or # S
1374                  $self->{next_input_character} == 0x0073) { # s
1375                !!!next-input-character;
1376                if ($self->{next_input_character} == 0x0054 or # T
1377                    $self->{next_input_character} == 0x0074) { # t
1378                  !!!next-input-character;
1379                  if ($self->{next_input_character} == 0x0045 or # E
1380                      $self->{next_input_character} == 0x0065) { # e
1381                    !!!next-input-character;
1382                    if ($self->{next_input_character} == 0x004D or # M
1383                        $self->{next_input_character} == 0x006D) { # m
1384                      $self->{state} = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
1385                      !!!next-input-character;
1386                      redo A;
1387                    }
1388                  }
1389                }
1390              }
1391            }
1392    
1393            #
1394          } else {
1395            !!!next-input-character;
1396            #
1397          }
1398    
1399          !!!parse-error (type => 'string after DOCTYPE name');
1400          $self->{state} = BOGUS_DOCTYPE_STATE;
1401          # next-input-character is already done
1402          redo A;
1403        } elsif ($self->{state} == BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {
1404          if ({
1405                0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,
1406                #0x000D => 1, # HT, LF, VT, FF, SP, CR
1407              }->{$self->{next_input_character}}) {
1408            ## Stay in the state
1409            !!!next-input-character;
1410            redo A;
1411          } elsif ($self->{next_input_character} eq 0x0022) { # "
1412            $self->{current_token}->{public_identifier} = ''; # DOCTYPE
1413            $self->{state} = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;
1414            !!!next-input-character;
1415            redo A;
1416          } elsif ($self->{next_input_character} eq 0x0027) { # '
1417            $self->{current_token}->{public_identifier} = ''; # DOCTYPE
1418            $self->{state} = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;
1419            !!!next-input-character;
1420            redo A;
1421          } elsif ($self->{next_input_character} eq 0x003E) { # >
1422            !!!parse-error (type => 'no PUBLIC literal');
1423    
1424            $self->{state} = DATA_STATE;
1425            !!!next-input-character;
1426    
1427            delete $self->{current_token}->{correct};
1428            !!!emit ($self->{current_token}); # DOCTYPE
1429    
1430            redo A;
1431          } elsif ($self->{next_input_character} == -1) {
1432            !!!parse-error (type => 'unclosed DOCTYPE');
1433    
1434            $self->{state} = DATA_STATE;
1435            ## reconsume
1436    
1437            delete $self->{current_token}->{correct};
1438            !!!emit ($self->{current_token}); # DOCTYPE
1439    
1440            redo A;
1441          } else {
1442            !!!parse-error (type => 'string after PUBLIC');
1443            $self->{state} = BOGUS_DOCTYPE_STATE;
1444            !!!next-input-character;
1445            redo A;
1446          }
1447        } elsif ($self->{state} == DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE) {
1448          if ($self->{next_input_character} == 0x0022) { # "
1449            $self->{state} = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
1450            !!!next-input-character;
1451            redo A;
1452          } elsif ($self->{next_input_character} == -1) {
1453            !!!parse-error (type => 'unclosed PUBLIC literal');
1454    
1455            $self->{state} = DATA_STATE;
1456            ## reconsume
1457    
1458            delete $self->{current_token}->{correct};
1459            !!!emit ($self->{current_token}); # DOCTYPE
1460    
1461            redo A;
1462          } else {
1463            $self->{current_token}->{public_identifier} # DOCTYPE
1464                .= chr $self->{next_input_character};
1465            ## Stay in the state
1466            !!!next-input-character;
1467            redo A;
1468          }
1469        } elsif ($self->{state} == DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE) {
1470          if ($self->{next_input_character} == 0x0027) { # '
1471            $self->{state} = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
1472            !!!next-input-character;
1473            redo A;
1474          } elsif ($self->{next_input_character} == -1) {
1475            !!!parse-error (type => 'unclosed PUBLIC literal');
1476    
1477            $self->{state} = DATA_STATE;
1478            ## reconsume
1479    
1480            delete $self->{current_token}->{correct};
1481            !!!emit ($self->{current_token}); # DOCTYPE
1482    
1483            redo A;
1484          } else {
1485            $self->{current_token}->{public_identifier} # DOCTYPE
1486                .= chr $self->{next_input_character};
1487            ## Stay in the state
1488            !!!next-input-character;
1489            redo A;
1490          }
1491        } elsif ($self->{state} == AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {
1492          if ({
1493                0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,
1494                #0x000D => 1, # HT, LF, VT, FF, SP, CR
1495              }->{$self->{next_input_character}}) {
1496            ## Stay in the state
1497            !!!next-input-character;
1498            redo A;
1499          } elsif ($self->{next_input_character} == 0x0022) { # "
1500            $self->{current_token}->{system_identifier} = ''; # DOCTYPE
1501            $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
1502            !!!next-input-character;
1503            redo A;
1504          } elsif ($self->{next_input_character} == 0x0027) { # '
1505            $self->{current_token}->{system_identifier} = ''; # DOCTYPE
1506            $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
1507            !!!next-input-character;
1508            redo A;
1509          } elsif ($self->{next_input_character} == 0x003E) { # >
1510            $self->{state} = DATA_STATE;
1511          !!!next-input-character;          !!!next-input-character;
1512    
1513          !!!emit ($self->{current_token}); # DOCTYPE          !!!emit ($self->{current_token}); # DOCTYPE
         undef $self->{current_token};  
1514    
1515          redo A;          redo A;
1516        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
1517          !!!parse-error (type => 'unclosed DOCTYPE');          !!!parse-error (type => 'unclosed DOCTYPE');
1518          $self->{state} = 'data';  
1519            $self->{state} = DATA_STATE;
1520          ## reconsume          ## reconsume
1521    
1522            delete $self->{current_token}->{correct};
1523          !!!emit ($self->{current_token}); # DOCTYPE          !!!emit ($self->{current_token}); # DOCTYPE
         undef $self->{current_token};  
1524    
1525          redo A;          redo A;
1526        } else {        } else {
1527          !!!parse-error (type => 'string after DOCTYPE name');          !!!parse-error (type => 'string after PUBLIC literal');
1528          $self->{current_token}->{error} = 1; # DOCTYPE          $self->{state} = BOGUS_DOCTYPE_STATE;
         $self->{state} = 'bogus DOCTYPE';  
1529          !!!next-input-character;          !!!next-input-character;
1530          redo A;          redo A;
1531        }        }
1532      } elsif ($self->{state} eq 'bogus DOCTYPE') {      } elsif ($self->{state} == BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {
1533          if ({
1534                0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,
1535                #0x000D => 1, # HT, LF, VT, FF, SP, CR
1536              }->{$self->{next_input_character}}) {
1537            ## Stay in the state
1538            !!!next-input-character;
1539            redo A;
1540          } elsif ($self->{next_input_character} == 0x0022) { # "
1541            $self->{current_token}->{system_identifier} = ''; # DOCTYPE
1542            $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
1543            !!!next-input-character;
1544            redo A;
1545          } elsif ($self->{next_input_character} == 0x0027) { # '
1546            $self->{current_token}->{system_identifier} = ''; # DOCTYPE
1547            $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
1548            !!!next-input-character;
1549            redo A;
1550          } elsif ($self->{next_input_character} == 0x003E) { # >
1551            !!!parse-error (type => 'no SYSTEM literal');
1552            $self->{state} = DATA_STATE;
1553            !!!next-input-character;
1554    
1555            delete $self->{current_token}->{correct};
1556            !!!emit ($self->{current_token}); # DOCTYPE
1557    
1558            redo A;
1559          } elsif ($self->{next_input_character} == -1) {
1560            !!!parse-error (type => 'unclosed DOCTYPE');
1561    
1562            $self->{state} = DATA_STATE;
1563            ## reconsume
1564    
1565            delete $self->{current_token}->{correct};
1566            !!!emit ($self->{current_token}); # DOCTYPE
1567    
1568            redo A;
1569          } else {
1570            !!!parse-error (type => 'string after SYSTEM');
1571            $self->{state} = BOGUS_DOCTYPE_STATE;
1572            !!!next-input-character;
1573            redo A;
1574          }
1575        } elsif ($self->{state} == DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE) {
1576          if ($self->{next_input_character} == 0x0022) { # "
1577            $self->{state} = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
1578            !!!next-input-character;
1579            redo A;
1580          } elsif ($self->{next_input_character} == -1) {
1581            !!!parse-error (type => 'unclosed SYSTEM literal');
1582    
1583            $self->{state} = DATA_STATE;
1584            ## reconsume
1585    
1586            delete $self->{current_token}->{correct};
1587            !!!emit ($self->{current_token}); # DOCTYPE
1588    
1589            redo A;
1590          } else {
1591            $self->{current_token}->{system_identifier} # DOCTYPE
1592                .= chr $self->{next_input_character};
1593            ## Stay in the state
1594            !!!next-input-character;
1595            redo A;
1596          }
1597        } elsif ($self->{state} == DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE) {
1598          if ($self->{next_input_character} == 0x0027) { # '
1599            $self->{state} = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
1600            !!!next-input-character;
1601            redo A;
1602          } elsif ($self->{next_input_character} == -1) {
1603            !!!parse-error (type => 'unclosed SYSTEM literal');
1604    
1605            $self->{state} = DATA_STATE;
1606            ## reconsume
1607    
1608            delete $self->{current_token}->{correct};
1609            !!!emit ($self->{current_token}); # DOCTYPE
1610    
1611            redo A;
1612          } else {
1613            $self->{current_token}->{system_identifier} # DOCTYPE
1614                .= chr $self->{next_input_character};
1615            ## Stay in the state
1616            !!!next-input-character;
1617            redo A;
1618          }
1619        } elsif ($self->{state} == AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {
1620          if ({
1621                0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,
1622                #0x000D => 1, # HT, LF, VT, FF, SP, CR
1623              }->{$self->{next_input_character}}) {
1624            ## Stay in the state
1625            !!!next-input-character;
1626            redo A;
1627          } elsif ($self->{next_input_character} == 0x003E) { # >
1628            $self->{state} = DATA_STATE;
1629            !!!next-input-character;
1630    
1631            !!!emit ($self->{current_token}); # DOCTYPE
1632    
1633            redo A;
1634          } elsif ($self->{next_input_character} == -1) {
1635            !!!parse-error (type => 'unclosed DOCTYPE');
1636    
1637            $self->{state} = DATA_STATE;
1638            ## reconsume
1639    
1640            delete $self->{current_token}->{correct};
1641            !!!emit ($self->{current_token}); # DOCTYPE
1642    
1643            redo A;
1644          } else {
1645            !!!parse-error (type => 'string after SYSTEM literal');
1646            $self->{state} = BOGUS_DOCTYPE_STATE;
1647            !!!next-input-character;
1648            redo A;
1649          }
1650        } elsif ($self->{state} == BOGUS_DOCTYPE_STATE) {
1651        if ($self->{next_input_character} == 0x003E) { # >        if ($self->{next_input_character} == 0x003E) { # >
1652          $self->{state} = 'data';          $self->{state} = DATA_STATE;
1653          !!!next-input-character;          !!!next-input-character;
1654    
1655            delete $self->{current_token}->{correct};
1656          !!!emit ($self->{current_token}); # DOCTYPE          !!!emit ($self->{current_token}); # DOCTYPE
         undef $self->{current_token};  
1657    
1658          redo A;          redo A;
1659        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
1660          !!!parse-error (type => 'unclosed DOCTYPE');          !!!parse-error (type => 'unclosed DOCTYPE');
1661          $self->{state} = 'data';          $self->{state} = DATA_STATE;
1662          ## reconsume          ## reconsume
1663    
1664            delete $self->{current_token}->{correct};
1665          !!!emit ($self->{current_token}); # DOCTYPE          !!!emit ($self->{current_token}); # DOCTYPE
         undef $self->{current_token};  
1666    
1667          redo A;          redo A;
1668        } else {        } else {
# Line 1523  sub _get_next_token ($) { Line 1678  sub _get_next_token ($) {
1678    die "$0: _get_next_token: unexpected case";    die "$0: _get_next_token: unexpected case";
1679  } # _get_next_token  } # _get_next_token
1680    
1681  sub _tokenize_attempt_to_consume_an_entity ($) {  sub _tokenize_attempt_to_consume_an_entity ($$) {
1682    my $self = shift;    my ($self, $in_attr) = @_;
1683      
1684    if ($self->{next_input_character} == 0x0023) { # #    if ({
1685           0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, # HT, LF, VT, FF,
1686           0x0020 => 1, 0x003C => 1, 0x0026 => 1, -1 => 1, # SP, <, & # 0x000D # CR
1687          }->{$self->{next_input_character}}) {
1688        ## Don't consume
1689        ## No error
1690        return undef;
1691      } elsif ($self->{next_input_character} == 0x0023) { # #
1692      !!!next-input-character;      !!!next-input-character;
1693      if ($self->{next_input_character} == 0x0078 or # x      if ($self->{next_input_character} == 0x0078 or # x
1694          $self->{next_input_character} == 0x0058) { # X          $self->{next_input_character} == 0x0058) { # X
1695        my $num;        my $code;
1696        X: {        X: {
1697          my $x_char = $self->{next_input_character};          my $x_char = $self->{next_input_character};
1698          !!!next-input-character;          !!!next-input-character;
1699          if (0x0030 <= $self->{next_input_character} and          if (0x0030 <= $self->{next_input_character} and
1700              $self->{next_input_character} <= 0x0039) { # 0..9              $self->{next_input_character} <= 0x0039) { # 0..9
1701            $num ||= 0;            $code ||= 0;
1702            $num *= 0x10;            $code *= 0x10;
1703            $num += $self->{next_input_character} - 0x0030;            $code += $self->{next_input_character} - 0x0030;
1704            redo X;            redo X;
1705          } elsif (0x0061 <= $self->{next_input_character} and          } elsif (0x0061 <= $self->{next_input_character} and
1706                   $self->{next_input_character} <= 0x0066) { # a..f                   $self->{next_input_character} <= 0x0066) { # a..f
1707            ## ISSUE: the spec says U+0078, which is apparently incorrect            $code ||= 0;
1708            $num ||= 0;            $code *= 0x10;
1709            $num *= 0x10;            $code += $self->{next_input_character} - 0x0060 + 9;
           $num += $self->{next_input_character} - 0x0060 + 9;  
1710            redo X;            redo X;
1711          } elsif (0x0041 <= $self->{next_input_character} and          } elsif (0x0041 <= $self->{next_input_character} and
1712                   $self->{next_input_character} <= 0x0046) { # A..F                   $self->{next_input_character} <= 0x0046) { # A..F
1713            ## ISSUE: the spec says U+0058, which is apparently incorrect            $code ||= 0;
1714            $num ||= 0;            $code *= 0x10;
1715            $num *= 0x10;            $code += $self->{next_input_character} - 0x0040 + 9;
           $num += $self->{next_input_character} - 0x0040 + 9;  
1716            redo X;            redo X;
1717          } elsif (not defined $num) { # no hexadecimal digit          } elsif (not defined $code) { # no hexadecimal digit
1718            !!!parse-error (type => 'bare hcro');            !!!parse-error (type => 'bare hcro');
1719              !!!back-next-input-character ($x_char, $self->{next_input_character});
1720            $self->{next_input_character} = 0x0023; # #            $self->{next_input_character} = 0x0023; # #
           !!!back-next-input-character ($x_char);  
1721            return undef;            return undef;
1722          } elsif ($self->{next_input_character} == 0x003B) { # ;          } elsif ($self->{next_input_character} == 0x003B) { # ;
1723            !!!next-input-character;            !!!next-input-character;
# Line 1565  sub _tokenize_attempt_to_consume_an_enti Line 1725  sub _tokenize_attempt_to_consume_an_enti
1725            !!!parse-error (type => 'no refc');            !!!parse-error (type => 'no refc');
1726          }          }
1727    
1728          ## TODO: check the definition for |a valid Unicode character|.          if ($code == 0 or (0xD800 <= $code and $code <= 0xDFFF)) {
1729          ## <http://lists.whatwg.org/pipermail/whatwg-whatwg.org/2006-December/thread.html#8189>            !!!parse-error (type => sprintf 'invalid character reference:U+%04X', $code);
1730          if ($num > 1114111 or $num == 0) {            $code = 0xFFFD;
1731            $num = 0xFFFD; # REPLACEMENT CHARACTER          } elsif ($code > 0x10FFFF) {
1732            ## ISSUE: Why this is not an error?            !!!parse-error (type => sprintf 'invalid character reference:U-%08X', $code);
1733          } elsif (0x80 <= $num and $num <= 0x9F) {            $code = 0xFFFD;
1734            !!!parse-error (type => sprintf 'c1 entity:U+%04X', $num);          } elsif ($code == 0x000D) {
1735            $num = $c1_entity_char->{$num};            !!!parse-error (type => 'CR character reference');
1736              $code = 0x000A;
1737            } elsif (0x80 <= $code and $code <= 0x9F) {
1738              !!!parse-error (type => sprintf 'C1 character reference:U+%04X', $code);
1739              $code = $c1_entity_char->{$code};
1740          }          }
1741    
1742          return {type => 'character', data => chr $num};          return {type => CHARACTER_TOKEN, data => chr $code};
1743        } # X        } # X
1744      } elsif (0x0030 <= $self->{next_input_character} and      } elsif (0x0030 <= $self->{next_input_character} and
1745               $self->{next_input_character} <= 0x0039) { # 0..9               $self->{next_input_character} <= 0x0039) { # 0..9
# Line 1596  sub _tokenize_attempt_to_consume_an_enti Line 1760  sub _tokenize_attempt_to_consume_an_enti
1760          !!!parse-error (type => 'no refc');          !!!parse-error (type => 'no refc');
1761        }        }
1762    
1763        ## TODO: check the definition for |a valid Unicode character|.        if ($code == 0 or (0xD800 <= $code and $code <= 0xDFFF)) {
1764        if ($code > 1114111 or $code == 0) {          !!!parse-error (type => sprintf 'invalid character reference:U+%04X', $code);
1765          $code = 0xFFFD; # REPLACEMENT CHARACTER          $code = 0xFFFD;
1766          ## ISSUE: Why this is not an error?        } elsif ($code > 0x10FFFF) {
1767            !!!parse-error (type => sprintf 'invalid character reference:U-%08X', $code);
1768            $code = 0xFFFD;
1769          } elsif ($code == 0x000D) {
1770            !!!parse-error (type => 'CR character reference');
1771            $code = 0x000A;
1772        } elsif (0x80 <= $code and $code <= 0x9F) {        } elsif (0x80 <= $code and $code <= 0x9F) {
1773          !!!parse-error (type => sprintf 'c1 entity:U+%04X', $code);          !!!parse-error (type => sprintf 'C1 character reference:U+%04X', $code);
1774          $code = $c1_entity_char->{$code};          $code = $c1_entity_char->{$code};
1775        }        }
1776                
1777        return {type => 'character', data => chr $code};        return {type => CHARACTER_TOKEN, data => chr $code};
1778      } else {      } else {
1779        !!!parse-error (type => 'bare nero');        !!!parse-error (type => 'bare nero');
1780        !!!back-next-input-character ($self->{next_input_character});        !!!back-next-input-character ($self->{next_input_character});
# Line 1620  sub _tokenize_attempt_to_consume_an_enti Line 1789  sub _tokenize_attempt_to_consume_an_enti
1789      !!!next-input-character;      !!!next-input-character;
1790    
1791      my $value = $entity_name;      my $value = $entity_name;
1792      my $match;      my $match = 0;
1793        require Whatpm::_NamedEntityList;
1794        our $EntityChar;
1795    
1796      while (length $entity_name < 10 and      while (length $entity_name < 10 and
1797             ## NOTE: Some number greater than the maximum length of entity name             ## NOTE: Some number greater than the maximum length of entity name
1798             ((0x0041 <= $self->{next_input_character} and             ((0x0041 <= $self->{next_input_character} and # a
1799               $self->{next_input_character} <= 0x005A) or               $self->{next_input_character} <= 0x005A) or # x
1800              (0x0061 <= $self->{next_input_character} and              (0x0061 <= $self->{next_input_character} and # a
1801               $self->{next_input_character} <= 0x007A) or               $self->{next_input_character} <= 0x007A) or # z
1802              (0x0030 <= $self->{next_input_character} and              (0x0030 <= $self->{next_input_character} and # 0
1803               $self->{next_input_character} <= 0x0039))) {               $self->{next_input_character} <= 0x0039) or # 9
1804                $self->{next_input_character} == 0x003B)) { # ;
1805        $entity_name .= chr $self->{next_input_character};        $entity_name .= chr $self->{next_input_character};
1806        if (defined $entity_char->{$entity_name}) {        if (defined $EntityChar->{$entity_name}) {
1807          $value = $entity_char->{$entity_name};          if ($self->{next_input_character} == 0x003B) { # ;
1808          $match = 1;            $value = $EntityChar->{$entity_name};
1809              $match = 1;
1810              !!!next-input-character;
1811              last;
1812            } else {
1813              $value = $EntityChar->{$entity_name};
1814              $match = -1;
1815              !!!next-input-character;
1816            }
1817        } else {        } else {
1818          $value .= chr $self->{next_input_character};          $value .= chr $self->{next_input_character};
1819            $match *= 2;
1820            !!!next-input-character;
1821        }        }
       !!!next-input-character;  
1822      }      }
1823            
1824      if ($match) {      if ($match > 0) {
1825        if ($self->{next_input_character} == 0x003B) { # ;        return {type => CHARACTER_TOKEN, data => $value};
1826          !!!next-input-character;      } elsif ($match < 0) {
1827          !!!parse-error (type => 'no refc');
1828          if ($in_attr and $match < -1) {
1829            return {type => CHARACTER_TOKEN, data => '&'.$entity_name};
1830        } else {        } else {
1831          !!!parse-error (type => 'refc');          return {type => CHARACTER_TOKEN, data => $value};
1832        }        }
   
       return {type => 'character', data => $value};  
1833      } else {      } else {
1834        !!!parse-error (type => 'bare ero');        !!!parse-error (type => 'bare ero');
1835        ## NOTE: No characters are consumed in the spec.        ## NOTE: No characters are consumed in the spec.
1836        !!!back-token ({type => 'character', data => $value});        return {type => CHARACTER_TOKEN, data => '&'.$value};
       return undef;  
1837      }      }
1838    } else {    } else {
1839      ## no characters are consumed      ## no characters are consumed
# Line 1667  sub _initialize_tree_constructor ($) { Line 1848  sub _initialize_tree_constructor ($) {
1848    $self->{document}->strict_error_checking (0);    $self->{document}->strict_error_checking (0);
1849    ## TODO: Turn mutation events off # MUST    ## TODO: Turn mutation events off # MUST
1850    ## TODO: Turn loose Document option (manakai extension) on    ## TODO: Turn loose Document option (manakai extension) on
1851    ## TODO: Mark the Document as an HTML document # MUST    $self->{document}->manakai_is_html (1); # MUST
1852  } # _initialize_tree_constructor  } # _initialize_tree_constructor
1853    
1854  sub _terminate_tree_constructor ($) {  sub _terminate_tree_constructor ($) {
# Line 1694  sub _construct_tree ($) { Line 1875  sub _construct_tree ($) {
1875        
1876    !!!next-token;    !!!next-token;
1877    
1878    $self->{insertion_mode} = 'before head';    $self->{insertion_mode} = BEFORE_HEAD_IM;
1879    undef $self->{form_element};    undef $self->{form_element};
1880    undef $self->{head_element};    undef $self->{head_element};
1881    $self->{open_elements} = [];    $self->{open_elements} = [];
# Line 1707  sub _construct_tree ($) { Line 1888  sub _construct_tree ($) {
1888    
1889  sub _tree_construction_initial ($) {  sub _tree_construction_initial ($) {
1890    my $self = shift;    my $self = shift;
1891    B: {    INITIAL: {
1892        if ($token->{type} eq 'DOCTYPE') {      if ($token->{type} == DOCTYPE_TOKEN) {
1893          if ($token->{error}) {        ## NOTE: Conformance checkers MAY, instead of reporting "not HTML5"
1894            ## ISSUE: Spec currently left this case undefined.        ## error, switch to a conformance checking mode for another
1895            !!!parse-error (type => 'bogus DOCTYPE');        ## language.
1896          }        my $doctype_name = $token->{name};
1897          my $doctype = $self->{document}->create_document_type_definition        $doctype_name = '' unless defined $doctype_name;
1898            ($token->{name});        $doctype_name =~ tr/a-z/A-Z/;
1899          $self->{document}->append_child ($doctype);        if (not defined $token->{name} or # <!DOCTYPE>
1900          #$phase = 'root element';            defined $token->{public_identifier} or
1901          !!!next-token;            defined $token->{system_identifier}) {
1902          #redo B;          !!!parse-error (type => 'not HTML5');
1903          return;        } elsif ($doctype_name ne 'HTML') {
1904        } elsif ({          ## ISSUE: ASCII case-insensitive? (in fact it does not matter)
1905                  comment => 1,          !!!parse-error (type => 'not HTML5');
1906                  'start tag' => 1,        }
1907                  'end tag' => 1,        
1908                  'end-of-file' => 1,        my $doctype = $self->{document}->create_document_type_definition
1909                 }->{$token->{type}}) {          ($token->{name}); ## ISSUE: If name is missing (e.g. <!DOCTYPE>)?
1910          ## ISSUE: Spec currently left this case undefined.        $doctype->public_id ($token->{public_identifier})
1911          !!!parse-error (type => 'missing DOCTYPE');            if defined $token->{public_identifier};
1912          #$phase = 'root element';        $doctype->system_id ($token->{system_identifier})
1913          ## reprocess            if defined $token->{system_identifier};
1914          #redo B;        ## NOTE: Other DocumentType attributes are null or empty lists.
1915          return;        ## ISSUE: internalSubset = null??
1916        } elsif ($token->{type} eq 'character') {        $self->{document}->append_child ($doctype);
1917          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {        
1918            $self->{document}->manakai_append_text ($1);        if (not $token->{correct} or $doctype_name ne 'HTML') {
1919            ## ISSUE: DOM3 Core does not allow Document > Text          $self->{document}->manakai_compat_mode ('quirks');
1920            unless (length $token->{data}) {        } elsif (defined $token->{public_identifier}) {
1921              ## Stay in the phase          my $pubid = $token->{public_identifier};
1922              !!!next-token;          $pubid =~ tr/a-z/A-z/;
1923              redo B;          if ({
1924              "+//SILMARIL//DTD HTML PRO V0R11 19970101//EN" => 1,
1925              "-//ADVASOFT LTD//DTD HTML 3.0 ASWEDIT + EXTENSIONS//EN" => 1,
1926              "-//AS//DTD HTML 3.0 ASWEDIT + EXTENSIONS//EN" => 1,
1927              "-//IETF//DTD HTML 2.0 LEVEL 1//EN" => 1,
1928              "-//IETF//DTD HTML 2.0 LEVEL 2//EN" => 1,
1929              "-//IETF//DTD HTML 2.0 STRICT LEVEL 1//EN" => 1,
1930              "-//IETF//DTD HTML 2.0 STRICT LEVEL 2//EN" => 1,
1931              "-//IETF//DTD HTML 2.0 STRICT//EN" => 1,
1932              "-//IETF//DTD HTML 2.0//EN" => 1,
1933              "-//IETF//DTD HTML 2.1E//EN" => 1,
1934              "-//IETF//DTD HTML 3.0//EN" => 1,
1935              "-//IETF//DTD HTML 3.0//EN//" => 1,
1936              "-//IETF//DTD HTML 3.2 FINAL//EN" => 1,
1937              "-//IETF//DTD HTML 3.2//EN" => 1,
1938              "-//IETF//DTD HTML 3//EN" => 1,
1939              "-//IETF//DTD HTML LEVEL 0//EN" => 1,
1940              "-//IETF//DTD HTML LEVEL 0//EN//2.0" => 1,
1941              "-//IETF//DTD HTML LEVEL 1//EN" => 1,
1942              "-//IETF//DTD HTML LEVEL 1//EN//2.0" => 1,
1943              "-//IETF//DTD HTML LEVEL 2//EN" => 1,
1944              "-//IETF//DTD HTML LEVEL 2//EN//2.0" => 1,
1945              "-//IETF//DTD HTML LEVEL 3//EN" => 1,
1946              "-//IETF//DTD HTML LEVEL 3//EN//3.0" => 1,
1947              "-//IETF//DTD HTML STRICT LEVEL 0//EN" => 1,
1948              "-//IETF//DTD HTML STRICT LEVEL 0//EN//2.0" => 1,
1949              "-//IETF//DTD HTML STRICT LEVEL 1//EN" => 1,
1950              "-//IETF//DTD HTML STRICT LEVEL 1//EN//2.0" => 1,
1951              "-//IETF//DTD HTML STRICT LEVEL 2//EN" => 1,
1952              "-//IETF//DTD HTML STRICT LEVEL 2//EN//2.0" => 1,
1953              "-//IETF//DTD HTML STRICT LEVEL 3//EN" => 1,
1954              "-//IETF//DTD HTML STRICT LEVEL 3//EN//3.0" => 1,
1955              "-//IETF//DTD HTML STRICT//EN" => 1,
1956              "-//IETF//DTD HTML STRICT//EN//2.0" => 1,
1957              "-//IETF//DTD HTML STRICT//EN//3.0" => 1,
1958              "-//IETF//DTD HTML//EN" => 1,
1959              "-//IETF//DTD HTML//EN//2.0" => 1,
1960              "-//IETF//DTD HTML//EN//3.0" => 1,
1961              "-//METRIUS//DTD METRIUS PRESENTATIONAL//EN" => 1,
1962              "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML STRICT//EN" => 1,
1963              "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML//EN" => 1,
1964              "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 TABLES//EN" => 1,
1965              "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML STRICT//EN" => 1,
1966              "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML//EN" => 1,
1967              "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 TABLES//EN" => 1,
1968              "-//NETSCAPE COMM. CORP.//DTD HTML//EN" => 1,
1969              "-//NETSCAPE COMM. CORP.//DTD STRICT HTML//EN" => 1,
1970              "-//O'REILLY AND ASSOCIATES//DTD HTML 2.0//EN" => 1,
1971              "-//O'REILLY AND ASSOCIATES//DTD HTML EXTENDED 1.0//EN" => 1,
1972              "-//SPYGLASS//DTD HTML 2.0 EXTENDED//EN" => 1,
1973              "-//SQ//DTD HTML 2.0 HOTMETAL + EXTENSIONS//EN" => 1,
1974              "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA HTML//EN" => 1,
1975              "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA STRICT HTML//EN" => 1,
1976              "-//W3C//DTD HTML 3 1995-03-24//EN" => 1,
1977              "-//W3C//DTD HTML 3.2 DRAFT//EN" => 1,
1978              "-//W3C//DTD HTML 3.2 FINAL//EN" => 1,
1979              "-//W3C//DTD HTML 3.2//EN" => 1,
1980              "-//W3C//DTD HTML 3.2S DRAFT//EN" => 1,
1981              "-//W3C//DTD HTML 4.0 FRAMESET//EN" => 1,
1982              "-//W3C//DTD HTML 4.0 TRANSITIONAL//EN" => 1,
1983              "-//W3C//DTD HTML EXPERIMETNAL 19960712//EN" => 1,
1984              "-//W3C//DTD HTML EXPERIMENTAL 970421//EN" => 1,
1985              "-//W3C//DTD W3 HTML//EN" => 1,
1986              "-//W3O//DTD W3 HTML 3.0//EN" => 1,
1987              "-//W3O//DTD W3 HTML 3.0//EN//" => 1,
1988              "-//W3O//DTD W3 HTML STRICT 3.0//EN//" => 1,
1989              "-//WEBTECHS//DTD MOZILLA HTML 2.0//EN" => 1,
1990              "-//WEBTECHS//DTD MOZILLA HTML//EN" => 1,
1991              "-/W3C/DTD HTML 4.0 TRANSITIONAL/EN" => 1,
1992              "HTML" => 1,
1993            }->{$pubid}) {
1994              $self->{document}->manakai_compat_mode ('quirks');
1995            } elsif ($pubid eq "-//W3C//DTD HTML 4.01 FRAMESET//EN" or
1996                     $pubid eq "-//W3C//DTD HTML 4.01 TRANSITIONAL//EN") {
1997              if (defined $token->{system_identifier}) {
1998                $self->{document}->manakai_compat_mode ('quirks');
1999              } else {
2000                $self->{document}->manakai_compat_mode ('limited quirks');
2001            }            }
2002            } elsif ($pubid eq "-//W3C//DTD XHTML 1.0 Frameset//EN" or
2003                     $pubid eq "-//W3C//DTD XHTML 1.0 Transitional//EN") {
2004              $self->{document}->manakai_compat_mode ('limited quirks');
2005            }
2006          }
2007          if (defined $token->{system_identifier}) {
2008            my $sysid = $token->{system_identifier};
2009            $sysid =~ tr/A-Z/a-z/;
2010            if ($sysid eq "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd") {
2011              $self->{document}->manakai_compat_mode ('quirks');
2012          }          }
         ## ISSUE: Spec currently left this case undefined.  
         !!!parse-error (type => 'missing DOCTYPE');  
         #$phase = 'root element';  
         ## reprocess  
         #redo B;  
         return;  
       } else {  
         die "$0: $token->{type}: Unknown token";  
2013        }        }
2014      } # B        
2015          ## Go to the root element phase.
2016          !!!next-token;
2017          return;
2018        } elsif ({
2019                  START_TAG_TOKEN, 1,
2020                  END_TAG_TOKEN, 1,
2021                  END_OF_FILE_TOKEN, 1,
2022                 }->{$token->{type}}) {
2023          !!!parse-error (type => 'no DOCTYPE');
2024          $self->{document}->manakai_compat_mode ('quirks');
2025          ## Go to the root element phase
2026          ## reprocess
2027          return;
2028        } elsif ($token->{type} == CHARACTER_TOKEN) {
2029          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D
2030            ## Ignore the token
2031    
2032            unless (length $token->{data}) {
2033              ## Stay in the phase
2034              !!!next-token;
2035              redo INITIAL;
2036            }
2037          }
2038    
2039          !!!parse-error (type => 'no DOCTYPE');
2040          $self->{document}->manakai_compat_mode ('quirks');
2041          ## Go to the root element phase
2042          ## reprocess
2043          return;
2044        } elsif ($token->{type} == COMMENT_TOKEN) {
2045          my $comment = $self->{document}->create_comment ($token->{data});
2046          $self->{document}->append_child ($comment);
2047          
2048          ## Stay in the phase.
2049          !!!next-token;
2050          redo INITIAL;
2051        } else {
2052          die "$0: $token->{type}: Unknown token type";
2053        }
2054      } # INITIAL
2055  } # _tree_construction_initial  } # _tree_construction_initial
2056    
2057  sub _tree_construction_root_element ($) {  sub _tree_construction_root_element ($) {
2058    my $self = shift;    my $self = shift;
2059        
2060    B: {    B: {
2061        if ($token->{type} eq 'DOCTYPE') {        if ($token->{type} == DOCTYPE_TOKEN) {
2062          !!!parse-error (type => 'in html:#DOCTYPE');          !!!parse-error (type => 'in html:#DOCTYPE');
2063          ## Ignore the token          ## Ignore the token
2064          ## Stay in the phase          ## Stay in the phase
2065          !!!next-token;          !!!next-token;
2066          redo B;          redo B;
2067        } elsif ($token->{type} eq 'comment') {        } elsif ($token->{type} == COMMENT_TOKEN) {
2068          my $comment = $self->{document}->create_comment ($token->{data});          my $comment = $self->{document}->create_comment ($token->{data});
2069          $self->{document}->append_child ($comment);          $self->{document}->append_child ($comment);
2070          ## Stay in the phase          ## Stay in the phase
2071          !!!next-token;          !!!next-token;
2072          redo B;          redo B;
2073        } elsif ($token->{type} eq 'character') {        } elsif ($token->{type} == CHARACTER_TOKEN) {
2074          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D
2075            $self->{document}->manakai_append_text ($1);            ## Ignore the token.
2076            ## ISSUE: DOM3 Core does not allow Document > Text  
2077            unless (length $token->{data}) {            unless (length $token->{data}) {
2078              ## Stay in the phase              ## Stay in the phase
2079              !!!next-token;              !!!next-token;
# Line 1782  sub _tree_construction_root_element ($) Line 2082  sub _tree_construction_root_element ($)
2082          }          }
2083          #          #
2084        } elsif ({        } elsif ({
2085                  'start tag' => 1,                  START_TAG_TOKEN, 1,
2086                  'end tag' => 1,                  END_TAG_TOKEN, 1,
2087                  'end-of-file' => 1,                  END_OF_FILE_TOKEN, 1,
2088                 }->{$token->{type}}) {                 }->{$token->{type}}) {
2089          ## ISSUE: There is an issue in the spec          ## ISSUE: There is an issue in the spec
2090          #          #
2091        } else {        } else {
2092          die "$0: $token->{type}: Unknown token";          die "$0: $token->{type}: Unknown token type";
2093        }        }
2094        my $root_element; !!!create-element ($root_element, 'html');        my $root_element; !!!create-element ($root_element, 'html');
2095        $self->{document}->append_child ($root_element);        $self->{document}->append_child ($root_element);
2096        push @{$self->{open_elements}}, [$root_element, 'html'];        push @{$self->{open_elements}}, [$root_element, 'html'];
       #$phase = 'main';  
2097        ## reprocess        ## reprocess
2098        #redo B;        #redo B;
2099        return;        return; ## Go to the main phase.
2100    } # B    } # B
2101  } # _tree_construction_root_element  } # _tree_construction_root_element
2102    
# Line 1813  sub _reset_insertion_mode ($) { Line 2112  sub _reset_insertion_mode ($) {
2112            
2113      ## Step 3      ## Step 3
2114      S3: {      S3: {
2115        $last = 1 if $self->{open_elements}->[0]->[0] eq $node->[0];        ## ISSUE: Oops! "If node is the first node in the stack of open
2116        if (defined $self->{inner_html_node}) {        ## elements, then set last to true. If the context element of the
2117          if ($self->{inner_html_node}->[1] eq 'td' or        ## HTML fragment parsing algorithm is neither a td element nor a
2118              $self->{inner_html_node}->[1] eq 'th') {        ## th element, then set node to the context element. (fragment case)":
2119            #        ## The second "if" is in the scope of the first "if"!?
2120          } else {        if ($self->{open_elements}->[0]->[0] eq $node->[0]) {
2121            $node = $self->{inner_html_node};          $last = 1;
2122            if (defined $self->{inner_html_node}) {
2123              if ($self->{inner_html_node}->[1] eq 'td' or
2124                  $self->{inner_html_node}->[1] eq 'th') {
2125                #
2126              } else {
2127                $node = $self->{inner_html_node};
2128              }
2129          }          }
2130        }        }
2131            
2132        ## Step 4..13        ## Step 4..13
2133        my $new_mode = {        my $new_mode = {
2134                        select => 'in select',                        select => IN_SELECT_IM,
2135                        td => 'in cell',                        td => IN_CELL_IM,
2136                        th => 'in cell',                        th => IN_CELL_IM,
2137                        tr => 'in row',                        tr => IN_ROW_IM,
2138                        tbody => 'in table body',                        tbody => IN_TABLE_BODY_IM,
2139                        thead => 'in table head',                        thead => IN_TABLE_BODY_IM,
2140                        tfoot => 'in table foot',                        tfoot => IN_TABLE_BODY_IM,
2141                        caption => 'in caption',                        caption => IN_CAPTION_IM,
2142                        colgroup => 'in column group',                        colgroup => IN_COLUMN_GROUP_IM,
2143                        table => 'in table',                        table => IN_TABLE_IM,
2144                        head => 'in body', # not in head!                        head => IN_BODY_IM, # not in head!
2145                        body => 'in body',                        body => IN_BODY_IM,
2146                        frameset => 'in frameset',                        frameset => IN_FRAMESET_IM,
2147                       }->{$node->[1]};                       }->{$node->[1]};
2148        $self->{insertion_mode} = $new_mode and return if defined $new_mode;        $self->{insertion_mode} = $new_mode and return if defined $new_mode;
2149                
2150        ## Step 14        ## Step 14
2151        if ($node->[1] eq 'html') {        if ($node->[1] eq 'html') {
2152          unless (defined $self->{head_element}) {          unless (defined $self->{head_element}) {
2153            $self->{insertion_mode} = 'before head';            $self->{insertion_mode} = BEFORE_HEAD_IM;
2154          } else {          } else {
2155            $self->{insertion_mode} = 'after head';            $self->{insertion_mode} = AFTER_HEAD_IM;
2156          }          }
2157          return;          return;
2158        }        }
2159                
2160        ## Step 15        ## Step 15
2161        $self->{insertion_mode} = 'in body' and return if $last;        $self->{insertion_mode} = IN_BODY_IM and return if $last;
2162                
2163        ## Step 16        ## Step 16
2164        $i--;        $i--;
# Line 1866  sub _reset_insertion_mode ($) { Line 2172  sub _reset_insertion_mode ($) {
2172  sub _tree_construction_main ($) {  sub _tree_construction_main ($) {
2173    my $self = shift;    my $self = shift;
2174    
   my $phase = 'main';  
   
2175    my $active_formatting_elements = [];    my $active_formatting_elements = [];
2176    
2177    my $reconstruct_active_formatting_elements = sub { # MUST    my $reconstruct_active_formatting_elements = sub { # MUST
# Line 1950  sub _tree_construction_main ($) { Line 2254  sub _tree_construction_main ($) {
2254      }      }
2255    }; # $clear_up_to_marker    }; # $clear_up_to_marker
2256    
2257    my $style_start_tag = sub {    my $parse_rcdata = sub ($$) {
2258      my $style_el; !!!create-element ($style_el, 'style', $token->{attributes});      my ($content_model_flag, $insert) = @_;
2259      ## $self->{insertion_mode} eq 'in head' and ... (always true)  
2260      (($self->{insertion_mode} eq 'in head' and defined $self->{head_element})      ## Step 1
2261       ? $self->{head_element} : $self->{open_elements}->[-1]->[0])      my $start_tag_name = $token->{tag_name};
2262        ->append_child ($style_el);      my $el;
2263      $self->{content_model_flag} = 'CDATA';      !!!create-element ($el, $start_tag_name, $token->{attributes});
2264    
2265        ## Step 2
2266        $insert->($el); # /context node/->append_child ($el)
2267    
2268        ## Step 3
2269        $self->{content_model} = $content_model_flag; # CDATA or RCDATA
2270      delete $self->{escape}; # MUST      delete $self->{escape}; # MUST
2271                  
2272        ## Step 4
2273      my $text = '';      my $text = '';
2274      !!!next-token;      !!!next-token;
2275      while ($token->{type} eq 'character') {      while ($token->{type} == CHARACTER_TOKEN) { # or until stop tokenizing
2276        $text .= $token->{data};        $text .= $token->{data};
2277        !!!next-token;        !!!next-token;
2278      } # stop if non-character token or tokenizer stops tokenising      }
2279    
2280        ## Step 5
2281      if (length $text) {      if (length $text) {
2282        $style_el->manakai_append_text ($text);        my $text = $self->{document}->create_text_node ($text);
2283          $el->append_child ($text);
2284      }      }
2285        
2286      $self->{content_model_flag} = 'PCDATA';      ## Step 6
2287                      $self->{content_model} = PCDATA_CONTENT_MODEL;
2288      if ($token->{type} eq 'end tag' and $token->{tag_name} eq 'style') {  
2289        ## Step 7
2290        if ($token->{type} == END_TAG_TOKEN and $token->{tag_name} eq $start_tag_name) {
2291        ## Ignore the token        ## Ignore the token
2292      } else {      } elsif ($content_model_flag == CDATA_CONTENT_MODEL) {
2293        !!!parse-error (type => 'in CDATA:#'.$token->{type});        !!!parse-error (type => 'in CDATA:#'.$token->{type});
2294        ## ISSUE: And ignore?      } elsif ($content_model_flag == RCDATA_CONTENT_MODEL) {
2295          !!!parse-error (type => 'in RCDATA:#'.$token->{type});
2296        } else {
2297          die "$0: $content_model_flag in parse_rcdata";
2298      }      }
2299      !!!next-token;      !!!next-token;
2300    }; # $style_start_tag    }; # $parse_rcdata
2301    
2302    my $script_start_tag = sub {    my $script_start_tag = sub ($) {
2303        my $insert = $_[0];
2304      my $script_el;      my $script_el;
2305      !!!create-element ($script_el, 'script', $token->{attributes});      !!!create-element ($script_el, 'script', $token->{attributes});
2306      ## TODO: mark as "parser-inserted"      ## TODO: mark as "parser-inserted"
2307    
2308      $self->{content_model_flag} = 'CDATA';      $self->{content_model} = CDATA_CONTENT_MODEL;
2309      delete $self->{escape}; # MUST      delete $self->{escape}; # MUST
2310            
2311      my $text = '';      my $text = '';
2312      !!!next-token;      !!!next-token;
2313      while ($token->{type} eq 'character') {      while ($token->{type} == CHARACTER_TOKEN) {
2314        $text .= $token->{data};        $text .= $token->{data};
2315        !!!next-token;        !!!next-token;
2316      } # stop if non-character token or tokenizer stops tokenising      } # stop if non-character token or tokenizer stops tokenising
# Line 1998  sub _tree_construction_main ($) { Line 2318  sub _tree_construction_main ($) {
2318        $script_el->manakai_append_text ($text);        $script_el->manakai_append_text ($text);
2319      }      }
2320                                
2321      $self->{content_model_flag} = 'PCDATA';      $self->{content_model} = PCDATA_CONTENT_MODEL;
2322    
2323      if ($token->{type} eq 'end tag' and      if ($token->{type} == END_TAG_TOKEN and
2324          $token->{tag_name} eq 'script') {          $token->{tag_name} eq 'script') {
2325        ## Ignore the token        ## Ignore the token
2326      } else {      } else {
# Line 2014  sub _tree_construction_main ($) { Line 2334  sub _tree_construction_main ($) {
2334      } else {      } else {
2335        ## TODO: $old_insertion_point = current insertion point        ## TODO: $old_insertion_point = current insertion point
2336        ## TODO: insertion point = just before the next input character        ## TODO: insertion point = just before the next input character
2337          
2338        (($self->{insertion_mode} eq 'in head' and defined $self->{head_element})        $insert->($script_el);
        ? $self->{head_element} : $self->{open_elements}->[-1]->[0])->append_child ($script_el);  
2339                
2340        ## TODO: insertion point = $old_insertion_point (might be "undefined")        ## TODO: insertion point = $old_insertion_point (might be "undefined")
2341                
# Line 2210  sub _tree_construction_main ($) { Line 2529  sub _tree_construction_main ($) {
2529    }; # $formatting_end_tag    }; # $formatting_end_tag
2530    
2531    my $insert_to_current = sub {    my $insert_to_current = sub {
2532      $self->{open_elements}->[-1]->[0]->append_child (shift);      $self->{open_elements}->[-1]->[0]->append_child ($_[0]);
2533    }; # $insert_to_current    }; # $insert_to_current
2534    
2535    my $insert_to_foster = sub {    my $insert_to_foster = sub {
# Line 2244  sub _tree_construction_main ($) { Line 2563  sub _tree_construction_main ($) {
2563                         }                         }
2564    }; # $insert_to_foster    }; # $insert_to_foster
2565    
2566    my $in_body = sub {    my $insert;
     my $insert = shift;  
     if ($token->{type} eq 'start tag') {  
       if ($token->{tag_name} eq 'script') {  
         $script_start_tag->();  
         return;  
       } elsif ($token->{tag_name} eq 'style') {  
         $style_start_tag->();  
         return;  
       } elsif ({  
                 base => 1, link => 1, meta => 1,  
                }->{$token->{tag_name}}) {  
         !!!parse-error (type => 'in body:'.$token->{tag_name});  
         ## NOTE: This is an "as if in head" code clone  
         my $el;  
         !!!create-element ($el, $token->{tag_name}, $token->{attributes});  
         if (defined $self->{head_element}) {  
           $self->{head_element}->append_child ($el);  
         } else {  
           $insert->($el);  
         }  
           
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'title') {  
         !!!parse-error (type => 'in body:title');  
         ## NOTE: There is an "as if in head" code clone  
         my $title_el;  
         !!!create-element ($title_el, 'title', $token->{attributes});  
         (defined $self->{head_element} ? $self->{head_element} : $self->{open_elements}->[-1]->[0])  
           ->append_child ($title_el);  
         $self->{content_model_flag} = 'RCDATA';  
         delete $self->{escape}; # MUST  
           
         my $text = '';  
         !!!next-token;  
         while ($token->{type} eq 'character') {  
           $text .= $token->{data};  
           !!!next-token;  
         }  
         if (length $text) {  
           $title_el->manakai_append_text ($text);  
         }  
           
         $self->{content_model_flag} = 'PCDATA';  
           
         if ($token->{type} eq 'end tag' and  
             $token->{tag_name} eq 'title') {  
           ## Ignore the token  
         } else {  
           !!!parse-error (type => 'in RCDATA:#'.$token->{type});  
           ## ISSUE: And ignore?  
         }  
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'body') {  
         !!!parse-error (type => 'in body:body');  
                 
         if (@{$self->{open_elements}} == 1 or  
             $self->{open_elements}->[1]->[1] ne 'body') {  
           ## Ignore the token  
         } else {  
           my $body_el = $self->{open_elements}->[1]->[0];  
           for my $attr_name (keys %{$token->{attributes}}) {  
             unless ($body_el->has_attribute_ns (undef, $attr_name)) {  
               $body_el->set_attribute_ns  
                 (undef, [undef, $attr_name],  
                  $token->{attributes}->{$attr_name}->{value});  
             }  
           }  
         }  
         !!!next-token;  
         return;  
       } elsif ({  
                 address => 1, blockquote => 1, center => 1, dir => 1,  
                 div => 1, dl => 1, fieldset => 1, listing => 1,  
                 menu => 1, ol => 1, p => 1, ul => 1,  
                 pre => 1,  
                }->{$token->{tag_name}}) {  
         ## has a p element in scope  
         INSCOPE: for (reverse @{$self->{open_elements}}) {  
           if ($_->[1] eq 'p') {  
             !!!back-token;  
             $token = {type => 'end tag', tag_name => 'p'};  
             return;  
           } elsif ({  
                     table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$_->[1]}) {  
             last INSCOPE;  
           }  
         } # INSCOPE  
             
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
         if ($token->{tag_name} eq 'pre') {  
           !!!next-token;  
           if ($token->{type} eq 'character') {  
             $token->{data} =~ s/^\x0A//;  
             unless (length $token->{data}) {  
               !!!next-token;  
             }  
           }  
         } else {  
           !!!next-token;  
         }  
         return;  
       } elsif ($token->{tag_name} eq 'form') {  
         if (defined $self->{form_element}) {  
           !!!parse-error (type => 'in form:form');  
           ## Ignore the token  
           !!!next-token;  
           return;  
         } else {  
           ## has a p element in scope  
           INSCOPE: for (reverse @{$self->{open_elements}}) {  
             if ($_->[1] eq 'p') {  
               !!!back-token;  
               $token = {type => 'end tag', tag_name => 'p'};  
               return;  
             } elsif ({  
                       table => 1, caption => 1, td => 1, th => 1,  
                       button => 1, marquee => 1, object => 1, html => 1,  
                      }->{$_->[1]}) {  
               last INSCOPE;  
             }  
           } # INSCOPE  
               
           !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
           $self->{form_element} = $self->{open_elements}->[-1]->[0];  
           !!!next-token;  
           return;  
         }  
       } elsif ($token->{tag_name} eq 'li') {  
         ## has a p element in scope  
         INSCOPE: for (reverse @{$self->{open_elements}}) {  
           if ($_->[1] eq 'p') {  
             !!!back-token;  
             $token = {type => 'end tag', tag_name => 'p'};  
             return;  
           } elsif ({  
                     table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$_->[1]}) {  
             last INSCOPE;  
           }  
         } # INSCOPE  
             
         ## Step 1  
         my $i = -1;  
         my $node = $self->{open_elements}->[$i];  
         LI: {  
           ## Step 2  
           if ($node->[1] eq 'li') {  
             if ($i != -1) {  
               !!!parse-error (type => 'end tag missing:'.  
                               $self->{open_elements}->[-1]->[1]);  
               ## TODO: test  
             }  
             splice @{$self->{open_elements}}, $i;  
             last LI;  
           }  
             
           ## Step 3  
           if (not $formatting_category->{$node->[1]} and  
               #not $phrasing_category->{$node->[1]} and  
               ($special_category->{$node->[1]} or  
                $scoping_category->{$node->[1]}) and  
               $node->[1] ne 'address' and $node->[1] ne 'div') {  
             last LI;  
           }  
             
           ## Step 4  
           $i--;  
           $node = $self->{open_elements}->[$i];  
           redo LI;  
         } # LI  
             
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'dd' or $token->{tag_name} eq 'dt') {  
         ## has a p element in scope  
         INSCOPE: for (reverse @{$self->{open_elements}}) {  
           if ($_->[1] eq 'p') {  
             !!!back-token;  
             $token = {type => 'end tag', tag_name => 'p'};  
             return;  
           } elsif ({  
                     table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$_->[1]}) {  
             last INSCOPE;  
           }  
         } # INSCOPE  
             
         ## Step 1  
         my $i = -1;  
         my $node = $self->{open_elements}->[$i];  
         LI: {  
           ## Step 2  
           if ($node->[1] eq 'dt' or $node->[1] eq 'dd') {  
             if ($i != -1) {  
               !!!parse-error (type => 'end tag missing:'.  
                               $self->{open_elements}->[-1]->[1]);  
               ## TODO: test  
             }  
             splice @{$self->{open_elements}}, $i;  
             last LI;  
           }  
             
           ## Step 3  
           if (not $formatting_category->{$node->[1]} and  
               #not $phrasing_category->{$node->[1]} and  
               ($special_category->{$node->[1]} or  
                $scoping_category->{$node->[1]}) and  
               $node->[1] ne 'address' and $node->[1] ne 'div') {  
             last LI;  
           }  
             
           ## Step 4  
           $i--;  
           $node = $self->{open_elements}->[$i];  
           redo LI;  
         } # LI  
             
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'plaintext') {  
         ## has a p element in scope  
         INSCOPE: for (reverse @{$self->{open_elements}}) {  
           if ($_->[1] eq 'p') {  
             !!!back-token;  
             $token = {type => 'end tag', tag_name => 'p'};  
             return;  
           } elsif ({  
                     table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$_->[1]}) {  
             last INSCOPE;  
           }  
         } # INSCOPE  
             
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
             
         $self->{content_model_flag} = 'PLAINTEXT';  
             
         !!!next-token;  
         return;  
       } elsif ({  
                 h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,  
                }->{$token->{tag_name}}) {  
         ## has a p element in scope  
         INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
           my $node = $self->{open_elements}->[$_];  
           if ($node->[1] eq 'p') {  
             !!!back-token;  
             $token = {type => 'end tag', tag_name => 'p'};  
             return;  
           } elsif ({  
                     table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$node->[1]}) {  
             last INSCOPE;  
           }  
         } # INSCOPE  
             
         ## has an element in scope  
         my $i;  
         INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
           my $node = $self->{open_elements}->[$_];  
           if ({  
                h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,  
               }->{$node->[1]}) {  
             $i = $_;  
             last INSCOPE;  
           } elsif ({  
                     table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$node->[1]}) {  
             last INSCOPE;  
           }  
         } # INSCOPE  
             
         if (defined $i) {  
           !!!parse-error (type => 'in hn:hn');  
           splice @{$self->{open_elements}}, $i;  
         }  
             
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
             
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'a') {  
         AFE: for my $i (reverse 0..$#$active_formatting_elements) {  
           my $node = $active_formatting_elements->[$i];  
           if ($node->[1] eq 'a') {  
             !!!parse-error (type => 'in a:a');  
               
             !!!back-token;  
             $token = {type => 'end tag', tag_name => 'a'};  
             $formatting_end_tag->($token->{tag_name});  
               
             AFE2: for (reverse 0..$#$active_formatting_elements) {  
               if ($active_formatting_elements->[$_]->[0] eq $node->[0]) {  
                 splice @$active_formatting_elements, $_, 1;  
                 last AFE2;  
               }  
             } # AFE2  
             OE: for (reverse 0..$#{$self->{open_elements}}) {  
               if ($self->{open_elements}->[$_]->[0] eq $node->[0]) {  
                 splice @{$self->{open_elements}}, $_, 1;  
                 last OE;  
               }  
             } # OE  
             last AFE;  
           } elsif ($node->[0] eq '#marker') {  
             last AFE;  
           }  
         } # AFE  
             
         $reconstruct_active_formatting_elements->($insert_to_current);  
   
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
         push @$active_formatting_elements, $self->{open_elements}->[-1];  
   
         !!!next-token;  
         return;  
       } elsif ({  
                 b => 1, big => 1, em => 1, font => 1, i => 1,  
                 nobr => 1, s => 1, small => 1, strile => 1,  
                 strong => 1, tt => 1, u => 1,  
                }->{$token->{tag_name}}) {  
         $reconstruct_active_formatting_elements->($insert_to_current);  
           
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
         push @$active_formatting_elements, $self->{open_elements}->[-1];  
           
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'button') {  
         ## has a button element in scope  
         INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
           my $node = $self->{open_elements}->[$_];  
           if ($node->[1] eq 'button') {  
             !!!parse-error (type => 'in button:button');  
             !!!back-token;  
             $token = {type => 'end tag', tag_name => 'button'};  
             return;  
           } elsif ({  
                     table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$node->[1]}) {  
             last INSCOPE;  
           }  
         } # INSCOPE  
             
         $reconstruct_active_formatting_elements->($insert_to_current);  
             
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
         push @$active_formatting_elements, ['#marker', ''];  
   
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'marquee' or  
                $token->{tag_name} eq 'object') {  
         $reconstruct_active_formatting_elements->($insert_to_current);  
           
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
         push @$active_formatting_elements, ['#marker', ''];  
           
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'xmp') {  
         $reconstruct_active_formatting_elements->($insert_to_current);  
           
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
           
         $self->{content_model_flag} = 'CDATA';  
         delete $self->{escape}; # MUST  
           
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'table') {  
         ## has a p element in scope  
         INSCOPE: for (reverse @{$self->{open_elements}}) {  
           if ($_->[1] eq 'p') {  
             !!!back-token;  
             $token = {type => 'end tag', tag_name => 'p'};  
             return;  
           } elsif ({  
                     table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$_->[1]}) {  
             last INSCOPE;  
           }  
         } # INSCOPE  
             
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
             
         $self->{insertion_mode} = 'in table';  
             
         !!!next-token;  
         return;  
       } elsif ({  
                 area => 1, basefont => 1, bgsound => 1, br => 1,  
                 embed => 1, img => 1, param => 1, spacer => 1, wbr => 1,  
                 image => 1,  
                }->{$token->{tag_name}}) {  
         if ($token->{tag_name} eq 'image') {  
           !!!parse-error (type => 'image');  
           $token->{tag_name} = 'img';  
         }  
           
         $reconstruct_active_formatting_elements->($insert_to_current);  
           
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
         pop @{$self->{open_elements}};  
           
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'hr') {  
         ## has a p element in scope  
         INSCOPE: for (reverse @{$self->{open_elements}}) {  
           if ($_->[1] eq 'p') {  
             !!!back-token;  
             $token = {type => 'end tag', tag_name => 'p'};  
             return;  
           } elsif ({  
                     table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$_->[1]}) {  
             last INSCOPE;  
           }  
         } # INSCOPE  
             
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
         pop @{$self->{open_elements}};  
             
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'input') {  
         $reconstruct_active_formatting_elements->($insert_to_current);  
           
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
         ## TODO: associate with $self->{form_element} if defined  
         pop @{$self->{open_elements}};  
           
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'isindex') {  
         !!!parse-error (type => 'isindex');  
           
         if (defined $self->{form_element}) {  
           ## Ignore the token  
           !!!next-token;  
           return;  
         } else {  
           my $at = $token->{attributes};  
           $at->{name} = {name => 'name', value => 'isindex'};  
           my @tokens = (  
                         {type => 'start tag', tag_name => 'form'},  
                         {type => 'start tag', tag_name => 'hr'},  
                         {type => 'start tag', tag_name => 'p'},  
                         {type => 'start tag', tag_name => 'label'},  
                         {type => 'character',  
                          data => 'This is a searchable index. Insert your search keywords here: '}, # SHOULD  
                         ## TODO: make this configurable  
                         {type => 'start tag', tag_name => 'input', attributes => $at},  
                         #{type => 'character', data => ''}, # SHOULD  
                         {type => 'end tag', tag_name => 'label'},  
                         {type => 'end tag', tag_name => 'p'},  
                         {type => 'start tag', tag_name => 'hr'},  
                         {type => 'end tag', tag_name => 'form'},  
                        );  
           $token = shift @tokens;  
           !!!back-token (@tokens);  
           return;  
         }  
       } elsif ({  
                 textarea => 1,  
                 iframe => 1,  
                 noembed => 1,  
                 noframes => 1,  
                 noscript => 0, ## TODO: 1 if scripting is enabled  
                }->{$token->{tag_name}}) {  
         my $tag_name = $token->{tag_name};  
         my $el;  
         !!!create-element ($el, $token->{tag_name}, $token->{attributes});  
           
         if ($token->{tag_name} eq 'textarea') {  
           ## TODO: $self->{form_element} if defined  
           $self->{content_model_flag} = 'RCDATA';  
         } else {  
           $self->{content_model_flag} = 'CDATA';  
         }  
         delete $self->{escape}; # MUST  
           
         $insert->($el);  
           
         my $text = '';  
         if ($token->{tag_name} eq 'textarea') {  
           !!!next-token;  
           if ($token->{type} eq 'character') {  
             $token->{data} =~ s/^\x0A//;  
             unless (length $token->{data}) {  
               !!!next-token;  
             }  
           }  
         } else {  
           !!!next-token;  
         }  
         while ($token->{type} eq 'character') {  
           $text .= $token->{data};  
           !!!next-token;  
         }  
         if (length $text) {  
           $el->manakai_append_text ($text);  
         }  
           
         $self->{content_model_flag} = 'PCDATA';  
           
         if ($token->{type} eq 'end tag' and  
             $token->{tag_name} eq $tag_name) {  
           ## Ignore the token  
         } else {  
           if ($token->{tag_name} eq 'textarea') {  
             !!!parse-error (type => 'in RCDATA:#'.$token->{type});  
           } else {  
             !!!parse-error (type => 'in CDATA:#'.$token->{type});  
           }  
           ## ISSUE: And ignore?  
         }  
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'select') {  
         $reconstruct_active_formatting_elements->($insert_to_current);  
           
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
           
         $self->{insertion_mode} = 'in select';  
         !!!next-token;  
         return;  
       } elsif ({  
                 caption => 1, col => 1, colgroup => 1, frame => 1,  
                 frameset => 1, head => 1, option => 1, optgroup => 1,  
                 tbody => 1, td => 1, tfoot => 1, th => 1,  
                 thead => 1, tr => 1,  
                }->{$token->{tag_name}}) {  
         !!!parse-error (type => 'in body:'.$token->{tag_name});  
         ## Ignore the token  
         !!!next-token;  
         return;  
           
         ## ISSUE: An issue on HTML5 new elements in the spec.  
       } else {  
         $reconstruct_active_formatting_elements->($insert_to_current);  
           
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
           
         !!!next-token;  
         return;  
       }  
     } elsif ($token->{type} eq 'end tag') {  
       if ($token->{tag_name} eq 'body') {  
         if (@{$self->{open_elements}} > 1 and $self->{open_elements}->[1]->[1] eq 'body') {  
           ## ISSUE: There is an issue in the spec.  
           if ($self->{open_elements}->[-1]->[1] ne 'body') {  
             !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
           }  
           $self->{insertion_mode} = 'after body';  
           !!!next-token;  
           return;  
         } else {  
           !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
           ## Ignore the token  
           !!!next-token;  
           return;  
         }  
       } elsif ($token->{tag_name} eq 'html') {  
         if (@{$self->{open_elements}} > 1 and $self->{open_elements}->[1]->[1] eq 'body') {  
           ## ISSUE: There is an issue in the spec.  
           if ($self->{open_elements}->[-1]->[1] ne 'body') {  
             !!!parse-error (type => 'not closed:'.$self->{open_elements}->[1]->[1]);  
           }  
           $self->{insertion_mode} = 'after body';  
           ## reprocess  
           return;  
         } else {  
           !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
           ## Ignore the token  
           !!!next-token;  
           return;  
         }  
       } elsif ({  
                 address => 1, blockquote => 1, center => 1, dir => 1,  
                 div => 1, dl => 1, fieldset => 1, listing => 1,  
                 menu => 1, ol => 1, pre => 1, ul => 1,  
                 p => 1,  
                 dd => 1, dt => 1, li => 1,  
                 button => 1, marquee => 1, object => 1,  
                }->{$token->{tag_name}}) {  
         ## has an element in scope  
         my $i;  
         INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
           my $node = $self->{open_elements}->[$_];  
           if ($node->[1] eq $token->{tag_name}) {  
             ## generate implied end tags  
             if ({  
                  dd => ($token->{tag_name} ne 'dd'),  
                  dt => ($token->{tag_name} ne 'dt'),  
                  li => ($token->{tag_name} ne 'li'),  
                  p => ($token->{tag_name} ne 'p'),  
                  td => 1, th => 1, tr => 1,  
                 }->{$self->{open_elements}->[-1]->[1]}) {  
               !!!back-token;  
               $token = {type => 'end tag',  
                         tag_name => $self->{open_elements}->[-1]->[1]}; # MUST  
               return;  
             }  
             $i = $_;  
             last INSCOPE unless $token->{tag_name} eq 'p';  
           } elsif ({  
                     table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$node->[1]}) {  
             last INSCOPE;  
           }  
         } # INSCOPE  
           
         if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {  
           !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
         }  
           
         splice @{$self->{open_elements}}, $i if defined $i;  
         $clear_up_to_marker->()  
           if {  
             button => 1, marquee => 1, object => 1,  
           }->{$token->{tag_name}};  
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'form') {  
         ## has an element in scope  
         INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
           my $node = $self->{open_elements}->[$_];  
           if ($node->[1] eq $token->{tag_name}) {  
             ## generate implied end tags  
             if ({  
                  dd => 1, dt => 1, li => 1, p => 1,  
                  td => 1, th => 1, tr => 1,  
                 }->{$self->{open_elements}->[-1]->[1]}) {  
               !!!back-token;  
               $token = {type => 'end tag',  
                         tag_name => $self->{open_elements}->[-1]->[1]}; # MUST  
               return;  
             }  
             last INSCOPE;  
           } elsif ({  
                     table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$node->[1]}) {  
             last INSCOPE;  
           }  
         } # INSCOPE  
           
         if ($self->{open_elements}->[-1]->[1] eq $token->{tag_name}) {  
           pop @{$self->{open_elements}};  
         } else {  
           !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
         }  
   
         undef $self->{form_element};  
         !!!next-token;  
         return;  
       } elsif ({  
                 h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,  
                }->{$token->{tag_name}}) {  
         ## has an element in scope  
         my $i;  
         INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
           my $node = $self->{open_elements}->[$_];  
           if ({  
                h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,  
               }->{$node->[1]}) {  
             ## generate implied end tags  
             if ({  
                  dd => 1, dt => 1, li => 1, p => 1,  
                  td => 1, th => 1, tr => 1,  
                 }->{$self->{open_elements}->[-1]->[1]}) {  
               !!!back-token;  
               $token = {type => 'end tag',  
                         tag_name => $self->{open_elements}->[-1]->[1]}; # MUST  
               return;  
             }  
             $i = $_;  
             last INSCOPE;  
           } elsif ({  
                     table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$node->[1]}) {  
             last INSCOPE;  
           }  
         } # INSCOPE  
           
         if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {  
           !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
         }  
           
         splice @{$self->{open_elements}}, $i if defined $i;  
         !!!next-token;  
         return;  
       } elsif ({  
                 a => 1,  
                 b => 1, big => 1, em => 1, font => 1, i => 1,  
                 nobr => 1, s => 1, small => 1, strile => 1,  
                 strong => 1, tt => 1, u => 1,  
                }->{$token->{tag_name}}) {  
         $formatting_end_tag->($token->{tag_name});  
 ## TODO: <http://html5.org/tools/web-apps-tracker?from=883&to=884>  
         return;  
       } elsif ({  
                 caption => 1, col => 1, colgroup => 1, frame => 1,  
                 frameset => 1, head => 1, option => 1, optgroup => 1,  
                 tbody => 1, td => 1, tfoot => 1, th => 1,  
                 thead => 1, tr => 1,  
                 area => 1, basefont => 1, bgsound => 1, br => 1,  
                 embed => 1, hr => 1, iframe => 1, image => 1,  
                 img => 1, input => 1, isindex => 1, noembed => 1,  
                 noframes => 1, param => 1, select => 1, spacer => 1,  
                 table => 1, textarea => 1, wbr => 1,  
                 noscript => 0, ## TODO: if scripting is enabled  
                }->{$token->{tag_name}}) {  
         !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
         ## Ignore the token  
         !!!next-token;  
         return;  
           
         ## ISSUE: Issue on HTML5 new elements in spec  
           
       } else {  
         ## Step 1  
         my $node_i = -1;  
         my $node = $self->{open_elements}->[$node_i];  
   
         ## Step 2  
         S2: {  
           if ($node->[1] eq $token->{tag_name}) {  
             ## Step 1  
             ## generate implied end tags  
             if ({  
                  dd => 1, dt => 1, li => 1, p => 1,  
                  td => 1, th => 1, tr => 1,  
                 }->{$self->{open_elements}->[-1]->[1]}) {  
               !!!back-token;  
               $token = {type => 'end tag',  
                         tag_name => $self->{open_elements}->[-1]->[1]}; # MUST  
               return;  
             }  
           
             ## Step 2  
             if ($token->{tag_name} ne $self->{open_elements}->[-1]->[1]) {  
               !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
             }  
               
             ## Step 3  
             splice @{$self->{open_elements}}, $node_i;  
   
             !!!next-token;  
             last S2;  
           } else {  
             ## Step 3  
             if (not $formatting_category->{$node->[1]} and  
                 #not $phrasing_category->{$node->[1]} and  
                 ($special_category->{$node->[1]} or  
                  $scoping_category->{$node->[1]})) {  
               !!!parse-error (type => 'not closed:'.$node->[1]);  
               ## Ignore the token  
               !!!next-token;  
               last S2;  
             }  
           }  
             
           ## Step 4  
           $node_i--;  
           $node = $self->{open_elements}->[$node_i];  
             
           ## Step 5;  
           redo S2;  
         } # S2  
         return;  
       }  
     }  
   }; # $in_body  
2567    
2568    B: {    B: {
2569      if ($phase eq 'main') {      if ($token->{type} == DOCTYPE_TOKEN) {
2570        if ($token->{type} eq 'DOCTYPE') {        !!!parse-error (type => 'DOCTYPE in the middle');
2571          !!!parse-error (type => 'in html:#DOCTYPE');        ## Ignore the token
2572          ## Ignore the token        ## Stay in the phase
2573          ## Stay in the phase        !!!next-token;
2574          !!!next-token;        redo B;
2575          redo B;      } elsif ($token->{type} == END_OF_FILE_TOKEN) {
2576        } elsif ($token->{type} eq 'start tag' and        if ($self->{insertion_mode} & AFTER_HTML_IMS) {
2577                 $token->{tag_name} eq 'html') {          #
2578          ## TODO: unless it is the first start tag token, parse-error        } else {
         my $top_el = $self->{open_elements}->[0]->[0];  
         for my $attr_name (keys %{$token->{attributes}}) {  
           unless ($top_el->has_attribute_ns (undef, $attr_name)) {  
             $top_el->set_attribute_ns  
               (undef, [undef, $attr_name],  
                $token->{attributes}->{$attr_name}->{value});  
           }  
         }  
         !!!next-token;  
         redo B;  
       } elsif ($token->{type} eq 'end-of-file') {  
2579          ## Generate implied end tags          ## Generate implied end tags
2580          if ({          if ({
2581               dd => 1, dt => 1, li => 1, p => 1, td => 1, th => 1, tr => 1,               dd => 1, dt => 1, li => 1, p => 1, td => 1, th => 1, tr => 1,
2582                 tbody => 1, tfoot=> 1, thead => 1,
2583              }->{$self->{open_elements}->[-1]->[1]}) {              }->{$self->{open_elements}->[-1]->[1]}) {
2584            !!!back-token;            !!!back-token;
2585            $token = {type => 'end tag', tag_name => $self->{open_elements}->[-1]->[1]};            $token = {type => END_TAG_TOKEN, tag_name => $self->{open_elements}->[-1]->[1]};
2586            redo B;            redo B;
2587          }          }
2588                    
# Line 3078  sub _tree_construction_main ($) { Line 2595  sub _tree_construction_main ($) {
2595            !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);            !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
2596          }          }
2597    
         ## Stop parsing  
         last B;  
   
2598          ## ISSUE: There is an issue in the spec.          ## ISSUE: There is an issue in the spec.
2599          }
2600    
2601          ## Stop parsing
2602          last B;
2603        } elsif ($token->{type} == START_TAG_TOKEN and
2604                 $token->{tag_name} eq 'html') {
2605          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
2606            ## Turn into the main phase
2607            !!!parse-error (type => 'after html:html');
2608            $self->{insertion_mode} = AFTER_BODY_IM;
2609          } elsif ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
2610            ## Turn into the main phase
2611            !!!parse-error (type => 'after html:html');
2612            $self->{insertion_mode} = AFTER_FRAMESET_IM;
2613          }
2614    
2615    ## ISSUE: "aa<html>" is not a parse error.
2616    ## ISSUE: "<html>" in fragment is not a parse error.
2617          unless ($token->{first_start_tag}) {
2618            !!!parse-error (type => 'not first start tag');
2619          }
2620          my $top_el = $self->{open_elements}->[0]->[0];
2621          for my $attr_name (keys %{$token->{attributes}}) {
2622            unless ($top_el->has_attribute_ns (undef, $attr_name)) {
2623              $top_el->set_attribute_ns
2624                (undef, [undef, $attr_name],
2625                 $token->{attributes}->{$attr_name}->{value});
2626            }
2627          }
2628          !!!next-token;
2629          redo B;
2630        } elsif ($token->{type} == COMMENT_TOKEN) {
2631          my $comment = $self->{document}->create_comment ($token->{data});
2632          if ($self->{insertion_mode} & AFTER_HTML_IMS) {
2633            $self->{document}->append_child ($comment);
2634          } elsif ($self->{insertion_mode} == AFTER_BODY_IM) {
2635            $self->{open_elements}->[0]->[0]->append_child ($comment);
2636        } else {        } else {
2637          if ($self->{insertion_mode} eq 'before head') {          $self->{open_elements}->[-1]->[0]->append_child ($comment);
2638            if ($token->{type} eq 'character') {        }
2639              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {        !!!next-token;
2640                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);        redo B;
2641                unless (length $token->{data}) {      } elsif ($self->{insertion_mode} & HEAD_IMS) {
2642                  !!!next-token;        if ($token->{type} == CHARACTER_TOKEN) {
2643                  redo B;          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
2644                }            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
2645              }            unless (length $token->{data}) {
             ## As if <head>  
             !!!create-element ($self->{head_element}, 'head');  
             $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});  
             push @{$self->{open_elements}}, [$self->{head_element}, 'head'];  
             $self->{insertion_mode} = 'in head';  
             ## reprocess  
             redo B;  
           } elsif ($token->{type} eq 'comment') {  
             my $comment = $self->{document}->create_comment ($token->{data});  
             $self->{open_elements}->[-1]->[0]->append_child ($comment);  
2646              !!!next-token;              !!!next-token;
2647              redo B;              redo B;
2648            } elsif ($token->{type} eq 'start tag') {            }
2649              my $attr = $token->{tag_name} eq 'head' ? $token->{attributes} : {};          }
2650              !!!create-element ($self->{head_element}, 'head', $attr);  
2651              $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});          if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2652              push @{$self->{open_elements}}, [$self->{head_element}, 'head'];            ## As if <head>
2653              $self->{insertion_mode} = 'in head';            !!!create-element ($self->{head_element}, 'head');
2654              if ($token->{tag_name} eq 'head') {            $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2655                !!!next-token;            push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2656              #} elsif ({  
2657              #          base => 1, link => 1, meta => 1,            ## Reprocess in the "in head" insertion mode...
2658              #          script => 1, style => 1, title => 1,            pop @{$self->{open_elements}};
2659              #         }->{$token->{tag_name}}) {  
2660              #  ## reprocess            ## Reprocess in the "after head" insertion mode...
2661              } else {          } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2662                ## reprocess            ## As if </noscript>
2663              }            pop @{$self->{open_elements}};
2664              !!!parse-error (type => 'in noscript:#character');
2665              
2666              ## Reprocess in the "in head" insertion mode...
2667              ## As if </head>
2668              pop @{$self->{open_elements}};
2669    
2670              ## Reprocess in the "after head" insertion mode...
2671            } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2672              pop @{$self->{open_elements}};
2673    
2674              ## Reprocess in the "after head" insertion mode...
2675            }
2676    
2677                ## "after head" insertion mode
2678                ## As if <body>
2679                !!!insert-element ('body');
2680                $self->{insertion_mode} = IN_BODY_IM;
2681                ## reprocess
2682              redo B;              redo B;
2683            } elsif ($token->{type} eq 'end tag') {            } elsif ($token->{type} == START_TAG_TOKEN) {
2684              if ($token->{tag_name} eq 'html') {              if ($token->{tag_name} eq 'head') {
2685                  if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2686                    !!!create-element ($self->{head_element}, $token->{tag_name}, $token->{attributes});
2687                    $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2688                    push @{$self->{open_elements}}, [$self->{head_element}, $token->{tag_name}];
2689                    $self->{insertion_mode} = IN_HEAD_IM;
2690                    !!!next-token;
2691                    redo B;
2692                  } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2693                    #
2694                  } else {
2695                    !!!parse-error (type => 'in head:head'); # or in head noscript
2696                    ## Ignore the token
2697                    !!!next-token;
2698                    redo B;
2699                  }
2700                } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2701                ## As if <head>                ## As if <head>
2702                !!!create-element ($self->{head_element}, 'head');                !!!create-element ($self->{head_element}, 'head');
2703                $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});                $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2704                push @{$self->{open_elements}}, [$self->{head_element}, 'head'];                push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2705                $self->{insertion_mode} = 'in head';  
2706                ## reprocess                $self->{insertion_mode} = IN_HEAD_IM;
2707                redo B;                ## Reprocess in the "in head" insertion mode...
             } else {  
               !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
               ## Ignore the token  
               !!!next-token;  
               redo B;  
             }  
           } else {  
             die "$0: $token->{type}: Unknown type";  
           }  
         } elsif ($self->{insertion_mode} eq 'in head') {  
           if ($token->{type} eq 'character') {  
             if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {  
               $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);  
               unless (length $token->{data}) {  
                 !!!next-token;  
                 redo B;  
               }  
2708              }              }
               
             #  
           } elsif ($token->{type} eq 'comment') {  
             my $comment = $self->{document}->create_comment ($token->{data});  
             $self->{open_elements}->[-1]->[0]->append_child ($comment);  
             !!!next-token;  
             redo B;  
           } elsif ($token->{type} eq 'start tag') {  
             if ($token->{tag_name} eq 'title') {  
               ## NOTE: There is an "as if in head" code clone  
               my $title_el;  
               !!!create-element ($title_el, 'title', $token->{attributes});  
               (defined $self->{head_element} ? $self->{head_element} : $self->{open_elements}->[-1]->[0])  
                 ->append_child ($title_el);  
               $self->{content_model_flag} = 'RCDATA';  
               delete $self->{escape}; # MUST  
2709    
2710                my $text = '';              if ($token->{tag_name} eq 'base') {
2711                !!!next-token;                if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2712                while ($token->{type} eq 'character') {                  ## As if </noscript>
2713                  $text .= $token->{data};                  pop @{$self->{open_elements}};
2714                  !!!next-token;                  !!!parse-error (type => 'in noscript:base');
               }  
               if (length $text) {  
                 $title_el->manakai_append_text ($text);  
               }  
                 
               $self->{content_model_flag} = 'PCDATA';  
2715                                
2716                if ($token->{type} eq 'end tag' and                  $self->{insertion_mode} = IN_HEAD_IM;
2717                    $token->{tag_name} eq 'title') {                  ## Reprocess in the "in head" insertion mode...
                 ## Ignore the token  
               } else {  
                 !!!parse-error (type => 'in RCDATA:#'.$token->{type});  
                 ## ISSUE: And ignore?  
2718                }                }
2719    
2720                  ## NOTE: There is a "as if in head" code clone.
2721                  if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2722                    !!!parse-error (type => 'after head:'.$token->{tag_name});
2723                    push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2724                  }
2725                  !!!insert-element ($token->{tag_name}, $token->{attributes});
2726                  pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
2727                  pop @{$self->{open_elements}}
2728                      if $self->{insertion_mode} == AFTER_HEAD_IM;
2729                !!!next-token;                !!!next-token;
2730                redo B;                redo B;
2731              } elsif ($token->{tag_name} eq 'style') {              } elsif ($token->{tag_name} eq 'link') {
2732                $style_start_tag->();                ## NOTE: There is a "as if in head" code clone.
2733                redo B;                if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2734              } elsif ($token->{tag_name} eq 'script') {                  !!!parse-error (type => 'after head:'.$token->{tag_name});
2735                $script_start_tag->();                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2736                  }
2737                  !!!insert-element ($token->{tag_name}, $token->{attributes});
2738                  pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
2739                  pop @{$self->{open_elements}}
2740                      if $self->{insertion_mode} == AFTER_HEAD_IM;
2741                  !!!next-token;
2742                redo B;                redo B;
2743              } elsif ({base => 1, link => 1, meta => 1}->{$token->{tag_name}}) {              } elsif ($token->{tag_name} eq 'meta') {
2744                ## NOTE: There are "as if in head" code clones                ## NOTE: There is a "as if in head" code clone.
2745                my $el;                if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2746                !!!create-element ($el, $token->{tag_name}, $token->{attributes});                  !!!parse-error (type => 'after head:'.$token->{tag_name});
2747                (defined $self->{head_element} ? $self->{head_element} : $self->{open_elements}->[-1]->[0])                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2748                  ->append_child ($el);                }
2749                  !!!insert-element ($token->{tag_name}, $token->{attributes});
2750                  pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
2751    
2752                  unless ($self->{confident}) {
2753                    my $charset;
2754                    if ($token->{attributes}->{charset}) { ## TODO: And if supported
2755                      $charset = $token->{attributes}->{charset}->{value};
2756                    }
2757                    if ($token->{attributes}->{'http-equiv'}) {
2758                      ## ISSUE: Algorithm name in the spec was incorrect so that not linked to the definition.
2759                      if ($token->{attributes}->{'http-equiv'}->{value}
2760                          =~ /\A[^;]*;[\x09-\x0D\x20]*charset[\x09-\x0D\x20]*=
2761                              [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'|
2762                              ([^"'\x09-\x0D\x20][^\x09-\x0D\x20]*))/x) {
2763                        $charset = defined $1 ? $1 : defined $2 ? $2 : $3;
2764                      } ## TODO: And if supported
2765                    }
2766                    ## TODO: Change the encoding
2767                  }
2768    
2769                  ## TODO: Extracting |charset| from |meta|.
2770                  pop @{$self->{open_elements}}
2771                      if $self->{insertion_mode} == AFTER_HEAD_IM;
2772                !!!next-token;                !!!next-token;
2773                redo B;                redo B;
2774              } elsif ($token->{tag_name} eq 'head') {              } elsif ($token->{tag_name} eq 'title') {
2775                !!!parse-error (type => 'in head:head');                if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2776                ## Ignore the token                  ## As if </noscript>
2777                !!!next-token;                  pop @{$self->{open_elements}};
2778                    !!!parse-error (type => 'in noscript:title');
2779                  
2780                    $self->{insertion_mode} = IN_HEAD_IM;
2781                    ## Reprocess in the "in head" insertion mode...
2782                  } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2783                    !!!parse-error (type => 'after head:'.$token->{tag_name});
2784                    push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2785                  }
2786    
2787                  ## NOTE: There is a "as if in head" code clone.
2788                  my $parent = defined $self->{head_element} ? $self->{head_element}
2789                      : $self->{open_elements}->[-1]->[0];
2790                  $parse_rcdata->(RCDATA_CONTENT_MODEL,
2791                                  sub { $parent->append_child ($_[0]) });
2792                  pop @{$self->{open_elements}}
2793                      if $self->{insertion_mode} == AFTER_HEAD_IM;
2794                redo B;                redo B;
2795              } else {              } elsif ($token->{tag_name} eq 'style') {
2796                #                ## NOTE: Or (scripting is enabled and tag_name eq 'noscript' and
2797              }                ## insertion mode IN_HEAD_IM)
2798            } elsif ($token->{type} eq 'end tag') {                ## NOTE: There is a "as if in head" code clone.
2799              if ($token->{tag_name} eq 'head') {                if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2800                if ($self->{open_elements}->[-1]->[1] eq 'head') {                  !!!parse-error (type => 'after head:'.$token->{tag_name});
2801                    push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2802                  }
2803                  $parse_rcdata->(CDATA_CONTENT_MODEL, $insert_to_current);
2804                  pop @{$self->{open_elements}}
2805                      if $self->{insertion_mode} == AFTER_HEAD_IM;
2806                  redo B;
2807                } elsif ($token->{tag_name} eq 'noscript') {
2808                  if ($self->{insertion_mode} == IN_HEAD_IM) {
2809                    ## NOTE: and scripting is disalbed
2810                    !!!insert-element ($token->{tag_name}, $token->{attributes});
2811                    $self->{insertion_mode} = IN_HEAD_NOSCRIPT_IM;
2812                    !!!next-token;
2813                    redo B;
2814                  } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2815                    !!!parse-error (type => 'in noscript:noscript');
2816                    ## Ignore the token
2817                    !!!next-token;
2818                    redo B;
2819                  } else {
2820                    #
2821                  }
2822                } elsif ($token->{tag_name} eq 'script') {
2823                  if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2824                    ## As if </noscript>
2825                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
2826                    !!!parse-error (type => 'in noscript:script');
2827                  
2828                    $self->{insertion_mode} = IN_HEAD_IM;
2829                    ## Reprocess in the "in head" insertion mode...
2830                  } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2831                    !!!parse-error (type => 'after head:'.$token->{tag_name});
2832                    push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2833                  }
2834    
2835                  ## NOTE: There is a "as if in head" code clone.
2836                  $script_start_tag->($insert_to_current);
2837                  pop @{$self->{open_elements}}
2838                      if $self->{insertion_mode} == AFTER_HEAD_IM;
2839                  redo B;
2840                } elsif ($token->{tag_name} eq 'body' or
2841                         $token->{tag_name} eq 'frameset') {
2842                  if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2843                    ## As if </noscript>
2844                    pop @{$self->{open_elements}};
2845                    !!!parse-error (type => 'in noscript:'.$token->{tag_name});
2846                    
2847                    ## Reprocess in the "in head" insertion mode...
2848                    ## As if </head>
2849                    pop @{$self->{open_elements}};
2850                    
2851                    ## Reprocess in the "after head" insertion mode...
2852                  } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2853                    pop @{$self->{open_elements}};
2854                    
2855                    ## Reprocess in the "after head" insertion mode...
2856                  }
2857    
2858                  ## "after head" insertion mode
2859                  !!!insert-element ($token->{tag_name}, $token->{attributes});
2860                  if ($token->{tag_name} eq 'body') {
2861                    $self->{insertion_mode} = IN_BODY_IM;
2862                  } elsif ($token->{tag_name} eq 'frameset') {
2863                    $self->{insertion_mode} = IN_FRAMESET_IM;
2864                } else {                } else {
2865                  !!!parse-error (type => 'unmatched end tag:head');                  die "$0: tag name: $self->{tag_name}";
2866                }                }
               $self->{insertion_mode} = 'after head';  
2867                !!!next-token;                !!!next-token;
2868                redo B;                redo B;
             } elsif ($token->{tag_name} eq 'html') {  
               #  
2869              } else {              } else {
2870                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                #
               ## Ignore the token  
               !!!next-token;  
               redo B;  
2871              }              }
           } else {  
             #  
           }  
2872    
2873            if ($self->{open_elements}->[-1]->[1] eq 'head') {              if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2874              ## As if </head>                ## As if </noscript>
2875              pop @{$self->{open_elements}};                pop @{$self->{open_elements}};
2876            }                !!!parse-error (type => 'in noscript:/'.$token->{tag_name});
2877            $self->{insertion_mode} = 'after head';                
2878            ## reprocess                ## Reprocess in the "in head" insertion mode...
2879            redo B;                ## As if </head>
2880                  pop @{$self->{open_elements}};
2881    
2882            ## ISSUE: An issue in the spec.                ## Reprocess in the "after head" insertion mode...
2883          } elsif ($self->{insertion_mode} eq 'after head') {              } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2884            if ($token->{type} eq 'character') {                ## As if </head>
2885              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {                pop @{$self->{open_elements}};
2886                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);  
2887                unless (length $token->{data}) {                ## Reprocess in the "after head" insertion mode...
                 !!!next-token;  
                 redo B;  
               }  
2888              }              }
               
             #  
           } elsif ($token->{type} eq 'comment') {  
             my $comment = $self->{document}->create_comment ($token->{data});  
             $self->{open_elements}->[-1]->[0]->append_child ($comment);  
             !!!next-token;  
             redo B;  
           } elsif ($token->{type} eq 'start tag') {  
             if ($token->{tag_name} eq 'body') {  
               !!!insert-element ('body', $token->{attributes});  
               $self->{insertion_mode} = 'in body';  
               !!!next-token;  
               redo B;  
             } elsif ($token->{tag_name} eq 'frameset') {  
               !!!insert-element ('frameset', $token->{attributes});  
               $self->{insertion_mode} = 'in frameset';  
               !!!next-token;  
               redo B;  
             } elsif ({  
                       base => 1, link => 1, meta => 1,  
                       script => 1, style => 1, title => 1,  
                      }->{$token->{tag_name}}) {  
               !!!parse-error (type => 'after head:'.$token->{tag_name});  
               $self->{insertion_mode} = 'in head';  
               ## reprocess  
               redo B;  
             } else {  
               #  
             }  
           } else {  
             #  
           }  
             
           ## As if <body>  
           !!!insert-element ('body');  
           $self->{insertion_mode} = 'in body';  
           ## reprocess  
           redo B;  
         } elsif ($self->{insertion_mode} eq 'in body') {  
           if ($token->{type} eq 'character') {  
             ## NOTE: There is a code clone of "character in body".  
             $reconstruct_active_formatting_elements->($insert_to_current);  
               
             $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});  
2889    
2890              !!!next-token;              ## "after head" insertion mode
2891              redo B;              ## As if <body>
2892            } elsif ($token->{type} eq 'comment') {              !!!insert-element ('body');
2893              ## NOTE: There is a code clone of "comment in body".              $self->{insertion_mode} = IN_BODY_IM;
2894              my $comment = $self->{document}->create_comment ($token->{data});              ## reprocess
             $self->{open_elements}->[-1]->[0]->append_child ($comment);  
             !!!next-token;  
             redo B;  
           } else {  
             $in_body->($insert_to_current);  
2895              redo B;              redo B;
2896            }            } elsif ($token->{type} == END_TAG_TOKEN) {
2897          } elsif ($self->{insertion_mode} eq 'in table') {              if ($token->{tag_name} eq 'head') {
2898            if ($token->{type} eq 'character') {                if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2899              ## NOTE: There are "character in table" code clones.                  ## As if <head>
2900              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {                  !!!create-element ($self->{head_element}, 'head');
2901                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);                  $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2902                                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2903                unless (length $token->{data}) {  
2904                    ## Reprocess in the "in head" insertion mode...
2905                    pop @{$self->{open_elements}};
2906                    $self->{insertion_mode} = AFTER_HEAD_IM;
2907                    !!!next-token;
2908                    redo B;
2909                  } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2910                    ## As if </noscript>
2911                    pop @{$self->{open_elements}};
2912                    !!!parse-error (type => 'in noscript:script');
2913                    
2914                    ## Reprocess in the "in head" insertion mode...
2915                    pop @{$self->{open_elements}};
2916                    $self->{insertion_mode} = AFTER_HEAD_IM;
2917                    !!!next-token;
2918                    redo B;
2919                  } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2920                    pop @{$self->{open_elements}};
2921                    $self->{insertion_mode} = AFTER_HEAD_IM;
2922                  !!!next-token;                  !!!next-token;
2923                  redo B;                  redo B;
               }  
             }  
   
             !!!parse-error (type => 'in table:#character');  
   
             ## As if in body, but insert into foster parent element  
             ## ISSUE: Spec says that "whenever a node would be inserted  
             ## into the current node" while characters might not be  
             ## result in a new Text node.  
             $reconstruct_active_formatting_elements->($insert_to_foster);  
               
             if ({  
                  table => 1, tbody => 1, tfoot => 1,  
                  thead => 1, tr => 1,  
                 }->{$self->{open_elements}->[-1]->[1]}) {  
               # MUST  
               my $foster_parent_element;  
               my $next_sibling;  
               my $prev_sibling;  
               OE: for (reverse 0..$#{$self->{open_elements}}) {  
                 if ($self->{open_elements}->[$_]->[1] eq 'table') {  
                   my $parent = $self->{open_elements}->[$_]->[0]->parent_node;  
                   if (defined $parent and $parent->node_type == 1) {  
                     $foster_parent_element = $parent;  
                     $next_sibling = $self->{open_elements}->[$_]->[0];  
                     $prev_sibling = $next_sibling->previous_sibling;  
                   } else {  
                     $foster_parent_element = $self->{open_elements}->[$_ - 1]->[0];  
                     $prev_sibling = $foster_parent_element->last_child;  
                   }  
                   last OE;  
                 }  
               } # OE  
               $foster_parent_element = $self->{open_elements}->[0]->[0] and  
               $prev_sibling = $foster_parent_element->last_child  
                 unless defined $foster_parent_element;  
               if (defined $prev_sibling and  
                   $prev_sibling->node_type == 3) {  
                 $prev_sibling->manakai_append_text ($token->{data});  
2924                } else {                } else {
2925                  $foster_parent_element->insert_before                  #
                   ($self->{document}->create_text_node ($token->{data}),  
                    $next_sibling);  
2926                }                }
2927              } else {              } elsif ($token->{tag_name} eq 'noscript') {
2928                $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});                if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
             }  
               
             !!!next-token;  
             redo B;  
           } elsif ($token->{type} eq 'comment') {  
             my $comment = $self->{document}->create_comment ($token->{data});  
             $self->{open_elements}->[-1]->[0]->append_child ($comment);  
             !!!next-token;  
             redo B;  
           } elsif ($token->{type} eq 'start tag') {  
             if ({  
                  caption => 1,  
                  colgroup => 1,  
                  tbody => 1, tfoot => 1, thead => 1,  
                 }->{$token->{tag_name}}) {  
               ## Clear back to table context  
               while ($self->{open_elements}->[-1]->[1] ne 'table' and  
                      $self->{open_elements}->[-1]->[1] ne 'html') {  
                 !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
2929                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
2930                    $self->{insertion_mode} = IN_HEAD_IM;
2931                    !!!next-token;
2932                    redo B;
2933                  } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2934                    !!!parse-error (type => 'unmatched end tag:noscript');
2935                    ## Ignore the token ## ISSUE: An issue in the spec.
2936                    !!!next-token;
2937                    redo B;
2938                  } else {
2939                    #
2940                }                }
   
               push @$active_formatting_elements, ['#marker', '']  
                 if $token->{tag_name} eq 'caption';  
   
               !!!insert-element ($token->{tag_name}, $token->{attributes});  
               $self->{insertion_mode} = {  
                                  caption => 'in caption',  
                                  colgroup => 'in column group',  
                                  tbody => 'in table body',  
                                  tfoot => 'in table body',  
                                  thead => 'in table body',  
                                 }->{$token->{tag_name}};  
               !!!next-token;  
               redo B;  
2941              } elsif ({              } elsif ({
2942                        col => 1,                        body => 1, html => 1,
                       td => 1, th => 1, tr => 1,  
2943                       }->{$token->{tag_name}}) {                       }->{$token->{tag_name}}) {
2944                ## Clear back to table context                if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2945                while ($self->{open_elements}->[-1]->[1] ne 'table' and                  ## As if <head>
2946                       $self->{open_elements}->[-1]->[1] ne 'html') {                  !!!create-element ($self->{head_element}, 'head');
2947                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                  $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2948                  pop @{$self->{open_elements}};                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2949                }  
2950                    $self->{insertion_mode} = IN_HEAD_IM;
2951                !!!insert-element ($token->{tag_name} eq 'col' ? 'colgroup' : 'tbody');                  ## Reprocess in the "in head" insertion mode...
2952                $self->{insertion_mode} = $token->{tag_name} eq 'col'                } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2953                  ? 'in column group' : 'in table body';                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
2954                ## reprocess                  ## Ignore the token
               redo B;  
             } elsif ($token->{tag_name} eq 'table') {  
               ## NOTE: There are code clones for this "table in table"  
               !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
   
               ## As if </table>  
               ## have a table element in table scope  
               my $i;  
               INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
                 my $node = $self->{open_elements}->[$_];  
                 if ($node->[1] eq 'table') {  
                   $i = $_;  
                   last INSCOPE;  
                 } elsif ({  
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
                   last INSCOPE;  
                 }  
               } # INSCOPE  
               unless (defined $i) {  
                 !!!parse-error (type => 'unmatched end tag:table');  
                 ## Ignore tokens </table><table>  
2955                  !!!next-token;                  !!!next-token;
2956                  redo B;                  redo B;
2957                }                }
2958                                
2959                ## generate implied end tags                #
2960                if ({              } elsif ({
2961                     dd => 1, dt => 1, li => 1, p => 1,                        p => 1, br => 1,
2962                     td => 1, th => 1, tr => 1,                       }->{$token->{tag_name}}) {
2963                    }->{$self->{open_elements}->[-1]->[1]}) {                if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2964                  !!!back-token; # <table>                  ## As if <head>
2965                  $token = {type => 'end tag', tag_name => 'table'};                  !!!create-element ($self->{head_element}, 'head');
2966                  !!!back-token;                  $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2967                  $token = {type => 'end tag',                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
                           tag_name => $self->{open_elements}->[-1]->[1]}; # MUST  
                 redo B;  
               }  
2968    
2969                if ($self->{open_elements}->[-1]->[1] ne 'table') {                  $self->{insertion_mode} = IN_HEAD_IM;
2970                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                  ## Reprocess in the "in head" insertion mode...
2971                }                }
2972    
               splice @{$self->{open_elements}}, $i;  
   
               $self->_reset_insertion_mode;  
   
               ## reprocess  
               redo B;  
             } else {  
2973                #                #
2974              }              } else {
2975            } elsif ($token->{type} eq 'end tag') {                if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2976              if ($token->{tag_name} eq 'table') {                  #
2977                ## have a table element in table scope                } else {
               my $i;  
               INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
                 my $node = $self->{open_elements}->[$_];  
                 if ($node->[1] eq $token->{tag_name}) {  
                   $i = $_;  
                   last INSCOPE;  
                 } elsif ({  
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
                   last INSCOPE;  
                 }  
               } # INSCOPE  
               unless (defined $i) {  
2978                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
2979                  ## Ignore the token                  ## Ignore the token
2980                  !!!next-token;                  !!!next-token;
2981                  redo B;                  redo B;
2982                }                }
2983                              }
               ## generate implied end tags  
               if ({  
                    dd => 1, dt => 1, li => 1, p => 1,  
                    td => 1, th => 1, tr => 1,  
                   }->{$self->{open_elements}->[-1]->[1]}) {  
                 !!!back-token;  
                 $token = {type => 'end tag',  
                           tag_name => $self->{open_elements}->[-1]->[1]}; # MUST  
                 redo B;  
               }  
   
               if ($self->{open_elements}->[-1]->[1] ne 'table') {  
                 !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
               }  
2984    
2985                splice @{$self->{open_elements}}, $i;              if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2986                  ## As if </noscript>
2987                  pop @{$self->{open_elements}};
2988                  !!!parse-error (type => 'in noscript:/'.$token->{tag_name});
2989                  
2990                  ## Reprocess in the "in head" insertion mode...
2991                  ## As if </head>
2992                  pop @{$self->{open_elements}};
2993    
2994                $self->_reset_insertion_mode;                ## Reprocess in the "after head" insertion mode...
2995                } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2996                  ## As if </head>
2997                  pop @{$self->{open_elements}};
2998    
2999                !!!next-token;                ## Reprocess in the "after head" insertion mode...
3000                redo B;              } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {
             } elsif ({  
                       body => 1, caption => 1, col => 1, colgroup => 1,  
                       html => 1, tbody => 1, td => 1, tfoot => 1, th => 1,  
                       thead => 1, tr => 1,  
                      }->{$token->{tag_name}}) {  
3001                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3002                ## Ignore the token                ## Ignore the token ## ISSUE: An issue in the spec.
3003                !!!next-token;                !!!next-token;
3004                redo B;                redo B;
             } else {  
               #  
3005              }              }
3006    
3007                ## "after head" insertion mode
3008                ## As if <body>
3009                !!!insert-element ('body');
3010                $self->{insertion_mode} = IN_BODY_IM;
3011                ## reprocess
3012                redo B;
3013            } else {            } else {
3014              #              die "$0: $token->{type}: Unknown token type";
3015            }            }
3016    
3017            !!!parse-error (type => 'in table:'.$token->{tag_name});            ## ISSUE: An issue in the spec.
3018            $in_body->($insert_to_foster);      } elsif ($self->{insertion_mode} & BODY_IMS) {
3019            redo B;            if ($token->{type} == CHARACTER_TOKEN) {
3020          } elsif ($self->{insertion_mode} eq 'in caption') {              ## NOTE: There is a code clone of "character in body".
           if ($token->{type} eq 'character') {  
             ## NOTE: This is a code clone of "character in body".  
3021              $reconstruct_active_formatting_elements->($insert_to_current);              $reconstruct_active_formatting_elements->($insert_to_current);
3022                            
3023              $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});              $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});
3024    
3025              !!!next-token;              !!!next-token;
3026              redo B;              redo B;
3027            } elsif ($token->{type} eq 'comment') {            } elsif ($token->{type} == START_TAG_TOKEN) {
             ## NOTE: This is a code clone of "comment in body".  
             my $comment = $self->{document}->create_comment ($token->{data});  
             $self->{open_elements}->[-1]->[0]->append_child ($comment);  
             !!!next-token;  
             redo B;  
           } elsif ($token->{type} eq 'start tag') {  
3028              if ({              if ({
3029                   caption => 1, col => 1, colgroup => 1, tbody => 1,                   caption => 1, col => 1, colgroup => 1, tbody => 1,
3030                   td => 1, tfoot => 1, th => 1, thead => 1, tr => 1,                   td => 1, tfoot => 1, th => 1, thead => 1, tr => 1,
3031                  }->{$token->{tag_name}}) {                  }->{$token->{tag_name}}) {
3032                !!!parse-error (type => 'not closed:caption');                if ($self->{insertion_mode} == IN_CELL_IM) {
3033                    ## have an element in table scope
3034                    my $tn;
3035                    INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3036                      my $node = $self->{open_elements}->[$_];
3037                      if ($node->[1] eq 'td' or $node->[1] eq 'th') {
3038                        $tn = $node->[1];
3039                        last INSCOPE;
3040                      } elsif ({
3041                                table => 1, html => 1,
3042                               }->{$node->[1]}) {
3043                        last INSCOPE;
3044                      }
3045                    } # INSCOPE
3046                      unless (defined $tn) {
3047                        !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3048                        ## Ignore the token
3049                        !!!next-token;
3050                        redo B;
3051                      }
3052                    
3053                    ## Close the cell
3054                    !!!back-token; # <?>
3055                    $token = {type => END_TAG_TOKEN, tag_name => $tn};
3056                    redo B;
3057                  } elsif ($self->{insertion_mode} == IN_CAPTION_IM) {
3058                    !!!parse-error (type => 'not closed:caption');
3059                    
3060                    ## As if </caption>
3061                    ## have a table element in table scope
3062                    my $i;
3063                    INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3064                      my $node = $self->{open_elements}->[$_];
3065                      if ($node->[1] eq 'caption') {
3066                        $i = $_;
3067                        last INSCOPE;
3068                      } elsif ({
3069                                table => 1, html => 1,
3070                               }->{$node->[1]}) {
3071                        last INSCOPE;
3072                      }
3073                    } # INSCOPE
3074                      unless (defined $i) {
3075                        !!!parse-error (type => 'unmatched end tag:caption');
3076                        ## Ignore the token
3077                        !!!next-token;
3078                        redo B;
3079                      }
3080                    
3081                    ## generate implied end tags
3082                    if ({
3083                         dd => 1, dt => 1, li => 1, p => 1,
3084                         td => 1, th => 1, tr => 1,
3085                         tbody => 1, tfoot=> 1, thead => 1,
3086                        }->{$self->{open_elements}->[-1]->[1]}) {
3087                      !!!back-token; # <?>
3088                      $token = {type => END_TAG_TOKEN, tag_name => 'caption'};
3089                      !!!back-token;
3090                      $token = {type => END_TAG_TOKEN,
3091                                tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
3092                      redo B;
3093                    }
3094    
3095                ## As if </caption>                  if ($self->{open_elements}->[-1]->[1] ne 'caption') {
3096                ## have a table element in table scope                    !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
               my $i;  
               INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
                 my $node = $self->{open_elements}->[$_];  
                 if ($node->[1] eq 'caption') {  
                   $i = $_;  
                   last INSCOPE;  
                 } elsif ({  
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
                   last INSCOPE;  
3097                  }                  }
3098                } # INSCOPE                  
3099                unless (defined $i) {                  splice @{$self->{open_elements}}, $i;
3100                  !!!parse-error (type => 'unmatched end tag:caption');                  
3101                    $clear_up_to_marker->();
3102                    
3103                    $self->{insertion_mode} = IN_TABLE_IM;
3104                    
3105                    ## reprocess
3106                    redo B;
3107                  } else {
3108                    #
3109                  }
3110                } else {
3111                  #
3112                }
3113              } elsif ($token->{type} == END_TAG_TOKEN) {
3114                if ($token->{tag_name} eq 'td' or $token->{tag_name} eq 'th') {
3115                  if ($self->{insertion_mode} == IN_CELL_IM) {
3116                    ## have an element in table scope
3117                    my $i;
3118                    INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3119                      my $node = $self->{open_elements}->[$_];
3120                      if ($node->[1] eq $token->{tag_name}) {
3121                        $i = $_;
3122                        last INSCOPE;
3123                      } elsif ({
3124                                table => 1, html => 1,
3125                               }->{$node->[1]}) {
3126                        last INSCOPE;
3127                      }
3128                    } # INSCOPE
3129                      unless (defined $i) {
3130                        !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3131                        ## Ignore the token
3132                        !!!next-token;
3133                        redo B;
3134                      }
3135                    
3136                    ## generate implied end tags
3137                    if ({
3138                         dd => 1, dt => 1, li => 1, p => 1,
3139                         td => ($token->{tag_name} eq 'th'),
3140                         th => ($token->{tag_name} eq 'td'),
3141                         tr => 1,
3142                         tbody => 1, tfoot=> 1, thead => 1,
3143                        }->{$self->{open_elements}->[-1]->[1]}) {
3144                      !!!back-token;
3145                      $token = {type => END_TAG_TOKEN,
3146                                tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
3147                      redo B;
3148                    }
3149                    
3150                    if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {
3151                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3152                    }
3153                    
3154                    splice @{$self->{open_elements}}, $i;
3155                    
3156                    $clear_up_to_marker->();
3157                    
3158                    $self->{insertion_mode} = IN_ROW_IM;
3159                    
3160                    !!!next-token;
3161                    redo B;
3162                  } elsif ($self->{insertion_mode} == IN_CAPTION_IM) {
3163                    !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3164                  ## Ignore the token                  ## Ignore the token
3165                  !!!next-token;                  !!!next-token;
3166                  redo B;                  redo B;
3167                  } else {
3168                    #
3169                }                }
3170                              } elsif ($token->{tag_name} eq 'caption') {
3171                ## generate implied end tags                if ($self->{insertion_mode} == IN_CAPTION_IM) {
3172                if ({                  ## have a table element in table scope
3173                     dd => 1, dt => 1, li => 1, p => 1,                  my $i;
3174                     td => 1, th => 1, tr => 1,                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3175                    }->{$self->{open_elements}->[-1]->[1]}) {                    my $node = $self->{open_elements}->[$_];
3176                  !!!back-token; # <?>                    if ($node->[1] eq $token->{tag_name}) {
3177                  $token = {type => 'end tag', tag_name => 'caption'};                      $i = $_;
3178                  !!!back-token;                      last INSCOPE;
3179                  $token = {type => 'end tag',                    } elsif ({
3180                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST                              table => 1, html => 1,
3181                               }->{$node->[1]}) {
3182                        last INSCOPE;
3183                      }
3184                    } # INSCOPE
3185                      unless (defined $i) {
3186                        !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3187                        ## Ignore the token
3188                        !!!next-token;
3189                        redo B;
3190                      }
3191                    
3192                    ## generate implied end tags
3193                    if ({
3194                         dd => 1, dt => 1, li => 1, p => 1,
3195                         td => 1, th => 1, tr => 1,
3196                         tbody => 1, tfoot=> 1, thead => 1,
3197                        }->{$self->{open_elements}->[-1]->[1]}) {
3198                      !!!back-token;
3199                      $token = {type => END_TAG_TOKEN,
3200                                tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
3201                      redo B;
3202                    }
3203                    
3204                    if ($self->{open_elements}->[-1]->[1] ne 'caption') {
3205                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3206                    }
3207                    
3208                    splice @{$self->{open_elements}}, $i;
3209                    
3210                    $clear_up_to_marker->();
3211                    
3212                    $self->{insertion_mode} = IN_TABLE_IM;
3213                    
3214                    !!!next-token;
3215                  redo B;                  redo B;
3216                  } elsif ($self->{insertion_mode} == IN_CELL_IM) {
3217                    !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3218                    ## Ignore the token
3219                    !!!next-token;
3220                    redo B;
3221                  } else {
3222                    #
3223                }                }
3224                } elsif ({
3225                if ($self->{open_elements}->[-1]->[1] ne 'caption') {                        table => 1, tbody => 1, tfoot => 1,
3226                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                        thead => 1, tr => 1,
3227                }                       }->{$token->{tag_name}} and
3228                         $self->{insertion_mode} == IN_CELL_IM) {
3229                splice @{$self->{open_elements}}, $i;                ## have an element in table scope
   
               $clear_up_to_marker->();  
   
               $self->{insertion_mode} = 'in table';  
   
               ## reprocess  
               redo B;  
             } else {  
               #  
             }  
           } elsif ($token->{type} eq 'end tag') {  
             if ($token->{tag_name} eq 'caption') {  
               ## have a table element in table scope  
3230                my $i;                my $i;
3231                  my $tn;
3232                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3233                  my $node = $self->{open_elements}->[$_];                  my $node = $self->{open_elements}->[$_];
3234                  if ($node->[1] eq $token->{tag_name}) {                  if ($node->[1] eq $token->{tag_name}) {
3235                    $i = $_;                    $i = $_;
3236                    last INSCOPE;                    last INSCOPE;
3237                    } elsif ($node->[1] eq 'td' or $node->[1] eq 'th') {
3238                      $tn = $node->[1];
3239                      ## NOTE: There is exactly one |td| or |th| element
3240                      ## in scope in the stack of open elements by definition.
3241                  } elsif ({                  } elsif ({
3242                            table => 1, html => 1,                            table => 1, html => 1,
3243                           }->{$node->[1]}) {                           }->{$node->[1]}) {
# Line 3617  sub _tree_construction_main ($) { Line 3250  sub _tree_construction_main ($) {
3250                  !!!next-token;                  !!!next-token;
3251                  redo B;                  redo B;
3252                }                }
                 
               ## generate implied end tags  
               if ({  
                    dd => 1, dt => 1, li => 1, p => 1,  
                    td => 1, th => 1, tr => 1,  
                   }->{$self->{open_elements}->[-1]->[1]}) {  
                 !!!back-token;  
                 $token = {type => 'end tag',  
                           tag_name => $self->{open_elements}->[-1]->[1]}; # MUST  
                 redo B;  
               }  
3253    
3254                if ($self->{open_elements}->[-1]->[1] ne 'caption') {                ## Close the cell
3255                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                !!!back-token; # </?>
3256                }                $token = {type => END_TAG_TOKEN, tag_name => $tn};
   
               splice @{$self->{open_elements}}, $i;  
   
               $clear_up_to_marker->();  
   
               $self->{insertion_mode} = 'in table';  
   
               !!!next-token;  
3257                redo B;                redo B;
3258              } elsif ($token->{tag_name} eq 'table') {              } elsif ($token->{tag_name} eq 'table' and
3259                         $self->{insertion_mode} == IN_CAPTION_IM) {
3260                !!!parse-error (type => 'not closed:caption');                !!!parse-error (type => 'not closed:caption');
3261    
3262                ## As if </caption>                ## As if </caption>
# Line 3669  sub _tree_construction_main ($) { Line 3284  sub _tree_construction_main ($) {
3284                if ({                if ({
3285                     dd => 1, dt => 1, li => 1, p => 1,                     dd => 1, dt => 1, li => 1, p => 1,
3286                     td => 1, th => 1, tr => 1,                     td => 1, th => 1, tr => 1,
3287                       tbody => 1, tfoot=> 1, thead => 1,
3288                    }->{$self->{open_elements}->[-1]->[1]}) {                    }->{$self->{open_elements}->[-1]->[1]}) {
3289                  !!!back-token; # </table>                  !!!back-token; # </table>
3290                  $token = {type => 'end tag', tag_name => 'caption'};                  $token = {type => END_TAG_TOKEN, tag_name => 'caption'};
3291                  !!!back-token;                  !!!back-token;
3292                  $token = {type => 'end tag',                  $token = {type => END_TAG_TOKEN,
3293                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
3294                  redo B;                  redo B;
3295                }                }
# Line 3686  sub _tree_construction_main ($) { Line 3302  sub _tree_construction_main ($) {
3302    
3303                $clear_up_to_marker->();                $clear_up_to_marker->();
3304    
3305                $self->{insertion_mode} = 'in table';                $self->{insertion_mode} = IN_TABLE_IM;
3306    
3307                ## reprocess                ## reprocess
3308                redo B;                redo B;
3309              } elsif ({              } elsif ({
3310                        body => 1, col => 1, colgroup => 1,                        body => 1, col => 1, colgroup => 1, html => 1,
                       html => 1, tbody => 1, td => 1, tfoot => 1,  
                       th => 1, thead => 1, tr => 1,  
3311                       }->{$token->{tag_name}}) {                       }->{$token->{tag_name}}) {
3312                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                if ($self->{insertion_mode} & BODY_TABLE_IMS) {
3313                ## Ignore the token                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
               redo B;  
             } else {  
               #  
             }  
           } else {  
             #  
           }  
                 
           $in_body->($insert_to_current);  
           redo B;  
         } elsif ($self->{insertion_mode} eq 'in column group') {  
           if ($token->{type} eq 'character') {  
             if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {  
               $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);  
               unless (length $token->{data}) {  
                 !!!next-token;  
                 redo B;  
               }  
             }  
               
             #  
           } elsif ($token->{type} eq 'comment') {  
             my $comment = $self->{document}->create_comment ($token->{data});  
             $self->{open_elements}->[-1]->[0]->append_child ($comment);  
             !!!next-token;  
             redo B;  
           } elsif ($token->{type} eq 'start tag') {  
             if ($token->{tag_name} eq 'col') {  
               !!!insert-element ($token->{tag_name}, $token->{attributes});  
               pop @{$self->{open_elements}};  
               !!!next-token;  
               redo B;  
             } else {  
               #  
             }  
           } elsif ($token->{type} eq 'end tag') {  
             if ($token->{tag_name} eq 'colgroup') {  
               if ($self->{open_elements}->[-1]->[1] eq 'html') {  
                 !!!parse-error (type => 'unmatched end tag:colgroup');  
3314                  ## Ignore the token                  ## Ignore the token
3315                  !!!next-token;                  !!!next-token;
3316                  redo B;                  redo B;
3317                } else {                } else {
3318                  pop @{$self->{open_elements}}; # colgroup                  #
                 $self->{insertion_mode} = 'in table';  
                 !!!next-token;  
                 redo B;              
3319                }                }
3320              } elsif ($token->{tag_name} eq 'col') {              } elsif ({
3321                !!!parse-error (type => 'unmatched end tag:col');                        tbody => 1, tfoot => 1,
3322                          thead => 1, tr => 1,
3323                         }->{$token->{tag_name}} and
3324                         $self->{insertion_mode} == IN_CAPTION_IM) {
3325                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3326                ## Ignore the token                ## Ignore the token
3327                !!!next-token;                !!!next-token;
3328                redo B;                redo B;
3329              } else {              } else {
3330                #                #
3331              }              }
3332            } else {        } else {
3333              #          die "$0: $token->{type}: Unknown token type";
3334            }        }
3335    
3336            ## As if </colgroup>        $insert = $insert_to_current;
3337            if ($self->{open_elements}->[-1]->[1] eq 'html') {        #
3338              !!!parse-error (type => 'unmatched end tag:colgroup');      } elsif ($self->{insertion_mode} & TABLE_IMS) {
3339              ## Ignore the token            if ($token->{type} == CHARACTER_TOKEN) {
3340              !!!next-token;              ## NOTE: There are "character in table" code clones.
             redo B;  
           } else {  
             pop @{$self->{open_elements}}; # colgroup  
             $self->{insertion_mode} = 'in table';  
             ## reprocess  
             redo B;  
           }  
         } elsif ($self->{insertion_mode} eq 'in table body') {  
           if ($token->{type} eq 'character') {  
             ## NOTE: This is a "character in table" code clone.  
3341              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
3342                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
3343                                
# Line 3788  sub _tree_construction_main ($) { Line 3354  sub _tree_construction_main ($) {
3354              ## into the current node" while characters might not be              ## into the current node" while characters might not be
3355              ## result in a new Text node.              ## result in a new Text node.
3356              $reconstruct_active_formatting_elements->($insert_to_foster);              $reconstruct_active_formatting_elements->($insert_to_foster);
3357                
3358              if ({              if ({
3359                   table => 1, tbody => 1, tfoot => 1,                   table => 1, tbody => 1, tfoot => 1,
3360                   thead => 1, tr => 1,                   thead => 1, tr => 1,
# Line 3828  sub _tree_construction_main ($) { Line 3394  sub _tree_construction_main ($) {
3394                            
3395              !!!next-token;              !!!next-token;
3396              redo B;              redo B;
3397            } elsif ($token->{type} eq 'comment') {            } elsif ($token->{type} == START_TAG_TOKEN) {
             ## Copied from 'in table'  
             my $comment = $self->{document}->create_comment ($token->{data});  
             $self->{open_elements}->[-1]->[0]->append_child ($comment);  
             !!!next-token;  
             redo B;  
           } elsif ($token->{type} eq 'start tag') {  
3398              if ({              if ({
3399                   tr => 1,                   tr => ($self->{insertion_mode} != IN_ROW_IM),
3400                   th => 1, td => 1,                   th => 1, td => 1,
3401                  }->{$token->{tag_name}}) {                  }->{$token->{tag_name}}) {
3402                unless ($token->{tag_name} eq 'tr') {                if ($self->{insertion_mode} == IN_TABLE_IM) {
3403                  !!!parse-error (type => 'missing start tag:tr');                  ## Clear back to table context
3404                    while ($self->{open_elements}->[-1]->[1] ne 'table' and
3405                           $self->{open_elements}->[-1]->[1] ne 'html') {
3406                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3407                      pop @{$self->{open_elements}};
3408                    }
3409                    
3410                    !!!insert-element ('tbody');
3411                    $self->{insertion_mode} = IN_TABLE_BODY_IM;
3412                    ## reprocess in the "in table body" insertion mode...
3413                }                }
3414    
3415                ## Clear back to table body context                if ($self->{insertion_mode} == IN_TABLE_BODY_IM) {
3416                    unless ($token->{tag_name} eq 'tr') {
3417                      !!!parse-error (type => 'missing start tag:tr');
3418                    }
3419                    
3420                    ## Clear back to table body context
3421                    while (not {
3422                      tbody => 1, tfoot => 1, thead => 1, html => 1,
3423                    }->{$self->{open_elements}->[-1]->[1]}) {
3424                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3425                      pop @{$self->{open_elements}};
3426                    }
3427                    
3428                    $self->{insertion_mode} = IN_ROW_IM;
3429                    if ($token->{tag_name} eq 'tr') {
3430                      !!!insert-element ($token->{tag_name}, $token->{attributes});
3431                      !!!next-token;
3432                      redo B;
3433                    } else {
3434                      !!!insert-element ('tr');
3435                      ## reprocess in the "in row" insertion mode
3436                    }
3437                  }
3438    
3439                  ## Clear back to table row context
3440                while (not {                while (not {
3441                  tbody => 1, tfoot => 1, thead => 1, html => 1,                  tr => 1, html => 1,
3442                }->{$self->{open_elements}->[-1]->[1]}) {                }->{$self->{open_elements}->[-1]->[1]}) {
3443                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3444                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
3445                }                }
3446                                
3447                $self->{insertion_mode} = 'in row';                !!!insert-element ($token->{tag_name}, $token->{attributes});
3448                if ($token->{tag_name} eq 'tr') {                $self->{insertion_mode} = IN_CELL_IM;
3449                  !!!insert-element ($token->{tag_name}, $token->{attributes});  
3450                  !!!next-token;                push @$active_formatting_elements, ['#marker', ''];
3451                } else {                
3452                  !!!insert-element ('tr');                !!!next-token;
                 ## reprocess  
               }  
3453                redo B;                redo B;
3454              } elsif ({              } elsif ({
3455                        caption => 1, col => 1, colgroup => 1,                        caption => 1, col => 1, colgroup => 1,
3456                        tbody => 1, tfoot => 1, thead => 1,                        tbody => 1, tfoot => 1, thead => 1,
3457                          tr => 1, # $self->{insertion_mode} == IN_ROW_IM
3458                       }->{$token->{tag_name}}) {                       }->{$token->{tag_name}}) {
3459                ## have an element in table scope                if ($self->{insertion_mode} == IN_ROW_IM) {
3460                my $i;                  ## As if </tr>
3461                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                  ## have an element in table scope
3462                  my $node = $self->{open_elements}->[$_];                  my $i;
3463                  if ({                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3464                       tbody => 1, thead => 1, tfoot => 1,                    my $node = $self->{open_elements}->[$_];
3465                      }->{$node->[1]}) {                    if ($node->[1] eq 'tr') {
3466                    $i = $_;                      $i = $_;
3467                    last INSCOPE;                      last INSCOPE;
3468                  } elsif ({                    } elsif ({
3469                            table => 1, html => 1,                              table => 1, html => 1,
3470                           }->{$node->[1]}) {                             }->{$node->[1]}) {
3471                    last INSCOPE;                      last INSCOPE;
3472                      }
3473                    } # INSCOPE
3474                    unless (defined $i) {
3475                      !!!parse-error (type => 'unmacthed end tag:'.$token->{tag_name});
3476                      ## Ignore the token
3477                      !!!next-token;
3478                      redo B;
3479                    }
3480                    
3481                    ## Clear back to table row context
3482                    while (not {
3483                      tr => 1, html => 1,
3484                    }->{$self->{open_elements}->[-1]->[1]}) {
3485                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3486                      pop @{$self->{open_elements}};
3487                    }
3488                    
3489                    pop @{$self->{open_elements}}; # tr
3490                    $self->{insertion_mode} = IN_TABLE_BODY_IM;
3491                    if ($token->{tag_name} eq 'tr') {
3492                      ## reprocess
3493                      redo B;
3494                    } else {
3495                      ## reprocess in the "in table body" insertion mode...
3496                  }                  }
               } # INSCOPE  
               unless (defined $i) {  
                 !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
                 ## Ignore the token  
                 !!!next-token;  
                 redo B;  
3497                }                }
3498    
3499                ## Clear back to table body context                if ($self->{insertion_mode} == IN_TABLE_BODY_IM) {
3500                while (not {                  ## have an element in table scope
3501                  tbody => 1, tfoot => 1, thead => 1, html => 1,                  my $i;
3502                }->{$self->{open_elements}->[-1]->[1]}) {                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3503                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                    my $node = $self->{open_elements}->[$_];
3504                      if ({
3505                           tbody => 1, thead => 1, tfoot => 1,
3506                          }->{$node->[1]}) {
3507                        $i = $_;
3508                        last INSCOPE;
3509                      } elsif ({
3510                                table => 1, html => 1,
3511                               }->{$node->[1]}) {
3512                        last INSCOPE;
3513                      }
3514                    } # INSCOPE
3515                    unless (defined $i) {
3516                      !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3517                      ## Ignore the token
3518                      !!!next-token;
3519                      redo B;
3520                    }
3521    
3522                    ## Clear back to table body context
3523                    while (not {
3524                      tbody => 1, tfoot => 1, thead => 1, html => 1,
3525                    }->{$self->{open_elements}->[-1]->[1]}) {
3526                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3527                      pop @{$self->{open_elements}};
3528                    }
3529                    
3530                    ## As if <{current node}>
3531                    ## have an element in table scope
3532                    ## true by definition
3533                    
3534                    ## Clear back to table body context
3535                    ## nop by definition
3536                    
3537                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
3538                    $self->{insertion_mode} = IN_TABLE_IM;
3539                    ## reprocess in "in table" insertion mode...
3540                }                }
3541    
3542                ## As if <{current node}>                if ($token->{tag_name} eq 'col') {
3543                ## have an element in table scope                  ## Clear back to table context
3544                ## true by definition                  while ($self->{open_elements}->[-1]->[1] ne 'table' and
3545                           $self->{open_elements}->[-1]->[1] ne 'html') {
3546                ## Clear back to table body context                    !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3547                ## nop by definition                    pop @{$self->{open_elements}};
3548                    }
3549                pop @{$self->{open_elements}};                  
3550                $self->{insertion_mode} = 'in table';                  !!!insert-element ('colgroup');
3551                ## reprocess                  $self->{insertion_mode} = IN_COLUMN_GROUP_IM;
3552                redo B;                  ## reprocess
3553                    redo B;
3554                  } elsif ({
3555                            caption => 1,
3556                            colgroup => 1,
3557                            tbody => 1, tfoot => 1, thead => 1,
3558                           }->{$token->{tag_name}}) {
3559                    ## Clear back to table context
3560                    while ($self->{open_elements}->[-1]->[1] ne 'table' and
3561                           $self->{open_elements}->[-1]->[1] ne 'html') {
3562                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3563                      pop @{$self->{open_elements}};
3564                    }
3565                    
3566                    push @$active_formatting_elements, ['#marker', '']
3567                        if $token->{tag_name} eq 'caption';
3568                    
3569                    !!!insert-element ($token->{tag_name}, $token->{attributes});
3570                    $self->{insertion_mode} = {
3571                                               caption => IN_CAPTION_IM,
3572                                               colgroup => IN_COLUMN_GROUP_IM,
3573                                               tbody => IN_TABLE_BODY_IM,
3574                                               tfoot => IN_TABLE_BODY_IM,
3575                                               thead => IN_TABLE_BODY_IM,
3576                                              }->{$token->{tag_name}};
3577                    !!!next-token;
3578                    redo B;
3579                  } else {
3580                    die "$0: in table: <>: $token->{tag_name}";
3581                  }
3582              } elsif ($token->{tag_name} eq 'table') {              } elsif ($token->{tag_name} eq 'table') {
3583                ## NOTE: This is a code clone of "table in table"                ## NOTE: There are code clones for this "table in table"
3584                !!!parse-error (type => 'not closed:table');                !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3585    
3586                ## As if </table>                ## As if </table>
3587                ## have a table element in table scope                ## have a table element in table scope
# Line 3934  sub _tree_construction_main ($) { Line 3608  sub _tree_construction_main ($) {
3608                if ({                if ({
3609                     dd => 1, dt => 1, li => 1, p => 1,                     dd => 1, dt => 1, li => 1, p => 1,
3610                     td => 1, th => 1, tr => 1,                     td => 1, th => 1, tr => 1,
3611                       tbody => 1, tfoot=> 1, thead => 1,
3612                    }->{$self->{open_elements}->[-1]->[1]}) {                    }->{$self->{open_elements}->[-1]->[1]}) {
3613                  !!!back-token; # <table>                  !!!back-token; # <table>
3614                  $token = {type => 'end tag', tag_name => 'table'};                  $token = {type => END_TAG_TOKEN, tag_name => 'table'};
3615                  !!!back-token;                  !!!back-token;
3616                  $token = {type => 'end tag',                  $token = {type => END_TAG_TOKEN,
3617                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
3618                  redo B;                  redo B;
3619                }                }
# Line 3949  sub _tree_construction_main ($) { Line 3624  sub _tree_construction_main ($) {
3624    
3625                splice @{$self->{open_elements}}, $i;                splice @{$self->{open_elements}}, $i;
3626    
3627                $self->_reset_insertion_mode;                $self->_reset_insertion_mode;
3628    
3629                ## reprocess                ## reprocess
3630                redo B;                redo B;
3631              } else {              } else {
3632                #                #
3633              }              }
3634            } elsif ($token->{type} eq 'end tag') {            } elsif ($token->{type} == END_TAG_TOKEN) {
3635              if ({              if ($token->{tag_name} eq 'tr' and
3636                   tbody => 1, tfoot => 1, thead => 1,                  $self->{insertion_mode} == IN_ROW_IM) {
                 }->{$token->{tag_name}}) {  
3637                ## have an element in table scope                ## have an element in table scope
3638                my $i;                my $i;
3639                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
# Line 3980  sub _tree_construction_main ($) { Line 3654  sub _tree_construction_main ($) {
3654                  redo B;                  redo B;
3655                }                }
3656    
3657                ## Clear back to table body context                ## Clear back to table row context
3658                while (not {                while (not {
3659                  tbody => 1, tfoot => 1, thead => 1, html => 1,                  tr => 1, html => 1,
3660                }->{$self->{open_elements}->[-1]->[1]}) {                }->{$self->{open_elements}->[-1]->[1]}) {
3661                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3662                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
3663                }                }
3664    
3665                pop @{$self->{open_elements}};                pop @{$self->{open_elements}}; # tr
3666                $self->{insertion_mode} = 'in table';                $self->{insertion_mode} = IN_TABLE_BODY_IM;
3667                !!!next-token;                !!!next-token;
3668                redo B;                redo B;
3669              } elsif ($token->{tag_name} eq 'table') {              } elsif ($token->{tag_name} eq 'table') {
3670                ## have an element in table scope                if ($self->{insertion_mode} == IN_ROW_IM) {
3671                my $i;                  ## As if </tr>
3672                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                  ## have an element in table scope
3673                  my $node = $self->{open_elements}->[$_];                  my $i;
3674                  if ({                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3675                       tbody => 1, thead => 1, tfoot => 1,                    my $node = $self->{open_elements}->[$_];
3676                      }->{$node->[1]}) {                    if ($node->[1] eq 'tr') {
3677                    $i = $_;                      $i = $_;
3678                    last INSCOPE;                      last INSCOPE;
3679                  } elsif ({                    } elsif ({
3680                            table => 1, html => 1,                              table => 1, html => 1,
3681                           }->{$node->[1]}) {                             }->{$node->[1]}) {
3682                    last INSCOPE;                      last INSCOPE;
3683                      }
3684                    } # INSCOPE
3685                    unless (defined $i) {
3686                      !!!parse-error (type => 'unmatched end tag:'.$token->{type});
3687                      ## Ignore the token
3688                      !!!next-token;
3689                      redo B;
3690                  }                  }
3691                } # INSCOPE                  
3692                unless (defined $i) {                  ## Clear back to table row context
3693                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                  while (not {
3694                  ## Ignore the token                    tr => 1, html => 1,
                 !!!next-token;  
                 redo B;  
               }  
   
               ## Clear back to table body context  
               while (not {  
                 tbody => 1, tfoot => 1, thead => 1, html => 1,  
               }->{$self->{open_elements}->[-1]->[1]}) {  
                 !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
                 pop @{$self->{open_elements}};  
               }  
   
               ## As if <{current node}>  
               ## have an element in table scope  
               ## true by definition  
   
               ## Clear back to table body context  
               ## nop by definition  
   
               pop @{$self->{open_elements}};  
               $self->{insertion_mode} = 'in table';  
               ## reprocess  
               redo B;  
             } elsif ({  
                       body => 1, caption => 1, col => 1, colgroup => 1,  
                       html => 1, td => 1, th => 1, tr => 1,  
                      }->{$token->{tag_name}}) {  
               !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
               ## Ignore the token  
               !!!next-token;  
               redo B;  
             } else {  
               #  
             }  
           } else {  
             #  
           }  
             
           ## As if in table  
           !!!parse-error (type => 'in table:'.$token->{tag_name});  
           $in_body->($insert_to_foster);  
           redo B;  
         } elsif ($self->{insertion_mode} eq 'in row') {  
           if ($token->{type} eq 'character') {  
             ## NOTE: This is a "character in table" code clone.  
             if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {  
               $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);  
                 
               unless (length $token->{data}) {  
                 !!!next-token;  
                 redo B;  
               }  
             }  
   
             !!!parse-error (type => 'in table:#character');  
   
             ## As if in body, but insert into foster parent element  
             ## ISSUE: Spec says that "whenever a node would be inserted  
             ## into the current node" while characters might not be  
             ## result in a new Text node.  
             $reconstruct_active_formatting_elements->($insert_to_foster);  
               
             if ({  
                  table => 1, tbody => 1, tfoot => 1,  
                  thead => 1, tr => 1,  
3695                  }->{$self->{open_elements}->[-1]->[1]}) {                  }->{$self->{open_elements}->[-1]->[1]}) {
3696                # MUST                    !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3697                my $foster_parent_element;                    pop @{$self->{open_elements}};
3698                my $next_sibling;                  }
3699                my $prev_sibling;                  
3700                OE: for (reverse 0..$#{$self->{open_elements}}) {                  pop @{$self->{open_elements}}; # tr
3701                  if ($self->{open_elements}->[$_]->[1] eq 'table') {                  $self->{insertion_mode} = IN_TABLE_BODY_IM;
3702                    my $parent = $self->{open_elements}->[$_]->[0]->parent_node;                  ## reprocess in the "in table body" insertion mode...
3703                    if (defined $parent and $parent->node_type == 1) {                }
3704                      $foster_parent_element = $parent;  
3705                      $next_sibling = $self->{open_elements}->[$_]->[0];                if ($self->{insertion_mode} == IN_TABLE_BODY_IM) {
3706                      $prev_sibling = $next_sibling->previous_sibling;                  ## have an element in table scope
3707                    } else {                  my $i;
3708                      $foster_parent_element = $self->{open_elements}->[$_ - 1]->[0];                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3709                      $prev_sibling = $foster_parent_element->last_child;                    my $node = $self->{open_elements}->[$_];
3710                      if ({
3711                           tbody => 1, thead => 1, tfoot => 1,
3712                          }->{$node->[1]}) {
3713                        $i = $_;
3714                        last INSCOPE;
3715                      } elsif ({
3716                                table => 1, html => 1,
3717                               }->{$node->[1]}) {
3718                        last INSCOPE;
3719                    }                    }
3720                    last OE;                  } # INSCOPE
3721                    unless (defined $i) {
3722                      !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3723                      ## Ignore the token
3724                      !!!next-token;
3725                      redo B;
3726                  }                  }
3727                } # OE                  
3728                $foster_parent_element = $self->{open_elements}->[0]->[0] and                  ## Clear back to table body context
3729                $prev_sibling = $foster_parent_element->last_child                  while (not {
3730                  unless defined $foster_parent_element;                    tbody => 1, tfoot => 1, thead => 1, html => 1,
3731                if (defined $prev_sibling and                  }->{$self->{open_elements}->[-1]->[1]}) {
3732                    $prev_sibling->node_type == 3) {                    !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3733                  $prev_sibling->manakai_append_text ($token->{data});                    pop @{$self->{open_elements}};
               } else {  
                 $foster_parent_element->insert_before  
                   ($self->{document}->create_text_node ($token->{data}),  
                    $next_sibling);  
               }  
             } else {  
               $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});  
             }  
               
             !!!next-token;  
             redo B;  
           } elsif ($token->{type} eq 'comment') {  
             ## Copied from 'in table'  
             my $comment = $self->{document}->create_comment ($token->{data});  
             $self->{open_elements}->[-1]->[0]->append_child ($comment);  
             !!!next-token;  
             redo B;  
           } elsif ($token->{type} eq 'start tag') {  
             if ($token->{tag_name} eq 'th' or  
                 $token->{tag_name} eq 'td') {  
               ## Clear back to table row context  
               while (not {  
                 tr => 1, html => 1,  
               }->{$self->{open_elements}->[-1]->[1]}) {  
                 !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
                 pop @{$self->{open_elements}};  
               }  
                 
               !!!insert-element ($token->{tag_name}, $token->{attributes});  
               $self->{insertion_mode} = 'in cell';  
   
               push @$active_formatting_elements, ['#marker', ''];  
                 
               !!!next-token;  
               redo B;  
             } elsif ({  
                       caption => 1, col => 1, colgroup => 1,  
                       tbody => 1, tfoot => 1, thead => 1, tr => 1,  
                      }->{$token->{tag_name}}) {  
               ## As if </tr>  
               ## have an element in table scope  
               my $i;  
               INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
                 my $node = $self->{open_elements}->[$_];  
                 if ($node->[1] eq 'tr') {  
                   $i = $_;  
                   last INSCOPE;  
                 } elsif ({  
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
                   last INSCOPE;  
3734                  }                  }
3735                } # INSCOPE                  
3736                unless (defined $i) {                  ## As if <{current node}>
3737                  !!!parse-error (type => 'unmacthed end tag:'.$token->{tag_name});                  ## have an element in table scope
3738                  ## Ignore the token                  ## true by definition
3739                  !!!next-token;                  
3740                  redo B;                  ## Clear back to table body context
3741                }                  ## nop by definition
3742                    
               ## Clear back to table row context  
               while (not {  
                 tr => 1, html => 1,  
               }->{$self->{open_elements}->[-1]->[1]}) {  
                 !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
3743                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
3744                    $self->{insertion_mode} = IN_TABLE_IM;
3745                    ## reprocess in the "in table" insertion mode...
3746                }                }
3747    
               pop @{$self->{open_elements}}; # tr  
               $self->{insertion_mode} = 'in table body';  
               ## reprocess  
               redo B;  
             } elsif ($token->{tag_name} eq 'table') {  
               ## NOTE: This is a code clone of "table in table"  
               !!!parse-error (type => 'not closed:table');  
   
               ## As if </table>  
3748                ## have a table element in table scope                ## have a table element in table scope
3749                my $i;                my $i;
3750                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3751                  my $node = $self->{open_elements}->[$_];                  my $node = $self->{open_elements}->[$_];
3752                  if ($node->[1] eq 'table') {                  if ($node->[1] eq $token->{tag_name}) {
3753                    $i = $_;                    $i = $_;
3754                    last INSCOPE;                    last INSCOPE;
3755                  } elsif ({                  } elsif ({
# Line 4192  sub _tree_construction_main ($) { Line 3759  sub _tree_construction_main ($) {
3759                  }                  }
3760                } # INSCOPE                } # INSCOPE
3761                unless (defined $i) {                unless (defined $i) {
3762                  !!!parse-error (type => 'unmatched end tag:table');                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3763                  ## Ignore tokens </table><table>                  ## Ignore the token
3764                  !!!next-token;                  !!!next-token;
3765                  redo B;                  redo B;
3766                }                }
3767                  
3768                ## generate implied end tags                ## generate implied end tags
3769                if ({                if ({
3770                     dd => 1, dt => 1, li => 1, p => 1,                     dd => 1, dt => 1, li => 1, p => 1,
3771                     td => 1, th => 1, tr => 1,                     td => 1, th => 1, tr => 1,
3772                       tbody => 1, tfoot=> 1, thead => 1,
3773                    }->{$self->{open_elements}->[-1]->[1]}) {                    }->{$self->{open_elements}->[-1]->[1]}) {
                 !!!back-token; # <table>  
                 $token = {type => 'end tag', tag_name => 'table'};  
3774                  !!!back-token;                  !!!back-token;
3775                  $token = {type => 'end tag',                  $token = {type => END_TAG_TOKEN,
3776                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
3777                  redo B;                  redo B;
3778                }                }
3779                  
3780                if ($self->{open_elements}->[-1]->[1] ne 'table') {                if ($self->{open_elements}->[-1]->[1] ne 'table') {
3781                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3782                }                }
3783                    
3784                splice @{$self->{open_elements}}, $i;                splice @{$self->{open_elements}}, $i;
3785                  
3786                $self->_reset_insertion_mode;                $self->_reset_insertion_mode;
3787                  
               ## reprocess  
               redo B;  
             } else {  
               #  
             }  
           } elsif ($token->{type} eq 'end tag') {  
             if ($token->{tag_name} eq 'tr') {  
               ## have an element in table scope  
               my $i;  
               INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
                 my $node = $self->{open_elements}->[$_];  
                 if ($node->[1] eq $token->{tag_name}) {  
                   $i = $_;  
                   last INSCOPE;  
                 } elsif ({  
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
                   last INSCOPE;  
                 }  
               } # INSCOPE  
               unless (defined $i) {  
                 !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
                 ## Ignore the token  
                 !!!next-token;  
                 redo B;  
               }  
   
               ## Clear back to table row context  
               while (not {  
                 tr => 1, html => 1,  
               }->{$self->{open_elements}->[-1]->[1]}) {  
                 !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
                 pop @{$self->{open_elements}};  
               }  
   
               pop @{$self->{open_elements}}; # tr  
               $self->{insertion_mode} = 'in table body';  
3788                !!!next-token;                !!!next-token;
3789                redo B;                redo B;
             } elsif ($token->{tag_name} eq 'table') {  
               ## As if </tr>  
               ## have an element in table scope  
               my $i;  
               INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
                 my $node = $self->{open_elements}->[$_];  
                 if ($node->[1] eq 'tr') {  
                   $i = $_;  
                   last INSCOPE;  
                 } elsif ({  
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
                   last INSCOPE;  
                 }  
               } # INSCOPE  
               unless (defined $i) {  
                 !!!parse-error (type => 'unmatched end tag:'.$token->{type});  
                 ## Ignore the token  
                 !!!next-token;  
                 redo B;  
               }  
   
               ## Clear back to table row context  
               while (not {  
                 tr => 1, html => 1,  
               }->{$self->{open_elements}->[-1]->[1]}) {  
                 !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
                 pop @{$self->{open_elements}};  
               }  
   
               pop @{$self->{open_elements}}; # tr  
               $self->{insertion_mode} = 'in table body';  
               ## reprocess  
               redo B;  
3790              } elsif ({              } elsif ({
3791                        tbody => 1, tfoot => 1, thead => 1,                        tbody => 1, tfoot => 1, thead => 1,
3792                       }->{$token->{tag_name}}) {                       }->{$token->{tag_name}} and
3793                ## have an element in table scope                       $self->{insertion_mode} & ROW_IMS) {
3794                my $i;                if ($self->{insertion_mode} == IN_ROW_IM) {
3795                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                  ## have an element in table scope
3796                  my $node = $self->{open_elements}->[$_];                  my $i;
3797                  if ($node->[1] eq $token->{tag_name}) {                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3798                    $i = $_;                    my $node = $self->{open_elements}->[$_];
3799                    last INSCOPE;                    if ($node->[1] eq $token->{tag_name}) {
3800                  } elsif ({                      $i = $_;
3801                            table => 1, html => 1,                      last INSCOPE;
3802                           }->{$node->[1]}) {                    } elsif ({
3803                    last INSCOPE;                              table => 1, html => 1,
3804                               }->{$node->[1]}) {
3805                        last INSCOPE;
3806                      }
3807                    } # INSCOPE
3808                      unless (defined $i) {
3809                        !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3810                        ## Ignore the token
3811                        !!!next-token;
3812                        redo B;
3813                      }
3814                    
3815                    ## As if </tr>
3816                    ## have an element in table scope
3817                    my $i;
3818                    INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3819                      my $node = $self->{open_elements}->[$_];
3820                      if ($node->[1] eq 'tr') {
3821                        $i = $_;
3822                        last INSCOPE;
3823                      } elsif ({
3824                                table => 1, html => 1,
3825                               }->{$node->[1]}) {
3826                        last INSCOPE;
3827                      }
3828                    } # INSCOPE
3829                      unless (defined $i) {
3830                        !!!parse-error (type => 'unmatched end tag:tr');
3831                        ## Ignore the token
3832                        !!!next-token;
3833                        redo B;
3834                      }
3835                    
3836                    ## Clear back to table row context
3837                    while (not {
3838                      tr => 1, html => 1,
3839                    }->{$self->{open_elements}->[-1]->[1]}) {
3840                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3841                      pop @{$self->{open_elements}};
3842                  }                  }
3843                } # INSCOPE                  
3844                unless (defined $i) {                  pop @{$self->{open_elements}}; # tr
3845                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                  $self->{insertion_mode} = IN_TABLE_BODY_IM;
3846                  ## Ignore the token                  ## reprocess in the "in table body" insertion mode...
                 !!!next-token;  
                 redo B;  
3847                }                }
3848    
               ## As if </tr>  
3849                ## have an element in table scope                ## have an element in table scope
3850                my $i;                my $i;
3851                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3852                  my $node = $self->{open_elements}->[$_];                  my $node = $self->{open_elements}->[$_];
3853                  if ($node->[1] eq 'tr') {                  if ($node->[1] eq $token->{tag_name}) {
3854                    $i = $_;                    $i = $_;
3855                    last INSCOPE;                    last INSCOPE;
3856                  } elsif ({                  } elsif ({
# Line 4330  sub _tree_construction_main ($) { Line 3860  sub _tree_construction_main ($) {
3860                  }                  }
3861                } # INSCOPE                } # INSCOPE
3862                unless (defined $i) {                unless (defined $i) {
3863                  !!!parse-error (type => 'unmatched end tag:tr');                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3864                  ## Ignore the token                  ## Ignore the token
3865                  !!!next-token;                  !!!next-token;
3866                  redo B;                  redo B;
3867                }                }
3868    
3869                ## Clear back to table row context                ## Clear back to table body context
3870                while (not {                while (not {
3871                  tr => 1, html => 1,                  tbody => 1, tfoot => 1, thead => 1, html => 1,
3872                }->{$self->{open_elements}->[-1]->[1]}) {                }->{$self->{open_elements}->[-1]->[1]}) {
3873                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3874                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
3875                }                }
3876    
3877                pop @{$self->{open_elements}}; # tr                pop @{$self->{open_elements}};
3878                $self->{insertion_mode} = 'in table body';                $self->{insertion_mode} = IN_TABLE_IM;
3879                ## reprocess                !!!next-token;
3880                redo B;                redo B;
3881              } elsif ({              } elsif ({
3882                        body => 1, caption => 1, col => 1,                        body => 1, caption => 1, col => 1, colgroup => 1,
3883                        colgroup => 1, html => 1, td => 1, th => 1,                        html => 1, td => 1, th => 1,
3884                          tr => 1, # $self->{insertion_mode} == IN_ROW_IM
3885                          tbody => 1, tfoot => 1, thead => 1, # $self->{insertion_mode} == IN_TABLE_IM
3886                       }->{$token->{tag_name}}) {                       }->{$token->{tag_name}}) {
3887                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3888                ## Ignore the token                ## Ignore the token
# Line 4360  sub _tree_construction_main ($) { Line 3892  sub _tree_construction_main ($) {
3892                #                #
3893              }              }
3894            } else {            } else {
3895              #              die "$0: $token->{type}: Unknown token type";
3896            }            }
3897    
3898            ## As if in table        !!!parse-error (type => 'in table:'.$token->{tag_name});
           !!!parse-error (type => 'in table:'.$token->{tag_name});  
           $in_body->($insert_to_foster);  
           redo B;  
         } elsif ($self->{insertion_mode} eq 'in cell') {  
           if ($token->{type} eq 'character') {  
             ## NOTE: This is a code clone of "character in body".  
             $reconstruct_active_formatting_elements->($insert_to_current);  
               
             $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});  
3899    
3900              !!!next-token;        $insert = $insert_to_foster;
3901              redo B;        #
3902            } elsif ($token->{type} eq 'comment') {      } elsif ($self->{insertion_mode} == IN_COLUMN_GROUP_IM) {
3903              ## NOTE: This is a code clone of "comment in body".            if ($token->{type} == CHARACTER_TOKEN) {
3904              my $comment = $self->{document}->create_comment ($token->{data});              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
3905              $self->{open_elements}->[-1]->[0]->append_child ($comment);                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
3906              !!!next-token;                unless (length $token->{data}) {
             redo B;  
           } elsif ($token->{type} eq 'start tag') {  
             if ({  
                  caption => 1, col => 1, colgroup => 1,  
                  tbody => 1, td => 1, tfoot => 1, th => 1,  
                  thead => 1, tr => 1,  
                 }->{$token->{tag_name}}) {  
               ## have an element in table scope  
               my $tn;  
               INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
                 my $node = $self->{open_elements}->[$_];  
                 if ($node->[1] eq 'td' or $node->[1] eq 'th') {  
                   $tn = $node->[1];  
                   last INSCOPE;  
                 } elsif ({  
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
                   last INSCOPE;  
                 }  
               } # INSCOPE  
               unless (defined $tn) {  
                 !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
                 ## Ignore the token  
3907                  !!!next-token;                  !!!next-token;
3908                  redo B;                  redo B;
3909                }                }
3910                }
3911                ## Close the cell              
3912                !!!back-token; # <?>              #
3913                $token = {type => 'end tag', tag_name => $tn};            } elsif ($token->{type} == START_TAG_TOKEN) {
3914                if ($token->{tag_name} eq 'col') {
3915                  !!!insert-element ($token->{tag_name}, $token->{attributes});
3916                  pop @{$self->{open_elements}};
3917                  !!!next-token;
3918                redo B;                redo B;
3919              } else {              } else {
3920                #                #
3921              }              }
3922            } elsif ($token->{type} eq 'end tag') {            } elsif ($token->{type} == END_TAG_TOKEN) {
3923              if ($token->{tag_name} eq 'td' or $token->{tag_name} eq 'th') {              if ($token->{tag_name} eq 'colgroup') {
3924                ## have an element in table scope                if ($self->{open_elements}->[-1]->[1] eq 'html') {
3925                my $i;                  !!!parse-error (type => 'unmatched end tag:colgroup');
               INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
                 my $node = $self->{open_elements}->[$_];  
                 if ($node->[1] eq $token->{tag_name}) {  
                   $i = $_;  
                   last INSCOPE;  
                 } elsif ({  
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
                   last INSCOPE;  
                 }  
               } # INSCOPE  
               unless (defined $i) {  
                 !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
3926                  ## Ignore the token                  ## Ignore the token
3927                  !!!next-token;                  !!!next-token;
3928                  redo B;                  redo B;
3929                  } else {
3930                    pop @{$self->{open_elements}}; # colgroup
3931                    $self->{insertion_mode} = IN_TABLE_IM;
3932                    !!!next-token;
3933                    redo B;            
3934                }                }
3935                              } elsif ($token->{tag_name} eq 'col') {
3936                ## generate implied end tags                !!!parse-error (type => 'unmatched end tag:col');
               if ({  
                    dd => 1, dt => 1, li => 1, p => 1,  
                    td => ($token->{tag_name} eq 'th'),  
                    th => ($token->{tag_name} eq 'td'),  
                    tr => 1,  
                   }->{$self->{open_elements}->[-1]->[1]}) {  
                 !!!back-token;  
                 $token = {type => 'end tag',  
                           tag_name => $self->{open_elements}->[-1]->[1]}; # MUST  
                 redo B;  
               }  
   
               if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {  
                 !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
               }  
   
               splice @{$self->{open_elements}}, $i;  
   
               $clear_up_to_marker->();  
   
               $self->{insertion_mode} = 'in row';  
   
               !!!next-token;  
               redo B;  
             } elsif ({  
                       body => 1, caption => 1, col => 1,  
                       colgroup => 1, html => 1,  
                      }->{$token->{tag_name}}) {  
               !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
3937                ## Ignore the token                ## Ignore the token
3938                !!!next-token;                !!!next-token;
3939                redo B;                redo B;
             } elsif ({  
                       table => 1, tbody => 1, tfoot => 1,  
                       thead => 1, tr => 1,  
                      }->{$token->{tag_name}}) {  
               ## have an element in table scope  
               my $i;  
               my $tn;  
               INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
                 my $node = $self->{open_elements}->[$_];  
                 if ($node->[1] eq $token->{tag_name}) {  
                   $i = $_;  
                   last INSCOPE;  
                 } elsif ($node->[1] eq 'td' or $node->[1] eq 'th') {  
                   $tn = $node->[1];  
                   ## NOTE: There is exactly one |td| or |th| element  
                   ## in scope in the stack of open elements by definition.  
                 } elsif ({  
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
                   last INSCOPE;  
                 }  
               } # INSCOPE  
               unless (defined $i) {  
                 !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
                 ## Ignore the token  
                 !!!next-token;  
                 redo B;  
               }  
   
               ## Close the cell  
               !!!back-token; # </?>  
               $token = {type => 'end tag', tag_name => $tn};  
               redo B;  
3940              } else {              } else {
3941                #                #
3942              }              }
3943            } else {            } else {
3944              #              #
3945            }            }
3946              
3947            $in_body->($insert_to_current);            ## As if </colgroup>
3948            redo B;            if ($self->{open_elements}->[-1]->[1] eq 'html') {
3949          } elsif ($self->{insertion_mode} eq 'in select') {              !!!parse-error (type => 'unmatched end tag:colgroup');
3950            if ($token->{type} eq 'character') {              ## Ignore the token
             $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});  
3951              !!!next-token;              !!!next-token;
3952              redo B;              redo B;
3953            } elsif ($token->{type} eq 'comment') {            } else {
3954              my $comment = $self->{document}->create_comment ($token->{data});              pop @{$self->{open_elements}}; # colgroup
3955              $self->{open_elements}->[-1]->[0]->append_child ($comment);              $self->{insertion_mode} = IN_TABLE_IM;
3956                ## reprocess
3957                redo B;
3958              }
3959        } elsif ($self->{insertion_mode} == IN_SELECT_IM) {
3960              if ($token->{type} == CHARACTER_TOKEN) {
3961                $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});
3962              !!!next-token;              !!!next-token;
3963              redo B;              redo B;
3964            } elsif ($token->{type} eq 'start tag') {            } elsif ($token->{type} == START_TAG_TOKEN) {
3965              if ($token->{tag_name} eq 'option') {              if ($token->{tag_name} eq 'option') {
3966                if ($self->{open_elements}->[-1]->[1] eq 'option') {                if ($self->{open_elements}->[-1]->[1] eq 'option') {
3967                  ## As if </option>                  ## As if </option>
# Line 4578  sub _tree_construction_main ($) { Line 4017  sub _tree_construction_main ($) {
4017              } else {              } else {
4018                #                #
4019              }              }
4020            } elsif ($token->{type} eq 'end tag') {            } elsif ($token->{type} == END_TAG_TOKEN) {
4021              if ($token->{tag_name} eq 'optgroup') {              if ($token->{tag_name} eq 'optgroup') {
4022                if ($self->{open_elements}->[-1]->[1] eq 'option' and                if ($self->{open_elements}->[-1]->[1] eq 'option' and
4023                    $self->{open_elements}->[-2]->[1] eq 'optgroup') {                    $self->{open_elements}->[-2]->[1] eq 'optgroup') {
# Line 4691  sub _tree_construction_main ($) { Line 4130  sub _tree_construction_main ($) {
4130            ## Ignore the token            ## Ignore the token
4131            !!!next-token;            !!!next-token;
4132            redo B;            redo B;
4133          } elsif ($self->{insertion_mode} eq 'after body') {      } elsif ($self->{insertion_mode} & BODY_AFTER_IMS) {
4134            if ($token->{type} eq 'character') {        if ($token->{type} == CHARACTER_TOKEN) {
4135              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
4136                ## As if in body            my $data = $1;
4137                $reconstruct_active_formatting_elements->($insert_to_current);            ## As if in body
4138              $reconstruct_active_formatting_elements->($insert_to_current);
4139                                
4140                $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
4141              
4142              unless (length $token->{data}) {
4143                !!!next-token;
4144                redo B;
4145              }
4146            }
4147            
4148            if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4149              !!!parse-error (type => 'after html:#character');
4150    
4151                unless (length $token->{data}) {            ## Reprocess in the "main" phase, "after body" insertion mode...
4152                  !!!next-token;          }
4153                  redo B;          
4154                }          ## "after body" insertion mode
4155              }          !!!parse-error (type => 'after body:#character');
4156                
4157              #          $self->{insertion_mode} = IN_BODY_IM;
4158              !!!parse-error (type => 'after body:#'.$token->{type});          ## reprocess
4159            } elsif ($token->{type} eq 'comment') {          redo B;
4160              my $comment = $self->{document}->create_comment ($token->{data});        } elsif ($token->{type} == START_TAG_TOKEN) {
4161              $self->{open_elements}->[0]->[0]->append_child ($comment);          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4162              !!!parse-error (type => 'after html:'.$token->{tag_name});
4163              
4164              ## Reprocess in the "main" phase, "after body" insertion mode...
4165            }
4166    
4167            ## "after body" insertion mode
4168            !!!parse-error (type => 'after body:'.$token->{tag_name});
4169    
4170            $self->{insertion_mode} = IN_BODY_IM;
4171            ## reprocess
4172            redo B;
4173          } elsif ($token->{type} == END_TAG_TOKEN) {
4174            if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4175              !!!parse-error (type => 'after html:/'.$token->{tag_name});
4176              
4177              $self->{insertion_mode} = AFTER_BODY_IM;
4178              ## Reprocess in the "main" phase, "after body" insertion mode...
4179            }
4180    
4181            ## "after body" insertion mode
4182            if ($token->{tag_name} eq 'html') {
4183              if (defined $self->{inner_html_node}) {
4184                !!!parse-error (type => 'unmatched end tag:html');
4185                ## Ignore the token
4186              !!!next-token;              !!!next-token;
4187              redo B;              redo B;
           } elsif ($token->{type} eq 'start tag') {  
             !!!parse-error (type => 'after body:'.$token->{tag_name});  
             #  
           } elsif ($token->{type} eq 'end tag') {  
             if ($token->{tag_name} eq 'html') {  
               if (defined $self->{inner_html_node}) {  
                 !!!parse-error (type => 'unmatched end tag:html');  
                 ## Ignore the token  
                 !!!next-token;  
                 redo B;  
               } else {  
                 $phase = 'trailing end';  
                 !!!next-token;  
                 redo B;  
               }  
             } else {  
               !!!parse-error (type => 'after body:/'.$token->{tag_name});  
             }  
4188            } else {            } else {
4189              !!!parse-error (type => 'after body:#'.$token->{type});              $self->{insertion_mode} = AFTER_HTML_BODY_IM;
4190                !!!next-token;
4191                redo B;
4192            }            }
4193            } else {
4194              !!!parse-error (type => 'after body:/'.$token->{tag_name});
4195    
4196            $self->{insertion_mode} = 'in body';            $self->{insertion_mode} = IN_BODY_IM;
4197            ## reprocess            ## reprocess
4198            redo B;            redo B;
4199          } elsif ($self->{insertion_mode} eq 'in frameset') {          }
4200            if ($token->{type} eq 'character') {        } else {
4201              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          die "$0: $token->{type}: Unknown token type";
4202                $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});        }
4203        } elsif ($self->{insertion_mode} & FRAME_IMS) {
4204                unless (length $token->{data}) {        if ($token->{type} == CHARACTER_TOKEN) {
4205                  !!!next-token;          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
4206                  redo B;            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
4207                }            
4208              }            unless (length $token->{data}) {
   
             #  
           } elsif ($token->{type} eq 'comment') {  
             my $comment = $self->{document}->create_comment ($token->{data});  
             $self->{open_elements}->[-1]->[0]->append_child ($comment);  
4209              !!!next-token;              !!!next-token;
4210              redo B;              redo B;
4211            } elsif ($token->{type} eq 'start tag') {            }
4212              if ($token->{tag_name} eq 'frameset') {          }
4213                !!!insert-element ($token->{tag_name}, $token->{attributes});          
4214                !!!next-token;          if ($token->{data} =~ s/^[^\x09\x0A\x0B\x0C\x20]+//) {
4215                redo B;            if ($self->{insertion_mode} == IN_FRAMESET_IM) {
4216              } elsif ($token->{tag_name} eq 'frame') {              !!!parse-error (type => 'in frameset:#character');
4217                !!!insert-element ($token->{tag_name}, $token->{attributes});            } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) {
4218                pop @{$self->{open_elements}};              !!!parse-error (type => 'after frameset:#character');
4219                !!!next-token;            } else { # "after html frameset"
4220                redo B;              !!!parse-error (type => 'after html:#character');
4221              } elsif ($token->{tag_name} eq 'noframes') {  
4222                $in_body->($insert_to_current);              $self->{insertion_mode} = AFTER_FRAMESET_IM;
4223                redo B;              ## Reprocess in the "main" phase, "after frameset"...
4224              } else {              !!!parse-error (type => 'after frameset:#character');
               #  
             }  
           } elsif ($token->{type} eq 'end tag') {  
             if ($token->{tag_name} eq 'frameset') {  
               if ($self->{open_elements}->[-1]->[1] eq 'html' and  
                   @{$self->{open_elements}} == 1) {  
                 !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
                 ## Ignore the token  
                 !!!next-token;  
               } else {  
                 pop @{$self->{open_elements}};  
                 !!!next-token;  
               }  
                 
               ## if not inner_html and  
               if ($self->{open_elements}->[-1]->[1] ne 'frameset') {  
                 $self->{insertion_mode} = 'after frameset';  
               }  
               redo B;  
             } else {  
               #  
             }  
           } else {  
             #  
4225            }            }
4226                        
4227            if (defined $token->{tag_name}) {            ## Ignore the token.
4228              if (length $token->{data}) {
4229                ## reprocess the rest of characters
4230              } else {
4231                !!!next-token;
4232              }
4233              redo B;
4234            }
4235            
4236            die qq[$0: Character "$token->{data}"];
4237          } elsif ($token->{type} == START_TAG_TOKEN) {
4238            if ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
4239              !!!parse-error (type => 'after html:'.$token->{tag_name});
4240    
4241              $self->{insertion_mode} = AFTER_FRAMESET_IM;
4242              ## Process in the "main" phase, "after frameset" insertion mode...
4243            }
4244    
4245            if ($token->{tag_name} eq 'frameset' and
4246                $self->{insertion_mode} == IN_FRAMESET_IM) {
4247              !!!insert-element ($token->{tag_name}, $token->{attributes});
4248              !!!next-token;
4249              redo B;
4250            } elsif ($token->{tag_name} eq 'frame' and
4251                     $self->{insertion_mode} == IN_FRAMESET_IM) {
4252              !!!insert-element ($token->{tag_name}, $token->{attributes});
4253              pop @{$self->{open_elements}};
4254              !!!next-token;
4255              redo B;
4256            } elsif ($token->{tag_name} eq 'noframes') {
4257              ## NOTE: As if in body.
4258              $parse_rcdata->(CDATA_CONTENT_MODEL, $insert_to_current);
4259              redo B;
4260            } else {
4261              if ($self->{insertion_mode} == IN_FRAMESET_IM) {
4262              !!!parse-error (type => 'in frameset:'.$token->{tag_name});              !!!parse-error (type => 'in frameset:'.$token->{tag_name});
4263            } else {            } else {
4264              !!!parse-error (type => 'in frameset:#'.$token->{type});              !!!parse-error (type => 'after frameset:'.$token->{tag_name});
4265            }            }
4266            ## Ignore the token            ## Ignore the token
4267            !!!next-token;            !!!next-token;
4268            redo B;            redo B;
4269          } elsif ($self->{insertion_mode} eq 'after frameset') {          }
4270            if ($token->{type} eq 'character') {        } elsif ($token->{type} == END_TAG_TOKEN) {
4271              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          if ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
4272                $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});            !!!parse-error (type => 'after html:/'.$token->{tag_name});
4273    
4274                unless (length $token->{data}) {            $self->{insertion_mode} = AFTER_FRAMESET_IM;
4275                  !!!next-token;            ## Process in the "main" phase, "after frameset" insertion mode...
4276                  redo B;          }
               }  
             }  
4277    
4278              #          if ($token->{tag_name} eq 'frameset' and
4279            } elsif ($token->{type} eq 'comment') {              $self->{insertion_mode} == IN_FRAMESET_IM) {
4280              my $comment = $self->{document}->create_comment ($token->{data});            if ($self->{open_elements}->[-1]->[1] eq 'html' and
4281              $self->{open_elements}->[-1]->[0]->append_child ($comment);                @{$self->{open_elements}} == 1) {
4282                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
4283                ## Ignore the token
4284              !!!next-token;              !!!next-token;
             redo B;  
           } elsif ($token->{type} eq 'start tag') {  
             if ($token->{tag_name} eq 'noframes') {  
               $in_body->($insert_to_current);  
               redo B;  
             } else {  
               #  
             }  
           } elsif ($token->{type} eq 'end tag') {  
             if ($token->{tag_name} eq 'html') {  
               $phase = 'trailing end';  
               !!!next-token;  
               redo B;  
             } else {  
               #  
             }  
4285            } else {            } else {
4286              #              pop @{$self->{open_elements}};
4287                !!!next-token;
4288            }            }
4289              
4290            if (defined $token->{tag_name}) {            if (not defined $self->{inner_html_node} and
4291              !!!parse-error (type => 'after frameset:'.$token->{tag_name});                $self->{open_elements}->[-1]->[1] ne 'frameset') {
4292                $self->{insertion_mode} = AFTER_FRAMESET_IM;
4293              }
4294              redo B;
4295            } elsif ($token->{tag_name} eq 'html' and
4296                     $self->{insertion_mode} == AFTER_FRAMESET_IM) {
4297              $self->{insertion_mode} = AFTER_HTML_FRAMESET_IM;
4298              !!!next-token;
4299              redo B;
4300            } else {
4301              if ($self->{insertion_mode} == IN_FRAMESET_IM) {
4302                !!!parse-error (type => 'in frameset:/'.$token->{tag_name});
4303            } else {            } else {
4304              !!!parse-error (type => 'after frameset:#'.$token->{type});              !!!parse-error (type => 'after frameset:/'.$token->{tag_name});
4305            }            }
4306            ## Ignore the token            ## Ignore the token
4307            !!!next-token;            !!!next-token;
4308            redo B;            redo B;
4309            }
4310          } else {
4311            die "$0: $token->{type}: Unknown token type";
4312          }
4313    
4314          ## ISSUE: An issue in spec here
4315        } else {
4316          die "$0: $self->{insertion_mode}: Unknown insertion mode";
4317        }
4318    
4319            ## ISSUE: An issue in spec there      ## "in body" insertion mode
4320        if ($token->{type} == START_TAG_TOKEN) {
4321          if ($token->{tag_name} eq 'script') {
4322            ## NOTE: This is an "as if in head" code clone
4323            $script_start_tag->($insert);
4324            redo B;
4325          } elsif ($token->{tag_name} eq 'style') {
4326            ## NOTE: This is an "as if in head" code clone
4327            $parse_rcdata->(CDATA_CONTENT_MODEL, $insert);
4328            redo B;
4329          } elsif ({
4330                    base => 1, link => 1,
4331                   }->{$token->{tag_name}}) {
4332            ## NOTE: This is an "as if in head" code clone, only "-t" differs
4333            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4334            pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
4335            !!!next-token;
4336            redo B;
4337          } elsif ($token->{tag_name} eq 'meta') {
4338            ## NOTE: This is an "as if in head" code clone, only "-t" differs
4339            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4340            pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
4341    
4342            unless ($self->{confident}) {
4343              my $charset;
4344              if ($token->{attributes}->{charset}) { ## TODO: And if supported
4345                $charset = $token->{attributes}->{charset}->{value};
4346              }
4347              if ($token->{attributes}->{'http-equiv'}) {
4348                ## ISSUE: Algorithm name in the spec was incorrect so that not linked to the definition.
4349                if ($token->{attributes}->{'http-equiv'}->{value}
4350                    =~ /\A[^;]*;[\x09-\x0D\x20]*charset[\x09-\x0D\x20]*=
4351                        [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'|
4352                        ([^"'\x09-\x0D\x20][^\x09-\x0D\x20]*))/x) {
4353                  $charset = defined $1 ? $1 : defined $2 ? $2 : $3;
4354                } ## TODO: And if supported
4355              }
4356              ## TODO: Change the encoding
4357            }
4358    
4359            !!!next-token;
4360            redo B;
4361          } elsif ($token->{tag_name} eq 'title') {
4362            !!!parse-error (type => 'in body:title');
4363            ## NOTE: This is an "as if in head" code clone
4364            $parse_rcdata->(RCDATA_CONTENT_MODEL, sub {
4365              if (defined $self->{head_element}) {
4366                $self->{head_element}->append_child ($_[0]);
4367              } else {
4368                $insert->($_[0]);
4369              }
4370            });
4371            redo B;
4372          } elsif ($token->{tag_name} eq 'body') {
4373            !!!parse-error (type => 'in body:body');
4374                  
4375            if (@{$self->{open_elements}} == 1 or
4376                $self->{open_elements}->[1]->[1] ne 'body') {
4377              ## Ignore the token
4378          } else {          } else {
4379            die "$0: $self->{insertion_mode}: Unknown insertion mode";            my $body_el = $self->{open_elements}->[1]->[0];
4380              for my $attr_name (keys %{$token->{attributes}}) {
4381                unless ($body_el->has_attribute_ns (undef, $attr_name)) {
4382                  $body_el->set_attribute_ns
4383                    (undef, [undef, $attr_name],
4384                     $token->{attributes}->{$attr_name}->{value});
4385                }
4386              }
4387          }          }
       }  
     } elsif ($phase eq 'trailing end') {  
       ## states in the main stage is preserved yet # MUST  
         
       if ($token->{type} eq 'DOCTYPE') {  
         !!!parse-error (type => 'after html:#DOCTYPE');  
         ## Ignore the token  
4388          !!!next-token;          !!!next-token;
4389          redo B;          redo B;
4390        } elsif ($token->{type} eq 'comment') {        } elsif ({
4391          my $comment = $self->{document}->create_comment ($token->{data});                  address => 1, blockquote => 1, center => 1, dir => 1,
4392          $self->{document}->append_child ($comment);                  div => 1, dl => 1, fieldset => 1, listing => 1,
4393                    menu => 1, ol => 1, p => 1, ul => 1,
4394                    pre => 1,
4395                   }->{$token->{tag_name}}) {
4396            ## has a p element in scope
4397            INSCOPE: for (reverse @{$self->{open_elements}}) {
4398              if ($_->[1] eq 'p') {
4399                !!!back-token;
4400                $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4401                redo B;
4402              } elsif ({
4403                        table => 1, caption => 1, td => 1, th => 1,
4404                        button => 1, marquee => 1, object => 1, html => 1,
4405                       }->{$_->[1]}) {
4406                last INSCOPE;
4407              }
4408            } # INSCOPE
4409              
4410            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4411            if ($token->{tag_name} eq 'pre') {
4412              !!!next-token;
4413              if ($token->{type} == CHARACTER_TOKEN) {
4414                $token->{data} =~ s/^\x0A//;
4415                unless (length $token->{data}) {
4416                  !!!next-token;
4417                }
4418              }
4419            } else {
4420              !!!next-token;
4421            }
4422            redo B;
4423          } elsif ($token->{tag_name} eq 'form') {
4424            if (defined $self->{form_element}) {
4425              !!!parse-error (type => 'in form:form');
4426              ## Ignore the token
4427              !!!next-token;
4428              redo B;
4429            } else {
4430              ## has a p element in scope
4431              INSCOPE: for (reverse @{$self->{open_elements}}) {
4432                if ($_->[1] eq 'p') {
4433                  !!!back-token;
4434                  $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4435                  redo B;
4436                } elsif ({
4437                          table => 1, caption => 1, td => 1, th => 1,
4438                          button => 1, marquee => 1, object => 1, html => 1,
4439                         }->{$_->[1]}) {
4440                  last INSCOPE;
4441                }
4442              } # INSCOPE
4443                
4444              !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4445              $self->{form_element} = $self->{open_elements}->[-1]->[0];
4446              !!!next-token;
4447              redo B;
4448            }
4449          } elsif ($token->{tag_name} eq 'li') {
4450            ## has a p element in scope
4451            INSCOPE: for (reverse @{$self->{open_elements}}) {
4452              if ($_->[1] eq 'p') {
4453                !!!back-token;
4454                $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4455                redo B;
4456              } elsif ({
4457                        table => 1, caption => 1, td => 1, th => 1,
4458                        button => 1, marquee => 1, object => 1, html => 1,
4459                       }->{$_->[1]}) {
4460                last INSCOPE;
4461              }
4462            } # INSCOPE
4463              
4464            ## Step 1
4465            my $i = -1;
4466            my $node = $self->{open_elements}->[$i];
4467            LI: {
4468              ## Step 2
4469              if ($node->[1] eq 'li') {
4470                if ($i != -1) {
4471                  !!!parse-error (type => 'end tag missing:'.
4472                                  $self->{open_elements}->[-1]->[1]);
4473                }
4474                splice @{$self->{open_elements}}, $i;
4475                last LI;
4476              }
4477              
4478              ## Step 3
4479              if (not $formatting_category->{$node->[1]} and
4480                  #not $phrasing_category->{$node->[1]} and
4481                  ($special_category->{$node->[1]} or
4482                   $scoping_category->{$node->[1]}) and
4483                  $node->[1] ne 'address' and $node->[1] ne 'div') {
4484                last LI;
4485              }
4486              
4487              ## Step 4
4488              $i--;
4489              $node = $self->{open_elements}->[$i];
4490              redo LI;
4491            } # LI
4492              
4493            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4494          !!!next-token;          !!!next-token;
4495          redo B;          redo B;
4496        } elsif ($token->{type} eq 'character') {        } elsif ($token->{tag_name} eq 'dd' or $token->{tag_name} eq 'dt') {
4497          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          ## has a p element in scope
4498            my $data = $1;          INSCOPE: for (reverse @{$self->{open_elements}}) {
4499            ## As if in the main phase.            if ($_->[1] eq 'p') {
4500            ## NOTE: The insertion mode in the main phase              !!!back-token;
4501            ## just before the phase has been changed to the trailing              $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4502            ## end phase is either "after body" or "after frameset".              redo B;
4503            $reconstruct_active_formatting_elements->($insert_to_current)            } elsif ({
4504              if $phase eq 'main';                      table => 1, caption => 1, td => 1, th => 1,
4505                        button => 1, marquee => 1, object => 1, html => 1,
4506                       }->{$_->[1]}) {
4507                last INSCOPE;
4508              }
4509            } # INSCOPE
4510              
4511            ## Step 1
4512            my $i = -1;
4513            my $node = $self->{open_elements}->[$i];
4514            LI: {
4515              ## Step 2
4516              if ($node->[1] eq 'dt' or $node->[1] eq 'dd') {
4517                if ($i != -1) {
4518                  !!!parse-error (type => 'end tag missing:'.
4519                                  $self->{open_elements}->[-1]->[1]);
4520                }
4521                splice @{$self->{open_elements}}, $i;
4522                last LI;
4523              }
4524              
4525              ## Step 3
4526              if (not $formatting_category->{$node->[1]} and
4527                  #not $phrasing_category->{$node->[1]} and
4528                  ($special_category->{$node->[1]} or
4529                   $scoping_category->{$node->[1]}) and
4530                  $node->[1] ne 'address' and $node->[1] ne 'div') {
4531                last LI;
4532              }
4533              
4534              ## Step 4
4535              $i--;
4536              $node = $self->{open_elements}->[$i];
4537              redo LI;
4538            } # LI
4539              
4540            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4541            !!!next-token;
4542            redo B;
4543          } elsif ($token->{tag_name} eq 'plaintext') {
4544            ## has a p element in scope
4545            INSCOPE: for (reverse @{$self->{open_elements}}) {
4546              if ($_->[1] eq 'p') {
4547                !!!back-token;
4548                $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4549                redo B;
4550              } elsif ({
4551                        table => 1, caption => 1, td => 1, th => 1,
4552                        button => 1, marquee => 1, object => 1, html => 1,
4553                       }->{$_->[1]}) {
4554                last INSCOPE;
4555              }
4556            } # INSCOPE
4557              
4558            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4559              
4560            $self->{content_model} = PLAINTEXT_CONTENT_MODEL;
4561              
4562            !!!next-token;
4563            redo B;
4564          } elsif ({
4565                    h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,
4566                   }->{$token->{tag_name}}) {
4567            ## has a p element in scope
4568            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4569              my $node = $self->{open_elements}->[$_];
4570              if ($node->[1] eq 'p') {
4571                !!!back-token;
4572                $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4573                redo B;
4574              } elsif ({
4575                        table => 1, caption => 1, td => 1, th => 1,
4576                        button => 1, marquee => 1, object => 1, html => 1,
4577                       }->{$node->[1]}) {
4578                last INSCOPE;
4579              }
4580            } # INSCOPE
4581              
4582            ## NOTE: See <http://html5.org/tools/web-apps-tracker?from=925&to=926>
4583            ## has an element in scope
4584            #my $i;
4585            #INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4586            #  my $node = $self->{open_elements}->[$_];
4587            #  if ({
4588            #       h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,
4589            #      }->{$node->[1]}) {
4590            #    $i = $_;
4591            #    last INSCOPE;
4592            #  } elsif ({
4593            #            table => 1, caption => 1, td => 1, th => 1,
4594            #            button => 1, marquee => 1, object => 1, html => 1,
4595            #           }->{$node->[1]}) {
4596            #    last INSCOPE;
4597            #  }
4598            #} # INSCOPE
4599            #  
4600            #if (defined $i) {
4601            #  !!! parse-error (type => 'in hn:hn');
4602            #  splice @{$self->{open_elements}}, $i;
4603            #}
4604              
4605            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4606              
4607            !!!next-token;
4608            redo B;
4609          } elsif ($token->{tag_name} eq 'a') {
4610            AFE: for my $i (reverse 0..$#$active_formatting_elements) {
4611              my $node = $active_formatting_elements->[$i];
4612              if ($node->[1] eq 'a') {
4613                !!!parse-error (type => 'in a:a');
4614                
4615                !!!back-token;
4616                $token = {type => END_TAG_TOKEN, tag_name => 'a'};
4617                $formatting_end_tag->($token->{tag_name});
4618                
4619                AFE2: for (reverse 0..$#$active_formatting_elements) {
4620                  if ($active_formatting_elements->[$_]->[0] eq $node->[0]) {
4621                    splice @$active_formatting_elements, $_, 1;
4622                    last AFE2;
4623                  }
4624                } # AFE2
4625                OE: for (reverse 0..$#{$self->{open_elements}}) {
4626                  if ($self->{open_elements}->[$_]->[0] eq $node->[0]) {
4627                    splice @{$self->{open_elements}}, $_, 1;
4628                    last OE;
4629                  }
4630                } # OE
4631                last AFE;
4632              } elsif ($node->[0] eq '#marker') {
4633                last AFE;
4634              }
4635            } # AFE
4636              
4637            $reconstruct_active_formatting_elements->($insert_to_current);
4638    
4639            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4640            push @$active_formatting_elements, $self->{open_elements}->[-1];
4641    
4642            !!!next-token;
4643            redo B;
4644          } elsif ({
4645                    b => 1, big => 1, em => 1, font => 1, i => 1,
4646                    s => 1, small => 1, strile => 1,
4647                    strong => 1, tt => 1, u => 1,
4648                   }->{$token->{tag_name}}) {
4649            $reconstruct_active_formatting_elements->($insert_to_current);
4650            
4651            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4652            push @$active_formatting_elements, $self->{open_elements}->[-1];
4653            
4654            !!!next-token;
4655            redo B;
4656          } elsif ($token->{tag_name} eq 'nobr') {
4657            $reconstruct_active_formatting_elements->($insert_to_current);
4658    
4659            ## has a |nobr| element in scope
4660            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4661              my $node = $self->{open_elements}->[$_];
4662              if ($node->[1] eq 'nobr') {
4663                !!!parse-error (type => 'not closed:nobr');
4664                !!!back-token;
4665                $token = {type => END_TAG_TOKEN, tag_name => 'nobr'};
4666                redo B;
4667              } elsif ({
4668                        table => 1, caption => 1, td => 1, th => 1,
4669                        button => 1, marquee => 1, object => 1, html => 1,
4670                       }->{$node->[1]}) {
4671                last INSCOPE;
4672              }
4673            } # INSCOPE
4674            
4675            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4676            push @$active_formatting_elements, $self->{open_elements}->[-1];
4677            
4678            !!!next-token;
4679            redo B;
4680          } elsif ($token->{tag_name} eq 'button') {
4681            ## has a button element in scope
4682            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4683              my $node = $self->{open_elements}->[$_];
4684              if ($node->[1] eq 'button') {
4685                !!!parse-error (type => 'in button:button');
4686                !!!back-token;
4687                $token = {type => END_TAG_TOKEN, tag_name => 'button'};
4688                redo B;
4689              } elsif ({
4690                        table => 1, caption => 1, td => 1, th => 1,
4691                        button => 1, marquee => 1, object => 1, html => 1,
4692                       }->{$node->[1]}) {
4693                last INSCOPE;
4694              }
4695            } # INSCOPE
4696              
4697            $reconstruct_active_formatting_elements->($insert_to_current);
4698              
4699            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4700            push @$active_formatting_elements, ['#marker', ''];
4701    
4702            !!!next-token;
4703            redo B;
4704          } elsif ($token->{tag_name} eq 'marquee' or
4705                   $token->{tag_name} eq 'object') {
4706            $reconstruct_active_formatting_elements->($insert_to_current);
4707            
4708            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4709            push @$active_formatting_elements, ['#marker', ''];
4710            
4711            !!!next-token;
4712            redo B;
4713          } elsif ($token->{tag_name} eq 'xmp') {
4714            $reconstruct_active_formatting_elements->($insert_to_current);
4715            $parse_rcdata->(CDATA_CONTENT_MODEL, $insert);
4716            redo B;
4717          } elsif ($token->{tag_name} eq 'table') {
4718            ## has a p element in scope
4719            INSCOPE: for (reverse @{$self->{open_elements}}) {
4720              if ($_->[1] eq 'p') {
4721                !!!back-token;
4722                $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4723                redo B;
4724              } elsif ({
4725                        table => 1, caption => 1, td => 1, th => 1,
4726                        button => 1, marquee => 1, object => 1, html => 1,
4727                       }->{$_->[1]}) {
4728                last INSCOPE;
4729              }
4730            } # INSCOPE
4731              
4732            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4733                        
4734            $self->{open_elements}->[-1]->[0]->manakai_append_text ($data);          $self->{insertion_mode} = IN_TABLE_IM;
4735                        
4736            !!!next-token;
4737            redo B;
4738          } elsif ({
4739                    area => 1, basefont => 1, bgsound => 1, br => 1,
4740                    embed => 1, img => 1, param => 1, spacer => 1, wbr => 1,
4741                    image => 1,
4742                   }->{$token->{tag_name}}) {
4743            if ($token->{tag_name} eq 'image') {
4744              !!!parse-error (type => 'image');
4745              $token->{tag_name} = 'img';
4746            }
4747    
4748            ## NOTE: There is an "as if <br>" code clone.
4749            $reconstruct_active_formatting_elements->($insert_to_current);
4750            
4751            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4752            pop @{$self->{open_elements}};
4753            
4754            !!!next-token;
4755            redo B;
4756          } elsif ($token->{tag_name} eq 'hr') {
4757            ## has a p element in scope
4758            INSCOPE: for (reverse @{$self->{open_elements}}) {
4759              if ($_->[1] eq 'p') {
4760                !!!back-token;
4761                $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4762                redo B;
4763              } elsif ({
4764                        table => 1, caption => 1, td => 1, th => 1,
4765                        button => 1, marquee => 1, object => 1, html => 1,
4766                       }->{$_->[1]}) {
4767                last INSCOPE;
4768              }
4769            } # INSCOPE
4770              
4771            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4772            pop @{$self->{open_elements}};
4773              
4774            !!!next-token;
4775            redo B;
4776          } elsif ($token->{tag_name} eq 'input') {
4777            $reconstruct_active_formatting_elements->($insert_to_current);
4778            
4779            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4780            ## TODO: associate with $self->{form_element} if defined
4781            pop @{$self->{open_elements}};
4782            
4783            !!!next-token;
4784            redo B;
4785          } elsif ($token->{tag_name} eq 'isindex') {
4786            !!!parse-error (type => 'isindex');
4787            
4788            if (defined $self->{form_element}) {
4789              ## Ignore the token
4790              !!!next-token;
4791              redo B;
4792            } else {
4793              my $at = $token->{attributes};
4794              my $form_attrs;
4795              $form_attrs->{action} = $at->{action} if $at->{action};
4796              my $prompt_attr = $at->{prompt};
4797              $at->{name} = {name => 'name', value => 'isindex'};
4798              delete $at->{action};
4799              delete $at->{prompt};
4800              my @tokens = (
4801                            {type => START_TAG_TOKEN, tag_name => 'form',
4802                             attributes => $form_attrs},
4803                            {type => START_TAG_TOKEN, tag_name => 'hr'},
4804                            {type => START_TAG_TOKEN, tag_name => 'p'},
4805                            {type => START_TAG_TOKEN, tag_name => 'label'},
4806                           );
4807              if ($prompt_attr) {
4808                push @tokens, {type => CHARACTER_TOKEN, data => $prompt_attr->{value}};
4809              } else {
4810                push @tokens, {type => CHARACTER_TOKEN,
4811                               data => 'This is a searchable index. Insert your search keywords here: '}; # SHOULD
4812                ## TODO: make this configurable
4813              }
4814              push @tokens,
4815                            {type => START_TAG_TOKEN, tag_name => 'input', attributes => $at},
4816                            #{type => CHARACTER_TOKEN, data => ''}, # SHOULD
4817                            {type => END_TAG_TOKEN, tag_name => 'label'},
4818                            {type => END_TAG_TOKEN, tag_name => 'p'},
4819                            {type => START_TAG_TOKEN, tag_name => 'hr'},
4820                            {type => END_TAG_TOKEN, tag_name => 'form'};
4821              $token = shift @tokens;
4822              !!!back-token (@tokens);
4823              redo B;
4824            }
4825          } elsif ($token->{tag_name} eq 'textarea') {
4826            my $tag_name = $token->{tag_name};
4827            my $el;
4828            !!!create-element ($el, $token->{tag_name}, $token->{attributes});
4829            
4830            ## TODO: $self->{form_element} if defined
4831            $self->{content_model} = RCDATA_CONTENT_MODEL;
4832            delete $self->{escape}; # MUST
4833            
4834            $insert->($el);
4835            
4836            my $text = '';
4837            !!!next-token;
4838            if ($token->{type} == CHARACTER_TOKEN) {
4839              $token->{data} =~ s/^\x0A//;
4840            unless (length $token->{data}) {            unless (length $token->{data}) {
4841              !!!next-token;              !!!next-token;
             redo B;  
4842            }            }
4843          }          }
4844            while ($token->{type} == CHARACTER_TOKEN) {
4845              $text .= $token->{data};
4846              !!!next-token;
4847            }
4848            if (length $text) {
4849              $el->manakai_append_text ($text);
4850            }
4851            
4852            $self->{content_model} = PCDATA_CONTENT_MODEL;
4853            
4854            if ($token->{type} == END_TAG_TOKEN and
4855                $token->{tag_name} eq $tag_name) {
4856              ## Ignore the token
4857            } else {
4858              !!!parse-error (type => 'in RCDATA:#'.$token->{type});
4859            }
4860            !!!next-token;
4861            redo B;
4862          } elsif ({
4863                    iframe => 1,
4864                    noembed => 1,
4865                    noframes => 1,
4866                    noscript => 0, ## TODO: 1 if scripting is enabled
4867                   }->{$token->{tag_name}}) {
4868            ## NOTE: There are two "as if in body" code clones.
4869            $parse_rcdata->(CDATA_CONTENT_MODEL, $insert);
4870            redo B;
4871          } elsif ($token->{tag_name} eq 'select') {
4872            $reconstruct_active_formatting_elements->($insert_to_current);
4873            
4874            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4875            
4876            $self->{insertion_mode} = IN_SELECT_IM;
4877            !!!next-token;
4878            redo B;
4879          } elsif ({
4880                    caption => 1, col => 1, colgroup => 1, frame => 1,
4881                    frameset => 1, head => 1, option => 1, optgroup => 1,
4882                    tbody => 1, td => 1, tfoot => 1, th => 1,
4883                    thead => 1, tr => 1,
4884                   }->{$token->{tag_name}}) {
4885            !!!parse-error (type => 'in body:'.$token->{tag_name});
4886            ## Ignore the token
4887            !!!next-token;
4888            redo B;
4889            
4890            ## ISSUE: An issue on HTML5 new elements in the spec.
4891          } else {
4892            $reconstruct_active_formatting_elements->($insert_to_current);
4893            
4894            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4895            
4896            !!!next-token;
4897            redo B;
4898          }
4899        } elsif ($token->{type} == END_TAG_TOKEN) {
4900          if ($token->{tag_name} eq 'body') {
4901            if (@{$self->{open_elements}} > 1 and
4902                $self->{open_elements}->[1]->[1] eq 'body') {
4903              for (@{$self->{open_elements}}) {
4904                unless ({
4905                           dd => 1, dt => 1, li => 1, p => 1, td => 1,
4906                           th => 1, tr => 1, body => 1, html => 1,
4907                         tbody => 1, tfoot => 1, thead => 1,
4908                        }->{$_->[1]}) {
4909                  !!!parse-error (type => 'not closed:'.$_->[1]);
4910                }
4911              }
4912    
4913          !!!parse-error (type => 'after html:#character');            $self->{insertion_mode} = AFTER_BODY_IM;
4914          $phase = 'main';            !!!next-token;
4915          ## reprocess            redo B;
4916            } else {
4917              !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
4918              ## Ignore the token
4919              !!!next-token;
4920              redo B;
4921            }
4922          } elsif ($token->{tag_name} eq 'html') {
4923            if (@{$self->{open_elements}} > 1 and $self->{open_elements}->[1]->[1] eq 'body') {
4924              ## ISSUE: There is an issue in the spec.
4925              if ($self->{open_elements}->[-1]->[1] ne 'body') {
4926                !!!parse-error (type => 'not closed:'.$self->{open_elements}->[1]->[1]);
4927              }
4928              $self->{insertion_mode} = AFTER_BODY_IM;
4929              ## reprocess
4930              redo B;
4931            } else {
4932              !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
4933              ## Ignore the token
4934              !!!next-token;
4935              redo B;
4936            }
4937          } elsif ({
4938                    address => 1, blockquote => 1, center => 1, dir => 1,
4939                    div => 1, dl => 1, fieldset => 1, listing => 1,
4940                    menu => 1, ol => 1, pre => 1, ul => 1,
4941                    p => 1,
4942                    dd => 1, dt => 1, li => 1,
4943                    button => 1, marquee => 1, object => 1,
4944                   }->{$token->{tag_name}}) {
4945            ## has an element in scope
4946            my $i;
4947            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4948              my $node = $self->{open_elements}->[$_];
4949              if ($node->[1] eq $token->{tag_name}) {
4950                ## generate implied end tags
4951                if ({
4952                     dd => ($token->{tag_name} ne 'dd'),
4953                     dt => ($token->{tag_name} ne 'dt'),
4954                     li => ($token->{tag_name} ne 'li'),
4955                     p => ($token->{tag_name} ne 'p'),
4956                     td => 1, th => 1, tr => 1,
4957                     tbody => 1, tfoot=> 1, thead => 1,
4958                    }->{$self->{open_elements}->[-1]->[1]}) {
4959                  !!!back-token;
4960                  $token = {type => END_TAG_TOKEN,
4961                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
4962                  redo B;
4963                }
4964                $i = $_;
4965                last INSCOPE unless $token->{tag_name} eq 'p';
4966              } elsif ({
4967                        table => 1, caption => 1, td => 1, th => 1,
4968                        button => 1, marquee => 1, object => 1, html => 1,
4969                       }->{$node->[1]}) {
4970                last INSCOPE;
4971              }
4972            } # INSCOPE
4973            
4974            if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {
4975              if (defined $i) {
4976                !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
4977              } else {
4978                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
4979              }
4980            }
4981            
4982            if (defined $i) {
4983              splice @{$self->{open_elements}}, $i;
4984            } elsif ($token->{tag_name} eq 'p') {
4985              ## As if <p>, then reprocess the current token
4986              my $el;
4987              !!!create-element ($el, 'p');
4988              $insert->($el);
4989            }
4990            $clear_up_to_marker->()
4991              if {
4992                button => 1, marquee => 1, object => 1,
4993              }->{$token->{tag_name}};
4994            !!!next-token;
4995          redo B;          redo B;
4996        } elsif ($token->{type} eq 'start tag' or        } elsif ($token->{tag_name} eq 'form') {
4997                 $token->{type} eq 'end tag') {          ## has an element in scope
4998          !!!parse-error (type => 'after html:'.$token->{tag_name});          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4999          $phase = 'main';            my $node = $self->{open_elements}->[$_];
5000          ## reprocess            if ($node->[1] eq $token->{tag_name}) {
5001                ## generate implied end tags
5002                if ({
5003                     dd => 1, dt => 1, li => 1, p => 1,
5004                     td => 1, th => 1, tr => 1,
5005                     tbody => 1, tfoot=> 1, thead => 1,
5006                    }->{$self->{open_elements}->[-1]->[1]}) {
5007                  !!!back-token;
5008                  $token = {type => END_TAG_TOKEN,
5009                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
5010                  redo B;
5011                }
5012                last INSCOPE;
5013              } elsif ({
5014                        table => 1, caption => 1, td => 1, th => 1,
5015                        button => 1, marquee => 1, object => 1, html => 1,
5016                       }->{$node->[1]}) {
5017                last INSCOPE;
5018              }
5019            } # INSCOPE
5020            
5021            if ($self->{open_elements}->[-1]->[1] eq $token->{tag_name}) {
5022              pop @{$self->{open_elements}};
5023            } else {
5024              !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5025            }
5026    
5027            undef $self->{form_element};
5028            !!!next-token;
5029            redo B;
5030          } elsif ({
5031                    h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,
5032                   }->{$token->{tag_name}}) {
5033            ## has an element in scope
5034            my $i;
5035            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5036              my $node = $self->{open_elements}->[$_];
5037              if ({
5038                   h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,
5039                  }->{$node->[1]}) {
5040                ## generate implied end tags
5041                if ({
5042                     dd => 1, dt => 1, li => 1, p => 1,
5043                     td => 1, th => 1, tr => 1,
5044                     tbody => 1, tfoot=> 1, thead => 1,
5045                    }->{$self->{open_elements}->[-1]->[1]}) {
5046                  !!!back-token;
5047                  $token = {type => END_TAG_TOKEN,
5048                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
5049                  redo B;
5050                }
5051                $i = $_;
5052                last INSCOPE;
5053              } elsif ({
5054                        table => 1, caption => 1, td => 1, th => 1,
5055                        button => 1, marquee => 1, object => 1, html => 1,
5056                       }->{$node->[1]}) {
5057                last INSCOPE;
5058              }
5059            } # INSCOPE
5060            
5061            if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {
5062              !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5063            }
5064            
5065            splice @{$self->{open_elements}}, $i if defined $i;
5066            !!!next-token;
5067            redo B;
5068          } elsif ({
5069                    a => 1,
5070                    b => 1, big => 1, em => 1, font => 1, i => 1,
5071                    nobr => 1, s => 1, small => 1, strile => 1,
5072                    strong => 1, tt => 1, u => 1,
5073                   }->{$token->{tag_name}}) {
5074            $formatting_end_tag->($token->{tag_name});
5075            redo B;
5076          } elsif ($token->{tag_name} eq 'br') {
5077            !!!parse-error (type => 'unmatched end tag:br');
5078    
5079            ## As if <br>
5080            $reconstruct_active_formatting_elements->($insert_to_current);
5081            
5082            my $el;
5083            !!!create-element ($el, 'br');
5084            $insert->($el);
5085            
5086            ## Ignore the token.
5087            !!!next-token;
5088            redo B;
5089          } elsif ({
5090                    caption => 1, col => 1, colgroup => 1, frame => 1,
5091                    frameset => 1, head => 1, option => 1, optgroup => 1,
5092                    tbody => 1, td => 1, tfoot => 1, th => 1,
5093                    thead => 1, tr => 1,
5094                    area => 1, basefont => 1, bgsound => 1,
5095                    embed => 1, hr => 1, iframe => 1, image => 1,
5096                    img => 1, input => 1, isindex => 1, noembed => 1,
5097                    noframes => 1, param => 1, select => 1, spacer => 1,
5098                    table => 1, textarea => 1, wbr => 1,
5099                    noscript => 0, ## TODO: if scripting is enabled
5100                   }->{$token->{tag_name}}) {
5101            !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
5102            ## Ignore the token
5103            !!!next-token;
5104          redo B;          redo B;
5105        } elsif ($token->{type} eq 'end-of-file') {          
5106          ## Stop parsing          ## ISSUE: Issue on HTML5 new elements in spec
5107          last B;          
5108        } else {        } else {
5109          die "$0: $token->{type}: Unknown token";          ## Step 1
5110            my $node_i = -1;
5111            my $node = $self->{open_elements}->[$node_i];
5112    
5113            ## Step 2
5114            S2: {
5115              if ($node->[1] eq $token->{tag_name}) {
5116                ## Step 1
5117                ## generate implied end tags
5118                if ({
5119                     dd => 1, dt => 1, li => 1, p => 1,
5120                     td => 1, th => 1, tr => 1,
5121                     tbody => 1, tfoot => 1, thead => 1,
5122                    }->{$self->{open_elements}->[-1]->[1]}) {
5123                  !!!back-token;
5124                  $token = {type => END_TAG_TOKEN,
5125                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
5126                  redo B;
5127                }
5128            
5129                ## Step 2
5130                if ($token->{tag_name} ne $self->{open_elements}->[-1]->[1]) {
5131                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5132                }
5133                
5134                ## Step 3
5135                splice @{$self->{open_elements}}, $node_i;
5136    
5137                !!!next-token;
5138                last S2;
5139              } else {
5140                ## Step 3
5141                if (not $formatting_category->{$node->[1]} and
5142                    #not $phrasing_category->{$node->[1]} and
5143                    ($special_category->{$node->[1]} or
5144                     $scoping_category->{$node->[1]})) {
5145                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
5146                  ## Ignore the token
5147                  !!!next-token;
5148                  last S2;
5149                }
5150              }
5151              
5152              ## Step 4
5153              $node_i--;
5154              $node = $self->{open_elements}->[$node_i];
5155              
5156              ## Step 5;
5157              redo S2;
5158            } # S2
5159            redo B;
5160        }        }
5161      }      }
5162        redo B;
5163    } # B    } # B
5164    
5165      ## NOTE: The "trailing end" phase in HTML5 is split into
5166      ## two insertion modes: "after html body" and "after html frameset".
5167      ## NOTE: States in the main stage is preserved while
5168      ## the parser stays in the trailing end phase. # MUST
5169    
5170    ## Stop parsing # MUST    ## Stop parsing # MUST
5171        
5172    ## TODO: script stuffs    ## TODO: script stuffs
# Line 4935  sub set_inner_html ($$$) { Line 5200  sub set_inner_html ($$$) {
5200      ## NOTE: Most of this code is copied from |parse_string|      ## NOTE: Most of this code is copied from |parse_string|
5201    
5202      ## Step 1 # MUST      ## Step 1 # MUST
5203      my $doc = $node->owner_document->implementation->create_document;      my $this_doc = $node->owner_document;
5204      ## TODO: Mark as HTML document      my $doc = $this_doc->implementation->create_document;
5205        $doc->manakai_is_html (1);
5206      my $p = $class->new;      my $p = $class->new;
5207      $p->{document} = $doc;      $p->{document} = $doc;
5208    
# Line 4946  sub set_inner_html ($$$) { Line 5212  sub set_inner_html ($$$) {
5212      my $column = 0;      my $column = 0;
5213      $p->{set_next_input_character} = sub {      $p->{set_next_input_character} = sub {
5214        my $self = shift;        my $self = shift;
5215    
5216          pop @{$self->{prev_input_character}};
5217          unshift @{$self->{prev_input_character}}, $self->{next_input_character};
5218    
5219        $self->{next_input_character} = -1 and return if $i >= length $$s;        $self->{next_input_character} = -1 and return if $i >= length $$s;
5220        $self->{next_input_character} = ord substr $$s, $i++, 1;        $self->{next_input_character} = ord substr $$s, $i++, 1;
5221        $column++;        $column++;
# Line 4954  sub set_inner_html ($$$) { Line 5224  sub set_inner_html ($$$) {
5224          $line++;          $line++;
5225          $column = 0;          $column = 0;
5226        } elsif ($self->{next_input_character} == 0x000D) { # CR        } elsif ($self->{next_input_character} == 0x000D) { # CR
5227          if ($i >= length $$s) {          $i++ if substr ($$s, $i, 1) eq "\x0A";
           #  
         } else {  
           my $next_char = ord substr $$s, $i++, 1;  
           if ($next_char == 0x000A) { # LF  
             #  
           } else {  
             push @{$self->{char}}, $next_char;  
           }  
         }  
5228          $self->{next_input_character} = 0x000A; # LF # MUST          $self->{next_input_character} = 0x000A; # LF # MUST
5229          $line++;          $line++;
5230          $column = 0;          $column = 0;
5231        } elsif ($self->{next_input_character} > 0x10FFFF) {        } elsif ($self->{next_input_character} > 0x10FFFF) {
5232          $self->{next_input_character} = 0xFFFD; # REPLACEMENT CHARACTER # MUST          $self->{next_input_character} = 0xFFFD; # REPLACEMENT CHARACTER # MUST
5233        } elsif ($self->{next_input_character} == 0x0000) { # NULL        } elsif ($self->{next_input_character} == 0x0000) { # NULL
5234            !!!parse-error (type => 'NULL');
5235          $self->{next_input_character} = 0xFFFD; # REPLACEMENT CHARACTER # MUST          $self->{next_input_character} = 0xFFFD; # REPLACEMENT CHARACTER # MUST
5236        }        }
5237      };      };
5238        $p->{prev_input_character} = [-1, -1, -1];
5239        $p->{next_input_character} = -1;
5240            
5241      my $ponerror = $onerror || sub {      my $ponerror = $onerror || sub {
5242        my (%opt) = @_;        my (%opt) = @_;
# Line 4987  sub set_inner_html ($$$) { Line 5251  sub set_inner_html ($$$) {
5251    
5252      ## Step 2      ## Step 2
5253      my $node_ln = $node->local_name;      my $node_ln = $node->local_name;
5254      $p->{content_model_flag} = {      $p->{content_model} = {
5255        title => 'RCDATA',        title => RCDATA_CONTENT_MODEL,
5256        textarea => 'RCDATA',        textarea => RCDATA_CONTENT_MODEL,
5257        style => 'CDATA',        style => CDATA_CONTENT_MODEL,
5258        script => 'CDATA',        script => CDATA_CONTENT_MODEL,
5259        xmp => 'CDATA',        xmp => CDATA_CONTENT_MODEL,
5260        iframe => 'CDATA',        iframe => CDATA_CONTENT_MODEL,
5261        noembed => 'CDATA',        noembed => CDATA_CONTENT_MODEL,
5262        noframes => 'CDATA',        noframes => CDATA_CONTENT_MODEL,
5263        noscript => 'CDATA',        noscript => CDATA_CONTENT_MODEL,
5264        plaintext => 'PLAINTEXT',        plaintext => PLAINTEXT_CONTENT_MODEL,
5265      }->{$node_ln} || 'PCDATA';      }->{$node_ln};
5266         ## ISSUE: What is "the name of the element"? local name?      $p->{content_model} = PCDATA_CONTENT_MODEL
5267            unless defined $p->{content_model};
5268            ## ISSUE: What is "the name of the element"? local name?
5269    
5270      $p->{inner_html_node} = [$node, $node_ln];      $p->{inner_html_node} = [$node, $node_ln];
5271    
# Line 5051  sub set_inner_html ($$$) { Line 5317  sub set_inner_html ($$$) {
5317      ## Step 12 # MUST      ## Step 12 # MUST
5318      @cn = @{$root->child_nodes};      @cn = @{$root->child_nodes};
5319      for (@cn) {      for (@cn) {
5320          $this_doc->adopt_node ($_);
5321        $node->append_child ($_);        $node->append_child ($_);
5322      }      }
5323      ## ISSUE: adopt_node? mutation events?      ## ISSUE: mutation events?
5324    
5325      $p->_terminate_tree_constructor;      $p->_terminate_tree_constructor;
5326    } else {    } else {
# Line 5098  sub get_inner_html ($$$) { Line 5365  sub get_inner_html ($$$) {
5365            
5366      my $nt = $child->node_type;      my $nt = $child->node_type;
5367      if ($nt == 1) { # Element      if ($nt == 1) { # Element
5368        my $tag_name = lc $child->tag_name; ## ISSUE: Definition of "lowercase"        my $tag_name = $child->tag_name; ## TODO: manakai_tag_name
5369        $s .= '<' . $tag_name;        $s .= '<' . $tag_name;
5370          ## NOTE: Non-HTML case:
5371        ## ISSUE: Non-html elements        ## <http://permalink.gmane.org/gmane.org.w3c.whatwg.discuss/11191>
5372    
5373        my @attrs = @{$child->attributes}; # sort order MUST be stable        my @attrs = @{$child->attributes}; # sort order MUST be stable
5374        for my $attr (@attrs) { # order is implementation dependent        for my $attr (@attrs) { # order is implementation dependent
5375          my $attr_name = lc $attr->name; ## ISSUE: Definition of "lowercase"          my $attr_name = $attr->name; ## TODO: manakai_name
5376          $s .= ' ' . $attr_name . '="';          $s .= ' ' . $attr_name . '="';
5377          my $attr_value = $attr->value;          my $attr_value = $attr->value;
5378          ## escape          ## escape
# Line 5124  sub get_inner_html ($$$) { Line 5391  sub get_inner_html ($$$) {
5391          spacer => 1, wbr => 1,          spacer => 1, wbr => 1,
5392        }->{$tag_name};        }->{$tag_name};
5393    
5394          $s .= "\x0A" if $tag_name eq 'pre' or $tag_name eq 'textarea';
5395    
5396        if (not $in_cdata and {        if (not $in_cdata and {
5397          style => 1, script => 1, xmp => 1, iframe => 1,          style => 1, script => 1, xmp => 1, iframe => 1,
5398          noembed => 1, noframes => 1, noscript => 1,          noembed => 1, noframes => 1, noscript => 1,
5399            plaintext => 1,
5400        }->{$tag_name}) {        }->{$tag_name}) {
5401          unshift @node, 'cdata-out';          unshift @node, 'cdata-out';
5402          $in_cdata = 1;          $in_cdata = 1;
Legend:
Removed from v.1.13  
changed lines
  Added in v.1.57
admin@suikawiki.org
 ViewVC Help
Powered by ViewVC 1.1.24