/[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.44 by wakaba, Sat Jul 21 07:34:32 2007 UTC revision 1.55 by wakaba, Sat Aug 11 06:53:38 2007 UTC
# Line 159  sub CDATA_CONTENT_MODEL () { CM_LIMITED_ Line 159  sub CDATA_CONTENT_MODEL () { CM_LIMITED_
159  sub RCDATA_CONTENT_MODEL () { CM_ENTITY | CM_LIMITED_MARKUP }  sub RCDATA_CONTENT_MODEL () { CM_ENTITY | CM_LIMITED_MARKUP }
160  sub PCDATA_CONTENT_MODEL () { CM_ENTITY | CM_FULL_MARKUP }  sub PCDATA_CONTENT_MODEL () { CM_ENTITY | CM_FULL_MARKUP }
161    
162    sub DOCTYPE_TOKEN () { 1 }
163    sub COMMENT_TOKEN () { 2 }
164    sub START_TAG_TOKEN () { 3 }
165    sub END_TAG_TOKEN () { 4 }
166    sub END_OF_FILE_TOKEN () { 5 }
167    sub CHARACTER_TOKEN () { 6 }
168    
169    sub AFTER_HTML_IMS () { 0b100 }
170    sub HEAD_IMS ()       { 0b1000 }
171    sub BODY_IMS ()       { 0b10000 }
172    sub BODY_TABLE_IMS () { 0b100000 | BODY_IMS }
173    sub TABLE_IMS ()      { 0b1000000 }
174    sub ROW_IMS ()        { 0b10000000 | TABLE_IMS }
175    sub BODY_AFTER_IMS () { 0b100000000 }
176    sub FRAME_IMS ()      { 0b1000000000 }
177    
178    sub AFTER_HTML_BODY_IM () { AFTER_HTML_IMS | BODY_AFTER_IMS }
179    sub AFTER_HTML_FRAMESET_IM () { AFTER_HTML_IMS | FRAME_IMS }
180    sub IN_HEAD_IM () { HEAD_IMS | 0b00 }
181    sub IN_HEAD_NOSCRIPT_IM () { HEAD_IMS | 0b01 }
182    sub AFTER_HEAD_IM () { HEAD_IMS | 0b10 }
183    sub BEFORE_HEAD_IM () { HEAD_IMS | 0b11 }
184    sub IN_BODY_IM () { BODY_IMS }
185    sub IN_CELL_IM () { BODY_TABLE_IMS | 0b01 }
186    sub IN_CAPTION_IM () { BODY_TABLE_IMS | 0b10 }
187    sub IN_ROW_IM () { ROW_IMS | 0b01 }
188    sub IN_TABLE_BODY_IM () { ROW_IMS | 0b10 }
189    sub IN_TABLE_IM () { TABLE_IMS }
190    sub AFTER_BODY_IM () { BODY_AFTER_IMS }
191    sub IN_FRAMESET_IM () { FRAME_IMS | 0b01 }
192    sub AFTER_FRAMESET_IM () { FRAME_IMS | 0b10 }
193    sub IN_SELECT_IM () { 0b01 }
194    sub IN_COLUMN_GROUP_IM () { 0b10 }
195    
196  ## Implementations MUST act as if state machine in the spec  ## Implementations MUST act as if state machine in the spec
197    
198  sub _initialize_tokenizer ($) {  sub _initialize_tokenizer ($) {
# Line 177  sub _initialize_tokenizer ($) { Line 211  sub _initialize_tokenizer ($) {
211  } # _initialize_tokenizer  } # _initialize_tokenizer
212    
213  ## A token has:  ## A token has:
214  ##   ->{type} eq 'DOCTYPE', 'start tag', 'end tag', 'comment',  ##   ->{type} == DOCTYPE_TOKEN, START_TAG_TOKEN, END_TAG_TOKEN, COMMENT_TOKEN,
215  ##       'character', or 'end-of-file'  ##       CHARACTER_TOKEN, or END_OF_FILE_TOKEN
216  ##   ->{name} (DOCTYPE, start tag (tag name), end tag (tag name))  ##   ->{name} (DOCTYPE_TOKEN)
217  ##   ->{public_identifier} (DOCTYPE)  ##   ->{tag_name} (START_TAG_TOKEN, END_TAG_TOKEN)
218  ##   ->{system_identifier} (DOCTYPE)  ##   ->{public_identifier} (DOCTYPE_TOKEN)
219  ##   ->{correct} == 1 or 0 (DOCTYPE)  ##   ->{system_identifier} (DOCTYPE_TOKEN)
220  ##   ->{attributes} isa HASH (start tag, end tag)  ##   ->{correct} == 1 or 0 (DOCTYPE_TOKEN)
221  ##   ->{data} (comment, character)  ##   ->{attributes} isa HASH (START_TAG_TOKEN, END_TAG_TOKEN)
222    ##   ->{data} (COMMENT_TOKEN, CHARACTER_TOKEN)
223    
224  ## Emitted token MUST immediately be handled by the tree construction state.  ## Emitted token MUST immediately be handled by the tree construction state.
225    
# Line 243  sub _get_next_token ($) { Line 278  sub _get_next_token ($) {
278                    
279          #          #
280        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
281          !!!emit ({type => 'end-of-file'});          !!!emit ({type => END_OF_FILE_TOKEN});
282          last A; ## TODO: ok?          last A; ## TODO: ok?
283        }        }
284        # Anything else        # Anything else
285        my $token = {type => 'character',        my $token = {type => CHARACTER_TOKEN,
286                     data => chr $self->{next_input_character}};                     data => chr $self->{next_input_character}};
287        ## Stay in the data state        ## Stay in the data state
288        !!!next-input-character;        !!!next-input-character;
# Line 264  sub _get_next_token ($) { Line 299  sub _get_next_token ($) {
299        # next-input-character is already done        # next-input-character is already done
300    
301        unless (defined $token) {        unless (defined $token) {
302          !!!emit ({type => 'character', data => '&'});          !!!emit ({type => CHARACTER_TOKEN, data => '&'});
303        } else {        } else {
304          !!!emit ($token);          !!!emit ($token);
305        }        }
# Line 280  sub _get_next_token ($) { Line 315  sub _get_next_token ($) {
315            ## reconsume            ## reconsume
316            $self->{state} = 'data';            $self->{state} = 'data';
317    
318            !!!emit ({type => 'character', data => '<'});            !!!emit ({type => CHARACTER_TOKEN, data => '<'});
319    
320            redo A;            redo A;
321          }          }
# Line 296  sub _get_next_token ($) { Line 331  sub _get_next_token ($) {
331          } elsif (0x0041 <= $self->{next_input_character} and          } elsif (0x0041 <= $self->{next_input_character} and
332                   $self->{next_input_character} <= 0x005A) { # A..Z                   $self->{next_input_character} <= 0x005A) { # A..Z
333            $self->{current_token}            $self->{current_token}
334              = {type => 'start tag',              = {type => START_TAG_TOKEN,
335                 tag_name => chr ($self->{next_input_character} + 0x0020)};                 tag_name => chr ($self->{next_input_character} + 0x0020)};
336            $self->{state} = 'tag name';            $self->{state} = 'tag name';
337            !!!next-input-character;            !!!next-input-character;
338            redo A;            redo A;
339          } elsif (0x0061 <= $self->{next_input_character} and          } elsif (0x0061 <= $self->{next_input_character} and
340                   $self->{next_input_character} <= 0x007A) { # a..z                   $self->{next_input_character} <= 0x007A) { # a..z
341            $self->{current_token} = {type => 'start tag',            $self->{current_token} = {type => START_TAG_TOKEN,
342                              tag_name => chr ($self->{next_input_character})};                              tag_name => chr ($self->{next_input_character})};
343            $self->{state} = 'tag name';            $self->{state} = 'tag name';
344            !!!next-input-character;            !!!next-input-character;
# Line 313  sub _get_next_token ($) { Line 348  sub _get_next_token ($) {
348            $self->{state} = 'data';            $self->{state} = 'data';
349            !!!next-input-character;            !!!next-input-character;
350    
351            !!!emit ({type => 'character', data => '<>'});            !!!emit ({type => CHARACTER_TOKEN, data => '<>'});
352    
353            redo A;            redo A;
354          } elsif ($self->{next_input_character} == 0x003F) { # ?          } elsif ($self->{next_input_character} == 0x003F) { # ?
# Line 326  sub _get_next_token ($) { Line 361  sub _get_next_token ($) {
361            $self->{state} = 'data';            $self->{state} = 'data';
362            ## reconsume            ## reconsume
363    
364            !!!emit ({type => 'character', data => '<'});            !!!emit ({type => CHARACTER_TOKEN, data => '<'});
365    
366            redo A;            redo A;
367          }          }
# Line 350  sub _get_next_token ($) { Line 385  sub _get_next_token ($) {
385                !!!back-next-input-character (@next_char);                !!!back-next-input-character (@next_char);
386                $self->{state} = 'data';                $self->{state} = 'data';
387    
388                !!!emit ({type => 'character', data => '</'});                !!!emit ({type => CHARACTER_TOKEN, data => '</'});
389        
390                redo A;                redo A;
391              }              }
# Line 368  sub _get_next_token ($) { Line 403  sub _get_next_token ($) {
403              $self->{next_input_character} = shift @next_char; # reconsume              $self->{next_input_character} = shift @next_char; # reconsume
404              !!!back-next-input-character (@next_char);              !!!back-next-input-character (@next_char);
405              $self->{state} = 'data';              $self->{state} = 'data';
406              !!!emit ({type => 'character', data => '</'});              !!!emit ({type => CHARACTER_TOKEN, data => '</'});
407              redo A;              redo A;
408            } else {            } else {
409              $self->{next_input_character} = shift @next_char;              $self->{next_input_character} = shift @next_char;
# Line 379  sub _get_next_token ($) { Line 414  sub _get_next_token ($) {
414            ## No start tag token has ever been emitted            ## No start tag token has ever been emitted
415            # next-input-character is already done            # next-input-character is already done
416            $self->{state} = 'data';            $self->{state} = 'data';
417            !!!emit ({type => 'character', data => '</'});            !!!emit ({type => CHARACTER_TOKEN, data => '</'});
418            redo A;            redo A;
419          }          }
420        }        }
421                
422        if (0x0041 <= $self->{next_input_character} and        if (0x0041 <= $self->{next_input_character} and
423            $self->{next_input_character} <= 0x005A) { # A..Z            $self->{next_input_character} <= 0x005A) { # A..Z
424          $self->{current_token} = {type => 'end tag',          $self->{current_token} = {type => END_TAG_TOKEN,
425                            tag_name => chr ($self->{next_input_character} + 0x0020)};                            tag_name => chr ($self->{next_input_character} + 0x0020)};
426          $self->{state} = 'tag name';          $self->{state} = 'tag name';
427          !!!next-input-character;          !!!next-input-character;
428          redo A;          redo A;
429        } elsif (0x0061 <= $self->{next_input_character} and        } elsif (0x0061 <= $self->{next_input_character} and
430                 $self->{next_input_character} <= 0x007A) { # a..z                 $self->{next_input_character} <= 0x007A) { # a..z
431          $self->{current_token} = {type => 'end tag',          $self->{current_token} = {type => END_TAG_TOKEN,
432                            tag_name => chr ($self->{next_input_character})};                            tag_name => chr ($self->{next_input_character})};
433          $self->{state} = 'tag name';          $self->{state} = 'tag name';
434          !!!next-input-character;          !!!next-input-character;
# Line 408  sub _get_next_token ($) { Line 443  sub _get_next_token ($) {
443          $self->{state} = 'data';          $self->{state} = 'data';
444          # reconsume          # reconsume
445    
446          !!!emit ({type => 'character', data => '</'});          !!!emit ({type => CHARACTER_TOKEN, data => '</'});
447    
448          redo A;          redo A;
449        } else {        } else {
# Line 427  sub _get_next_token ($) { Line 462  sub _get_next_token ($) {
462          !!!next-input-character;          !!!next-input-character;
463          redo A;          redo A;
464        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
465          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
466            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
467                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
468            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
469          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
470            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
471            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
472              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 454  sub _get_next_token ($) { Line 489  sub _get_next_token ($) {
489          redo A;          redo A;
490        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
491          !!!parse-error (type => 'unclosed tag');          !!!parse-error (type => 'unclosed tag');
492          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
493            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
494                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
495            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
496          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
497            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
498            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
499              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 475  sub _get_next_token ($) { Line 510  sub _get_next_token ($) {
510        } elsif ($self->{next_input_character} == 0x002F) { # /        } elsif ($self->{next_input_character} == 0x002F) { # /
511          !!!next-input-character;          !!!next-input-character;
512          if ($self->{next_input_character} == 0x003E and # >          if ($self->{next_input_character} == 0x003E and # >
513              $self->{current_token}->{type} eq 'start tag' and              $self->{current_token}->{type} == START_TAG_TOKEN and
514              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
515            # permitted slash            # permitted slash
516            #            #
# Line 502  sub _get_next_token ($) { Line 537  sub _get_next_token ($) {
537          !!!next-input-character;          !!!next-input-character;
538          redo A;          redo A;
539        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
540          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
541            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
542                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
543            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
544          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
545            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
546            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
547              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 530  sub _get_next_token ($) { Line 565  sub _get_next_token ($) {
565        } elsif ($self->{next_input_character} == 0x002F) { # /        } elsif ($self->{next_input_character} == 0x002F) { # /
566          !!!next-input-character;          !!!next-input-character;
567          if ($self->{next_input_character} == 0x003E and # >          if ($self->{next_input_character} == 0x003E and # >
568              $self->{current_token}->{type} eq 'start tag' and              $self->{current_token}->{type} == START_TAG_TOKEN and
569              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
570            # permitted slash            # permitted slash
571            #            #
# Line 542  sub _get_next_token ($) { Line 577  sub _get_next_token ($) {
577          redo A;          redo A;
578        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
579          !!!parse-error (type => 'unclosed tag');          !!!parse-error (type => 'unclosed tag');
580          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
581            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
582                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
583            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
584          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
585            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
586            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
587              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 595  sub _get_next_token ($) { Line 630  sub _get_next_token ($) {
630          redo A;          redo A;
631        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
632          $before_leave->();          $before_leave->();
633          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
634            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
635                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
636            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
637          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
638            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
639            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
640              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 623  sub _get_next_token ($) { Line 658  sub _get_next_token ($) {
658          $before_leave->();          $before_leave->();
659          !!!next-input-character;          !!!next-input-character;
660          if ($self->{next_input_character} == 0x003E and # >          if ($self->{next_input_character} == 0x003E and # >
661              $self->{current_token}->{type} eq 'start tag' and              $self->{current_token}->{type} == START_TAG_TOKEN and
662              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
663            # permitted slash            # permitted slash
664            #            #
# Line 636  sub _get_next_token ($) { Line 671  sub _get_next_token ($) {
671        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
672          !!!parse-error (type => 'unclosed tag');          !!!parse-error (type => 'unclosed tag');
673          $before_leave->();          $before_leave->();
674          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
675            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
676                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
677            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
678          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
679            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
680            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
681              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 674  sub _get_next_token ($) { Line 709  sub _get_next_token ($) {
709          !!!next-input-character;          !!!next-input-character;
710          redo A;          redo A;
711        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
712          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
713            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
714                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
715            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
716          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
717            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
718            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
719              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 702  sub _get_next_token ($) { Line 737  sub _get_next_token ($) {
737        } elsif ($self->{next_input_character} == 0x002F) { # /        } elsif ($self->{next_input_character} == 0x002F) { # /
738          !!!next-input-character;          !!!next-input-character;
739          if ($self->{next_input_character} == 0x003E and # >          if ($self->{next_input_character} == 0x003E and # >
740              $self->{current_token}->{type} eq 'start tag' and              $self->{current_token}->{type} == START_TAG_TOKEN and
741              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
742            # permitted slash            # permitted slash
743            #            #
# Line 715  sub _get_next_token ($) { Line 750  sub _get_next_token ($) {
750          redo A;          redo A;
751        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
752          !!!parse-error (type => 'unclosed tag');          !!!parse-error (type => 'unclosed tag');
753          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
754            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
755                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
756            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
757          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
758            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
759            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
760              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 762  sub _get_next_token ($) { Line 797  sub _get_next_token ($) {
797          !!!next-input-character;          !!!next-input-character;
798          redo A;          redo A;
799        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
800          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
801            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
802                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
803            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
804          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
805            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
806            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
807              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 782  sub _get_next_token ($) { Line 817  sub _get_next_token ($) {
817          redo A;          redo A;
818        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
819          !!!parse-error (type => 'unclosed tag');          !!!parse-error (type => 'unclosed tag');
820          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
821            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
822                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
823            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
824          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
825            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
826            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
827              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 818  sub _get_next_token ($) { Line 853  sub _get_next_token ($) {
853          redo A;          redo A;
854        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
855          !!!parse-error (type => 'unclosed attribute value');          !!!parse-error (type => 'unclosed attribute value');
856          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
857            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
858                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
859            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
860          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
861            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
862            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
863              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 854  sub _get_next_token ($) { Line 889  sub _get_next_token ($) {
889          redo A;          redo A;
890        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
891          !!!parse-error (type => 'unclosed attribute value');          !!!parse-error (type => 'unclosed attribute value');
892          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
893            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
894                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
895            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
896          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
897            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
898            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
899              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 893  sub _get_next_token ($) { Line 928  sub _get_next_token ($) {
928          !!!next-input-character;          !!!next-input-character;
929          redo A;          redo A;
930        } elsif ($self->{next_input_character} == 0x003E) { # >        } elsif ($self->{next_input_character} == 0x003E) { # >
931          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
932            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
933                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
934            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
935          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
936            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
937            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
938              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 913  sub _get_next_token ($) { Line 948  sub _get_next_token ($) {
948          redo A;          redo A;
949        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
950          !!!parse-error (type => 'unclosed tag');          !!!parse-error (type => 'unclosed tag');
951          if ($self->{current_token}->{type} eq 'start tag') {          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
952            $self->{current_token}->{first_start_tag}            $self->{current_token}->{first_start_tag}
953                = not defined $self->{last_emitted_start_tag_name};                = not defined $self->{last_emitted_start_tag_name};
954            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
955          } elsif ($self->{current_token}->{type} eq 'end tag') {          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
956            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
957            if ($self->{current_token}->{attributes}) {            if ($self->{current_token}->{attributes}) {
958              !!!parse-error (type => 'end tag attribute');              !!!parse-error (type => 'end tag attribute');
# Line 953  sub _get_next_token ($) { Line 988  sub _get_next_token ($) {
988      } elsif ($self->{state} eq 'bogus comment') {      } elsif ($self->{state} eq 'bogus comment') {
989        ## (only happen if PCDATA state)        ## (only happen if PCDATA state)
990                
991        my $token = {type => 'comment', data => ''};        my $token = {type => COMMENT_TOKEN, data => ''};
992    
993        BC: {        BC: {
994          if ($self->{next_input_character} == 0x003E) { # >          if ($self->{next_input_character} == 0x003E) { # >
# Line 986  sub _get_next_token ($) { Line 1021  sub _get_next_token ($) {
1021          !!!next-input-character;          !!!next-input-character;
1022          push @next_char, $self->{next_input_character};          push @next_char, $self->{next_input_character};
1023          if ($self->{next_input_character} == 0x002D) { # -          if ($self->{next_input_character} == 0x002D) { # -
1024            $self->{current_token} = {type => 'comment', data => ''};            $self->{current_token} = {type => COMMENT_TOKEN, data => ''};
1025            $self->{state} = 'comment start';            $self->{state} = 'comment start';
1026            !!!next-input-character;            !!!next-input-character;
1027            redo A;            redo A;
# Line 1189  sub _get_next_token ($) { Line 1224  sub _get_next_token ($) {
1224          $self->{state} = 'data';          $self->{state} = 'data';
1225          !!!next-input-character;          !!!next-input-character;
1226    
1227          !!!emit ({type => 'DOCTYPE'}); # incorrect          !!!emit ({type => DOCTYPE_TOKEN}); # incorrect
1228    
1229          redo A;          redo A;
1230        } elsif ($self->{next_input_character} == -1) {        } elsif ($self->{next_input_character} == -1) {
# Line 1197  sub _get_next_token ($) { Line 1232  sub _get_next_token ($) {
1232          $self->{state} = 'data';          $self->{state} = 'data';
1233          ## reconsume          ## reconsume
1234    
1235          !!!emit ({type => 'DOCTYPE'}); # incorrect          !!!emit ({type => DOCTYPE_TOKEN}); # incorrect
1236    
1237          redo A;          redo A;
1238        } else {        } else {
1239          $self->{current_token}          $self->{current_token}
1240              = {type => 'DOCTYPE',              = {type => DOCTYPE_TOKEN,
1241                 name => chr ($self->{next_input_character}),                 name => chr ($self->{next_input_character}),
1242                 correct => 1};                 correct => 1};
1243  ## ISSUE: "Set the token's name name to the" in the spec  ## ISSUE: "Set the token's name name to the" in the spec
# Line 1670  sub _tokenize_attempt_to_consume_an_enti Line 1705  sub _tokenize_attempt_to_consume_an_enti
1705            $code = $c1_entity_char->{$code};            $code = $c1_entity_char->{$code};
1706          }          }
1707    
1708          return {type => 'character', data => chr $code};          return {type => CHARACTER_TOKEN, data => chr $code};
1709        } # X        } # X
1710      } elsif (0x0030 <= $self->{next_input_character} and      } elsif (0x0030 <= $self->{next_input_character} and
1711               $self->{next_input_character} <= 0x0039) { # 0..9               $self->{next_input_character} <= 0x0039) { # 0..9
# Line 1705  sub _tokenize_attempt_to_consume_an_enti Line 1740  sub _tokenize_attempt_to_consume_an_enti
1740          $code = $c1_entity_char->{$code};          $code = $c1_entity_char->{$code};
1741        }        }
1742                
1743        return {type => 'character', data => chr $code};        return {type => CHARACTER_TOKEN, data => chr $code};
1744      } else {      } else {
1745        !!!parse-error (type => 'bare nero');        !!!parse-error (type => 'bare nero');
1746        !!!back-next-input-character ($self->{next_input_character});        !!!back-next-input-character ($self->{next_input_character});
# Line 1753  sub _tokenize_attempt_to_consume_an_enti Line 1788  sub _tokenize_attempt_to_consume_an_enti
1788      }      }
1789            
1790      if ($match > 0) {      if ($match > 0) {
1791        return {type => 'character', data => $value};        return {type => CHARACTER_TOKEN, data => $value};
1792      } elsif ($match < 0) {      } elsif ($match < 0) {
1793        !!!parse-error (type => 'no refc');        !!!parse-error (type => 'no refc');
1794        if ($in_attr and $match < -1) {        if ($in_attr and $match < -1) {
1795          return {type => 'character', data => '&'.$entity_name};          return {type => CHARACTER_TOKEN, data => '&'.$entity_name};
1796        } else {        } else {
1797          return {type => 'character', data => $value};          return {type => CHARACTER_TOKEN, data => $value};
1798        }        }
1799      } else {      } else {
1800        !!!parse-error (type => 'bare ero');        !!!parse-error (type => 'bare ero');
1801        ## NOTE: No characters are consumed in the spec.        ## NOTE: No characters are consumed in the spec.
1802        return {type => 'character', data => '&'.$value};        return {type => CHARACTER_TOKEN, data => '&'.$value};
1803      }      }
1804    } else {    } else {
1805      ## no characters are consumed      ## no characters are consumed
# Line 1806  sub _construct_tree ($) { Line 1841  sub _construct_tree ($) {
1841        
1842    !!!next-token;    !!!next-token;
1843    
1844    $self->{insertion_mode} = 'before head';    $self->{insertion_mode} = BEFORE_HEAD_IM;
1845    undef $self->{form_element};    undef $self->{form_element};
1846    undef $self->{head_element};    undef $self->{head_element};
1847    $self->{open_elements} = [];    $self->{open_elements} = [];
# Line 1820  sub _construct_tree ($) { Line 1855  sub _construct_tree ($) {
1855  sub _tree_construction_initial ($) {  sub _tree_construction_initial ($) {
1856    my $self = shift;    my $self = shift;
1857    INITIAL: {    INITIAL: {
1858      if ($token->{type} eq 'DOCTYPE') {      if ($token->{type} == DOCTYPE_TOKEN) {
1859        ## NOTE: Conformance checkers MAY, instead of reporting "not HTML5"        ## NOTE: Conformance checkers MAY, instead of reporting "not HTML5"
1860        ## error, switch to a conformance checking mode for another        ## error, switch to a conformance checking mode for another
1861        ## language.        ## language.
# Line 1947  sub _tree_construction_initial ($) { Line 1982  sub _tree_construction_initial ($) {
1982        !!!next-token;        !!!next-token;
1983        return;        return;
1984      } elsif ({      } elsif ({
1985                'start tag' => 1,                START_TAG_TOKEN, 1,
1986                'end tag' => 1,                END_TAG_TOKEN, 1,
1987                'end-of-file' => 1,                END_OF_FILE_TOKEN, 1,
1988               }->{$token->{type}}) {               }->{$token->{type}}) {
1989        !!!parse-error (type => 'no DOCTYPE');        !!!parse-error (type => 'no DOCTYPE');
1990        $self->{document}->manakai_compat_mode ('quirks');        $self->{document}->manakai_compat_mode ('quirks');
1991        ## Go to the root element phase        ## Go to the root element phase
1992        ## reprocess        ## reprocess
1993        return;        return;
1994      } elsif ($token->{type} eq 'character') {      } elsif ($token->{type} == CHARACTER_TOKEN) {
1995        if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D        if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D
1996          ## Ignore the token          ## Ignore the token
1997    
# Line 1972  sub _tree_construction_initial ($) { Line 2007  sub _tree_construction_initial ($) {
2007        ## Go to the root element phase        ## Go to the root element phase
2008        ## reprocess        ## reprocess
2009        return;        return;
2010      } elsif ($token->{type} eq 'comment') {      } elsif ($token->{type} == COMMENT_TOKEN) {
2011        my $comment = $self->{document}->create_comment ($token->{data});        my $comment = $self->{document}->create_comment ($token->{data});
2012        $self->{document}->append_child ($comment);        $self->{document}->append_child ($comment);
2013                
# Line 1980  sub _tree_construction_initial ($) { Line 2015  sub _tree_construction_initial ($) {
2015        !!!next-token;        !!!next-token;
2016        redo INITIAL;        redo INITIAL;
2017      } else {      } else {
2018        die "$0: $token->{type}: Unknown token";        die "$0: $token->{type}: Unknown token type";
2019      }      }
2020    } # INITIAL    } # INITIAL
2021  } # _tree_construction_initial  } # _tree_construction_initial
# Line 1989  sub _tree_construction_root_element ($) Line 2024  sub _tree_construction_root_element ($)
2024    my $self = shift;    my $self = shift;
2025        
2026    B: {    B: {
2027        if ($token->{type} eq 'DOCTYPE') {        if ($token->{type} == DOCTYPE_TOKEN) {
2028          !!!parse-error (type => 'in html:#DOCTYPE');          !!!parse-error (type => 'in html:#DOCTYPE');
2029          ## Ignore the token          ## Ignore the token
2030          ## Stay in the phase          ## Stay in the phase
2031          !!!next-token;          !!!next-token;
2032          redo B;          redo B;
2033        } elsif ($token->{type} eq 'comment') {        } elsif ($token->{type} == COMMENT_TOKEN) {
2034          my $comment = $self->{document}->create_comment ($token->{data});          my $comment = $self->{document}->create_comment ($token->{data});
2035          $self->{document}->append_child ($comment);          $self->{document}->append_child ($comment);
2036          ## Stay in the phase          ## Stay in the phase
2037          !!!next-token;          !!!next-token;
2038          redo B;          redo B;
2039        } elsif ($token->{type} eq 'character') {        } elsif ($token->{type} == CHARACTER_TOKEN) {
2040          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D
2041            ## Ignore the token.            ## Ignore the token.
2042    
# Line 2013  sub _tree_construction_root_element ($) Line 2048  sub _tree_construction_root_element ($)
2048          }          }
2049          #          #
2050        } elsif ({        } elsif ({
2051                  'start tag' => 1,                  START_TAG_TOKEN, 1,
2052                  'end tag' => 1,                  END_TAG_TOKEN, 1,
2053                  'end-of-file' => 1,                  END_OF_FILE_TOKEN, 1,
2054                 }->{$token->{type}}) {                 }->{$token->{type}}) {
2055          ## ISSUE: There is an issue in the spec          ## ISSUE: There is an issue in the spec
2056          #          #
2057        } else {        } else {
2058          die "$0: $token->{type}: Unknown token";          die "$0: $token->{type}: Unknown token type";
2059        }        }
2060        my $root_element; !!!create-element ($root_element, 'html');        my $root_element; !!!create-element ($root_element, 'html');
2061        $self->{document}->append_child ($root_element);        $self->{document}->append_child ($root_element);
# Line 2062  sub _reset_insertion_mode ($) { Line 2097  sub _reset_insertion_mode ($) {
2097            
2098        ## Step 4..13        ## Step 4..13
2099        my $new_mode = {        my $new_mode = {
2100                        select => 'in select',                        select => IN_SELECT_IM,
2101                        td => 'in cell',                        td => IN_CELL_IM,
2102                        th => 'in cell',                        th => IN_CELL_IM,
2103                        tr => 'in row',                        tr => IN_ROW_IM,
2104                        tbody => 'in table body',                        tbody => IN_TABLE_BODY_IM,
2105                        thead => 'in table head',                        thead => IN_TABLE_BODY_IM,
2106                        tfoot => 'in table foot',                        tfoot => IN_TABLE_BODY_IM,
2107                        caption => 'in caption',                        caption => IN_CAPTION_IM,
2108                        colgroup => 'in column group',                        colgroup => IN_COLUMN_GROUP_IM,
2109                        table => 'in table',                        table => IN_TABLE_IM,
2110                        head => 'in body', # not in head!                        head => IN_BODY_IM, # not in head!
2111                        body => 'in body',                        body => IN_BODY_IM,
2112                        frameset => 'in frameset',                        frameset => IN_FRAMESET_IM,
2113                       }->{$node->[1]};                       }->{$node->[1]};
2114        $self->{insertion_mode} = $new_mode and return if defined $new_mode;        $self->{insertion_mode} = $new_mode and return if defined $new_mode;
2115                
2116        ## Step 14        ## Step 14
2117        if ($node->[1] eq 'html') {        if ($node->[1] eq 'html') {
2118          unless (defined $self->{head_element}) {          unless (defined $self->{head_element}) {
2119            $self->{insertion_mode} = 'before head';            $self->{insertion_mode} = BEFORE_HEAD_IM;
2120          } else {          } else {
2121            $self->{insertion_mode} = 'after head';            $self->{insertion_mode} = AFTER_HEAD_IM;
2122          }          }
2123          return;          return;
2124        }        }
2125                
2126        ## Step 15        ## Step 15
2127        $self->{insertion_mode} = 'in body' and return if $last;        $self->{insertion_mode} = IN_BODY_IM and return if $last;
2128                
2129        ## Step 16        ## Step 16
2130        $i--;        $i--;
# Line 2103  sub _reset_insertion_mode ($) { Line 2138  sub _reset_insertion_mode ($) {
2138  sub _tree_construction_main ($) {  sub _tree_construction_main ($) {
2139    my $self = shift;    my $self = shift;
2140    
   my $previous_insertion_mode;  
   
2141    my $active_formatting_elements = [];    my $active_formatting_elements = [];
2142    
2143    my $reconstruct_active_formatting_elements = sub { # MUST    my $reconstruct_active_formatting_elements = sub { # MUST
# Line 2205  sub _tree_construction_main ($) { Line 2238  sub _tree_construction_main ($) {
2238      ## Step 4      ## Step 4
2239      my $text = '';      my $text = '';
2240      !!!next-token;      !!!next-token;
2241      while ($token->{type} eq 'character') { # or until stop tokenizing      while ($token->{type} == CHARACTER_TOKEN) { # or until stop tokenizing
2242        $text .= $token->{data};        $text .= $token->{data};
2243        !!!next-token;        !!!next-token;
2244      }      }
# Line 2220  sub _tree_construction_main ($) { Line 2253  sub _tree_construction_main ($) {
2253      $self->{content_model} = PCDATA_CONTENT_MODEL;      $self->{content_model} = PCDATA_CONTENT_MODEL;
2254    
2255      ## Step 7      ## Step 7
2256      if ($token->{type} eq 'end tag' and $token->{tag_name} eq $start_tag_name) {      if ($token->{type} == END_TAG_TOKEN and $token->{tag_name} eq $start_tag_name) {
2257        ## Ignore the token        ## Ignore the token
2258      } elsif ($content_model_flag == CDATA_CONTENT_MODEL) {      } elsif ($content_model_flag == CDATA_CONTENT_MODEL) {
2259        !!!parse-error (type => 'in CDATA:#'.$token->{type});        !!!parse-error (type => 'in CDATA:#'.$token->{type});
# Line 2243  sub _tree_construction_main ($) { Line 2276  sub _tree_construction_main ($) {
2276            
2277      my $text = '';      my $text = '';
2278      !!!next-token;      !!!next-token;
2279      while ($token->{type} eq 'character') {      while ($token->{type} == CHARACTER_TOKEN) {
2280        $text .= $token->{data};        $text .= $token->{data};
2281        !!!next-token;        !!!next-token;
2282      } # stop if non-character token or tokenizer stops tokenising      } # stop if non-character token or tokenizer stops tokenising
# Line 2253  sub _tree_construction_main ($) { Line 2286  sub _tree_construction_main ($) {
2286                                
2287      $self->{content_model} = PCDATA_CONTENT_MODEL;      $self->{content_model} = PCDATA_CONTENT_MODEL;
2288    
2289      if ($token->{type} eq 'end tag' and      if ($token->{type} == END_TAG_TOKEN and
2290          $token->{tag_name} eq 'script') {          $token->{tag_name} eq 'script') {
2291        ## Ignore the token        ## Ignore the token
2292      } else {      } else {
# Line 2496  sub _tree_construction_main ($) { Line 2529  sub _tree_construction_main ($) {
2529                         }                         }
2530    }; # $insert_to_foster    }; # $insert_to_foster
2531    
2532    my $in_body = sub {    my $insert;
     my $insert = shift;  
     if ($token->{type} eq 'start tag') {  
       if ($token->{tag_name} eq 'script') {  
         ## NOTE: This is an "as if in head" code clone  
         $script_start_tag->($insert);  
         return;  
       } elsif ($token->{tag_name} eq 'style') {  
         ## NOTE: This is an "as if in head" code clone  
         $parse_rcdata->(CDATA_CONTENT_MODEL, $insert);  
         return;  
       } elsif ({  
                 base => 1, link => 1,  
                }->{$token->{tag_name}}) {  
         ## NOTE: This is an "as if in head" code clone, only "-t" differs  
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
         pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.  
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'meta') {  
         ## NOTE: This is an "as if in head" code clone, only "-t" differs  
         !!!insert-element-t ($token->{tag_name}, $token->{attributes});  
         pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.  
   
         unless ($self->{confident}) {  
           my $charset;  
           if ($token->{attributes}->{charset}) { ## TODO: And if supported  
             $charset = $token->{attributes}->{charset}->{value};  
           }  
           if ($token->{attributes}->{'http-equiv'}) {  
             ## ISSUE: Algorithm name in the spec was incorrect so that not linked to the definition.  
             if ($token->{attributes}->{'http-equiv'}->{value}  
                 =~ /\A[^;]*;[\x09-\x0D\x20]*charset[\x09-\x0D\x20]*=  
                     [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'|  
                     ([^"'\x09-\x0D\x20][^\x09-\x0D\x20]*))/x) {  
               $charset = defined $1 ? $1 : defined $2 ? $2 : $3;  
             } ## TODO: And if supported  
           }  
           ## TODO: Change the encoding  
         }  
   
         !!!next-token;  
         return;  
       } elsif ($token->{tag_name} eq 'title') {  
         !!!parse-error (type => 'in body:title');  
         ## NOTE: This is an "as if in head" code clone  
         $parse_rcdata->(RCDATA_CONTENT_MODEL, sub {  
           if (defined $self->{head_element}) {  
             $self->{head_element}->append_child ($_[0]);  
           } else {  
             $insert->($_[0]);  
           }  
         });  
         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]);  
             }  
             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]);  
             }  
             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} = PLAINTEXT_CONTENT_MODEL;  
             
         !!!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  
             
         ## NOTE: See <http://html5.org/tools/web-apps-tracker?from=925&to=926>  
         ## 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,  
                 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 'nobr') {  
         $reconstruct_active_formatting_elements->($insert_to_current);  
   
         ## has a |nobr| element in scope  
         INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
           my $node = $self->{open_elements}->[$_];  
           if ($node->[1] eq 'nobr') {  
             !!!parse-error (type => 'not closed:nobr');  
             !!!back-token;  
             $token = {type => 'end tag', tag_name => 'nobr'};  
             return;  
           } elsif ({  
                     table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$node->[1]}) {  
             last INSCOPE;  
           }  
         } # INSCOPE  
           
         !!!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);  
         $parse_rcdata->(CDATA_CONTENT_MODEL, $insert);  
         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';  
         }  
   
         ## NOTE: There is an "as if <br>" code clone.  
         $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};  
           my $form_attrs;  
           $form_attrs->{action} = $at->{action} if $at->{action};  
           my $prompt_attr = $at->{prompt};  
           $at->{name} = {name => 'name', value => 'isindex'};  
           delete $at->{action};  
           delete $at->{prompt};  
           my @tokens = (  
                         {type => 'start tag', tag_name => 'form',  
                          attributes => $form_attrs},  
                         {type => 'start tag', tag_name => 'hr'},  
                         {type => 'start tag', tag_name => 'p'},  
                         {type => 'start tag', tag_name => 'label'},  
                        );  
           if ($prompt_attr) {  
             push @tokens, {type => 'character', data => $prompt_attr->{value}};  
           } else {  
             push @tokens, {type => 'character',  
                            data => 'This is a searchable index. Insert your search keywords here: '}; # SHOULD  
             ## TODO: make this configurable  
           }  
           push @tokens,  
                         {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 ($token->{tag_name} eq 'textarea') {  
         my $tag_name = $token->{tag_name};  
         my $el;  
         !!!create-element ($el, $token->{tag_name}, $token->{attributes});  
           
         ## TODO: $self->{form_element} if defined  
         $self->{content_model} = RCDATA_CONTENT_MODEL;  
         delete $self->{escape}; # MUST  
           
         $insert->($el);  
           
         my $text = '';  
         !!!next-token;  
         if ($token->{type} eq 'character') {  
           $token->{data} =~ s/^\x0A//;  
           unless (length $token->{data}) {  
             !!!next-token;  
           }  
         }  
         while ($token->{type} eq 'character') {  
           $text .= $token->{data};  
           !!!next-token;  
         }  
         if (length $text) {  
           $el->manakai_append_text ($text);  
         }  
           
         $self->{content_model} = PCDATA_CONTENT_MODEL;  
           
         if ($token->{type} eq 'end tag' and  
             $token->{tag_name} eq $tag_name) {  
           ## Ignore the token  
         } else {  
           !!!parse-error (type => 'in RCDATA:#'.$token->{type});  
         }  
         !!!next-token;  
         return;  
       } elsif ({  
                 iframe => 1,  
                 noembed => 1,  
                 noframes => 1,  
                 noscript => 0, ## TODO: 1 if scripting is enabled  
                }->{$token->{tag_name}}) {  
         ## NOTE: There are two "as if in body" code clones.  
         $parse_rcdata->(CDATA_CONTENT_MODEL, $insert);  
         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') {  
           for (@{$self->{open_elements}}) {  
             unless ({  
                        dd => 1, dt => 1, li => 1, p => 1, td => 1,  
                        th => 1, tr => 1, body => 1, html => 1,  
                      tbody => 1, tfoot => 1, thead => 1,  
                     }->{$_->[1]}) {  
               !!!parse-error (type => 'not closed:'.$_->[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,  
                  tbody => 1, tfoot=> 1, thead => 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}) {  
           if (defined $i) {  
             !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);  
           } else {  
             !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
           }  
         }  
           
         if (defined $i) {  
           splice @{$self->{open_elements}}, $i;  
         } elsif ($token->{tag_name} eq 'p') {  
           ## As if <p>, then reprocess the current token  
           my $el;  
           !!!create-element ($el, 'p');  
           $insert->($el);  
         }  
         $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,  
                  tbody => 1, tfoot=> 1, thead => 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,  
                  tbody => 1, tfoot=> 1, thead => 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});  
         return;  
       } elsif ($token->{tag_name} eq 'br') {  
         !!!parse-error (type => 'unmatched end tag:br');  
   
         ## As if <br>  
         $reconstruct_active_formatting_elements->($insert_to_current);  
           
         my $el;  
         !!!create-element ($el, 'br');  
         $insert->($el);  
           
         ## Ignore the token.  
         !!!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,  
                 area => 1, basefont => 1, bgsound => 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,  
                  tbody => 1, tfoot=> 1, thead => 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 => 'unmatched end tag:'.$token->{tag_name});  
               ## 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  
2533    
2534    B: {    B: {
2535      if ($token->{type} eq 'DOCTYPE') {      if ($token->{type} == DOCTYPE_TOKEN) {
2536        !!!parse-error (type => 'DOCTYPE in the middle');        !!!parse-error (type => 'DOCTYPE in the middle');
2537        ## Ignore the token        ## Ignore the token
2538        ## Stay in the phase        ## Stay in the phase
2539        !!!next-token;        !!!next-token;
2540        redo B;        redo B;
2541      } elsif ($token->{type} eq 'end-of-file') {      } elsif ($token->{type} == END_OF_FILE_TOKEN) {
2542        if ($token->{insertion_mode} ne 'trailing end') {        if ($self->{insertion_mode} == AFTER_HTML_BODY_IM or
2543              $self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
2544            #
2545          } else {
2546          ## Generate implied end tags          ## Generate implied end tags
2547          if ({          if ({
2548               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,
2549               tbody => 1, tfoot=> 1, thead => 1,               tbody => 1, tfoot=> 1, thead => 1,
2550              }->{$self->{open_elements}->[-1]->[1]}) {              }->{$self->{open_elements}->[-1]->[1]}) {
2551            !!!back-token;            !!!back-token;
2552            $token = {type => 'end tag', tag_name => $self->{open_elements}->[-1]->[1]};            $token = {type => END_TAG_TOKEN, tag_name => $self->{open_elements}->[-1]->[1]};
2553            redo B;            redo B;
2554          }          }
2555                    
# Line 3375  sub _tree_construction_main ($) { Line 2567  sub _tree_construction_main ($) {
2567    
2568        ## Stop parsing        ## Stop parsing
2569        last B;        last B;
2570      } elsif ($token->{type} eq 'start tag' and      } elsif ($token->{type} == START_TAG_TOKEN and
2571               $token->{tag_name} eq 'html') {               $token->{tag_name} eq 'html') {
2572        if ($self->{insertion_mode} eq 'trailing end') {        if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
2573          ## Turn into the main phase          ## Turn into the main phase
2574          !!!parse-error (type => 'after html:html');          !!!parse-error (type => 'after html:html');
2575          $self->{insertion_mode} = $previous_insertion_mode;          $self->{insertion_mode} = AFTER_BODY_IM;
2576          } elsif ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
2577            ## Turn into the main phase
2578            !!!parse-error (type => 'after html:html');
2579            $self->{insertion_mode} = AFTER_FRAMESET_IM;
2580        }        }
2581    
2582  ## ISSUE: "aa<html>" is not a parse error.  ## ISSUE: "aa<html>" is not a parse error.
# Line 3398  sub _tree_construction_main ($) { Line 2594  sub _tree_construction_main ($) {
2594        }        }
2595        !!!next-token;        !!!next-token;
2596        redo B;        redo B;
2597      } elsif ($token->{type} eq 'comment') {      } elsif ($token->{type} == COMMENT_TOKEN) {
2598        my $comment = $self->{document}->create_comment ($token->{data});        my $comment = $self->{document}->create_comment ($token->{data});
2599        if ($self->{insertion_mode} eq 'trailing end') {        if ($self->{insertion_mode} == AFTER_HTML_BODY_IM or
2600              $self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
2601          $self->{document}->append_child ($comment);          $self->{document}->append_child ($comment);
2602        } elsif ($self->{insertion_mode} eq 'after body') {        } elsif ($self->{insertion_mode} == AFTER_BODY_IM) {
2603          $self->{open_elements}->[0]->[0]->append_child ($comment);          $self->{open_elements}->[0]->[0]->append_child ($comment);
2604        } else {        } else {
2605          $self->{open_elements}->[-1]->[0]->append_child ($comment);          $self->{open_elements}->[-1]->[0]->append_child ($comment);
2606        }        }
2607        !!!next-token;        !!!next-token;
2608        redo B;        redo B;
2609      } elsif ($self->{insertion_mode} eq 'before head') {      } elsif ($self->{insertion_mode} == IN_HEAD_IM or
2610            if ($token->{type} eq 'character') {               $self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM or
2611              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {               $self->{insertion_mode} == AFTER_HEAD_IM or
2612                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);               $self->{insertion_mode} == BEFORE_HEAD_IM) {
2613                unless (length $token->{data}) {        if ($token->{type} == CHARACTER_TOKEN) {
2614                  !!!next-token;          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
2615                  redo B;            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
2616                }            unless (length $token->{data}) {
2617              }              !!!next-token;
2618              ## As if <head>              redo B;
2619              !!!create-element ($self->{head_element}, 'head');            }
2620              $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});          }
2621              push @{$self->{open_elements}}, [$self->{head_element}, 'head'];  
2622              $self->{insertion_mode} = 'in head';          if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2623              ## As if <head>
2624              !!!create-element ($self->{head_element}, 'head');
2625              $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2626              push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2627    
2628              ## Reprocess in the "in head" insertion mode...
2629              pop @{$self->{open_elements}};
2630    
2631              ## Reprocess in the "after head" insertion mode...
2632            } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2633              ## As if </noscript>
2634              pop @{$self->{open_elements}};
2635              !!!parse-error (type => 'in noscript:#character');
2636              
2637              ## Reprocess in the "in head" insertion mode...
2638              ## As if </head>
2639              pop @{$self->{open_elements}};
2640    
2641              ## Reprocess in the "after head" insertion mode...
2642            } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2643              pop @{$self->{open_elements}};
2644    
2645              ## Reprocess in the "after head" insertion mode...
2646            }
2647    
2648                ## "after head" insertion mode
2649                ## As if <body>
2650                !!!insert-element ('body');
2651                $self->{insertion_mode} = IN_BODY_IM;
2652              ## reprocess              ## reprocess
2653              redo B;              redo B;
2654            } elsif ($token->{type} eq 'start tag') {            } elsif ($token->{type} == START_TAG_TOKEN) {
             my $attr = $token->{tag_name} eq 'head' ? $token->{attributes} : {};  
             !!!create-element ($self->{head_element}, 'head', $attr);  
             $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});  
             push @{$self->{open_elements}}, [$self->{head_element}, 'head'];  
             $self->{insertion_mode} = 'in head';  
2655              if ($token->{tag_name} eq 'head') {              if ($token->{tag_name} eq 'head') {
2656                !!!next-token;                if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2657              #} elsif ({                  !!!create-element ($self->{head_element}, $token->{tag_name}, $token->{attributes});
2658              #          base => 1, link => 1, meta => 1,                  $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2659              #          script => 1, style => 1, title => 1,                  push @{$self->{open_elements}}, [$self->{head_element}, $token->{tag_name}];
2660              #         }->{$token->{tag_name}}) {                  $self->{insertion_mode} = IN_HEAD_IM;
2661              #  ## reprocess                  !!!next-token;
2662              } else {                  redo B;
2663                ## reprocess                } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2664              }                  #
2665              redo B;                } else {
2666            } elsif ($token->{type} eq 'end tag') {                  !!!parse-error (type => 'in head:head'); # or in head noscript
2667              if ({                  ## Ignore the token
2668                   head => 1, body => 1, html => 1,                  !!!next-token;
2669                   p => 1, br => 1,                  redo B;
2670                  }->{$token->{tag_name}}) {                }
2671                } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2672                ## As if <head>                ## As if <head>
2673                !!!create-element ($self->{head_element}, 'head');                !!!create-element ($self->{head_element}, 'head');
2674                $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});                $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2675                push @{$self->{open_elements}}, [$self->{head_element}, 'head'];                push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2676                $self->{insertion_mode} = 'in head';  
2677                ## reprocess                $self->{insertion_mode} = IN_HEAD_IM;
2678                redo B;                ## Reprocess in the "in head" insertion mode...
             } else {  
               !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
               ## Ignore the token ## ISSUE: An issue in the spec.  
               !!!next-token;  
               redo B;  
2679              }              }
2680            } else {  
2681              die "$0: $token->{type}: Unknown type";              if ($token->{tag_name} eq 'base') {
2682            }                if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2683          } elsif ($self->{insertion_mode} eq 'in head' or                  ## As if </noscript>
2684                   $self->{insertion_mode} eq 'in head noscript' or                  pop @{$self->{open_elements}};
2685                   $self->{insertion_mode} eq 'after head') {                  !!!parse-error (type => 'in noscript:base');
2686            if ($token->{type} eq 'character') {                
2687              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {                  $self->{insertion_mode} = IN_HEAD_IM;
2688                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);                  ## Reprocess in the "in head" insertion mode...
               unless (length $token->{data}) {  
                 !!!next-token;  
                 redo B;  
2689                }                }
2690              }  
               
             #  
           } elsif ($token->{type} eq 'start tag') {  
             if ({base => ($self->{insertion_mode} eq 'in head' or  
                           $self->{insertion_mode} eq 'after head'),  
                  link => 1}->{$token->{tag_name}}) {  
2691                ## NOTE: There is a "as if in head" code clone.                ## NOTE: There is a "as if in head" code clone.
2692                if ($self->{insertion_mode} eq 'after head') {                if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2693                  !!!parse-error (type => 'after head:'.$token->{tag_name});                  !!!parse-error (type => 'after head:'.$token->{tag_name});
2694                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2695                }                }
2696                !!!insert-element ($token->{tag_name}, $token->{attributes});                !!!insert-element ($token->{tag_name}, $token->{attributes});
2697                pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.                pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
2698                pop @{$self->{open_elements}}                pop @{$self->{open_elements}}
2699                    if $self->{insertion_mode} eq 'after head';                    if $self->{insertion_mode} == AFTER_HEAD_IM;
2700                  !!!next-token;
2701                  redo B;
2702                } elsif ($token->{tag_name} eq 'link') {
2703                  ## NOTE: There is a "as if in head" code clone.
2704                  if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2705                    !!!parse-error (type => 'after head:'.$token->{tag_name});
2706                    push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2707                  }
2708                  !!!insert-element ($token->{tag_name}, $token->{attributes});
2709                  pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
2710                  pop @{$self->{open_elements}}
2711                      if $self->{insertion_mode} == AFTER_HEAD_IM;
2712                !!!next-token;                !!!next-token;
2713                redo B;                redo B;
2714              } elsif ($token->{tag_name} eq 'meta') {              } elsif ($token->{tag_name} eq 'meta') {
2715                ## NOTE: There is a "as if in head" code clone.                ## NOTE: There is a "as if in head" code clone.
2716                if ($self->{insertion_mode} eq 'after head') {                if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2717                  !!!parse-error (type => 'after head:'.$token->{tag_name});                  !!!parse-error (type => 'after head:'.$token->{tag_name});
2718                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2719                }                }
# Line 3519  sub _tree_construction_main ($) { Line 2739  sub _tree_construction_main ($) {
2739    
2740                ## TODO: Extracting |charset| from |meta|.                ## TODO: Extracting |charset| from |meta|.
2741                pop @{$self->{open_elements}}                pop @{$self->{open_elements}}
2742                    if $self->{insertion_mode} eq 'after head';                    if $self->{insertion_mode} == AFTER_HEAD_IM;
2743                !!!next-token;                !!!next-token;
2744                redo B;                redo B;
2745              } elsif ($token->{tag_name} eq 'title' and              } elsif ($token->{tag_name} eq 'title') {
2746                       $self->{insertion_mode} eq 'in head') {                if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2747                ## NOTE: There is a "as if in head" code clone.                  ## As if </noscript>
2748                if ($self->{insertion_mode} eq 'after head') {                  pop @{$self->{open_elements}};
2749                    !!!parse-error (type => 'in noscript:title');
2750                  
2751                    $self->{insertion_mode} = IN_HEAD_IM;
2752                    ## Reprocess in the "in head" insertion mode...
2753                  } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2754                  !!!parse-error (type => 'after head:'.$token->{tag_name});                  !!!parse-error (type => 'after head:'.$token->{tag_name});
2755                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2756                }                }
2757    
2758                  ## NOTE: There is a "as if in head" code clone.
2759                my $parent = defined $self->{head_element} ? $self->{head_element}                my $parent = defined $self->{head_element} ? $self->{head_element}
2760                    : $self->{open_elements}->[-1]->[0];                    : $self->{open_elements}->[-1]->[0];
2761                $parse_rcdata->(RCDATA_CONTENT_MODEL,                $parse_rcdata->(RCDATA_CONTENT_MODEL,
2762                                sub { $parent->append_child ($_[0]) });                                sub { $parent->append_child ($_[0]) });
2763                pop @{$self->{open_elements}}                pop @{$self->{open_elements}}
2764                    if $self->{insertion_mode} eq 'after head';                    if $self->{insertion_mode} == AFTER_HEAD_IM;
2765                redo B;                redo B;
2766              } elsif ($token->{tag_name} eq 'style') {              } elsif ($token->{tag_name} eq 'style') {
2767                ## NOTE: Or (scripting is enabled and tag_name eq 'noscript' and                ## NOTE: Or (scripting is enabled and tag_name eq 'noscript' and
2768                ## insertion mode 'in head')                ## insertion mode IN_HEAD_IM)
2769                ## NOTE: There is a "as if in head" code clone.                ## NOTE: There is a "as if in head" code clone.
2770                if ($self->{insertion_mode} eq 'after head') {                if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2771                  !!!parse-error (type => 'after head:'.$token->{tag_name});                  !!!parse-error (type => 'after head:'.$token->{tag_name});
2772                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2773                }                }
2774                $parse_rcdata->(CDATA_CONTENT_MODEL, $insert_to_current);                $parse_rcdata->(CDATA_CONTENT_MODEL, $insert_to_current);
2775                pop @{$self->{open_elements}}                pop @{$self->{open_elements}}
2776                    if $self->{insertion_mode} eq 'after head';                    if $self->{insertion_mode} == AFTER_HEAD_IM;
2777                redo B;                redo B;
2778              } elsif ($token->{tag_name} eq 'noscript') {              } elsif ($token->{tag_name} eq 'noscript') {
2779                if ($self->{insertion_mode} eq 'in head') {                if ($self->{insertion_mode} == IN_HEAD_IM) {
2780                  ## NOTE: and scripting is disalbed                  ## NOTE: and scripting is disalbed
2781                  !!!insert-element ($token->{tag_name}, $token->{attributes});                  !!!insert-element ($token->{tag_name}, $token->{attributes});
2782                  $self->{insertion_mode} = 'in head noscript';                  $self->{insertion_mode} = IN_HEAD_NOSCRIPT_IM;
2783                  !!!next-token;                  !!!next-token;
2784                  redo B;                  redo B;
2785                } elsif ($self->{insertion_mode} eq 'in head noscript') {                } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2786                  !!!parse-error (type => 'in noscript:noscript');                  !!!parse-error (type => 'in noscript:noscript');
2787                  ## Ignore the token                  ## Ignore the token
2788                  !!!next-token;                  !!!next-token;
# Line 3563  sub _tree_construction_main ($) { Line 2790  sub _tree_construction_main ($) {
2790                } else {                } else {
2791                  #                  #
2792                }                }
2793              } elsif ($token->{tag_name} eq 'head' and              } elsif ($token->{tag_name} eq 'script') {
2794                       $self->{insertion_mode} ne 'after head') {                if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2795                !!!parse-error (type => 'in head:head'); # or in head noscript                  ## As if </noscript>
2796                ## Ignore the token                  pop @{$self->{open_elements}};
2797                !!!next-token;                  !!!parse-error (type => 'in noscript:script');
2798                redo B;                
2799              } elsif ($self->{insertion_mode} ne 'in head noscript' and                  $self->{insertion_mode} = IN_HEAD_IM;
2800                       $token->{tag_name} eq 'script') {                  ## Reprocess in the "in head" insertion mode...
2801                if ($self->{insertion_mode} eq 'after head') {                } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2802                  !!!parse-error (type => 'after head:'.$token->{tag_name});                  !!!parse-error (type => 'after head:'.$token->{tag_name});
2803                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2804                }                }
2805    
2806                ## NOTE: There is a "as if in head" code clone.                ## NOTE: There is a "as if in head" code clone.
2807                $script_start_tag->($insert_to_current);                $script_start_tag->($insert_to_current);
2808                pop @{$self->{open_elements}}                pop @{$self->{open_elements}}
2809                    if $self->{insertion_mode} eq 'after head';                    if $self->{insertion_mode} == AFTER_HEAD_IM;
               redo B;  
             } elsif ($self->{insertion_mode} eq 'after head' and  
                      $token->{tag_name} eq 'body') {  
               !!!insert-element ('body', $token->{attributes});  
               $self->{insertion_mode} = 'in body';  
               !!!next-token;  
2810                redo B;                redo B;
2811              } elsif ($self->{insertion_mode} eq 'after head' and              } elsif ($token->{tag_name} eq 'body' or
2812                       $token->{tag_name} eq 'frameset') {                       $token->{tag_name} eq 'frameset') {
2813                !!!insert-element ('frameset', $token->{attributes});                if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2814                $self->{insertion_mode} = 'in frameset';                  ## As if </noscript>
2815                    pop @{$self->{open_elements}};
2816                    !!!parse-error (type => 'in noscript:'.$token->{tag_name});
2817                    
2818                    ## Reprocess in the "in head" insertion mode...
2819                    ## As if </head>
2820                    pop @{$self->{open_elements}};
2821                    
2822                    ## Reprocess in the "after head" insertion mode...
2823                  } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2824                    pop @{$self->{open_elements}};
2825                    
2826                    ## Reprocess in the "after head" insertion mode...
2827                  }
2828    
2829                  ## "after head" insertion mode
2830                  !!!insert-element ($token->{tag_name}, $token->{attributes});
2831                  if ($token->{tag_name} eq 'body') {
2832                    $self->{insertion_mode} = IN_BODY_IM;
2833                  } elsif ($token->{tag_name} eq 'frameset') {
2834                    $self->{insertion_mode} = IN_FRAMESET_IM;
2835                  } else {
2836                    die "$0: tag name: $self->{tag_name}";
2837                  }
2838                !!!next-token;                !!!next-token;
2839                redo B;                redo B;
2840              } else {              } else {
2841                #                #
2842              }              }
2843            } elsif ($token->{type} eq 'end tag') {  
2844              if ($self->{insertion_mode} eq 'in head' and              if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2845                  $token->{tag_name} eq 'head') {                ## As if </noscript>
2846                pop @{$self->{open_elements}};                pop @{$self->{open_elements}};
2847                $self->{insertion_mode} = 'after head';                !!!parse-error (type => 'in noscript:/'.$token->{tag_name});
2848                !!!next-token;                
2849                redo B;                ## Reprocess in the "in head" insertion mode...
2850              } elsif ($self->{insertion_mode} eq 'in head noscript' and                ## As if </head>
                 $token->{tag_name} eq 'noscript') {  
2851                pop @{$self->{open_elements}};                pop @{$self->{open_elements}};
2852                $self->{insertion_mode} = 'in head';  
2853                !!!next-token;                ## Reprocess in the "after head" insertion mode...
2854                redo B;              } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2855              } elsif ($self->{insertion_mode} eq 'in head' and                ## As if </head>
2856                       {                pop @{$self->{open_elements}};
2857    
2858                  ## Reprocess in the "after head" insertion mode...
2859                }
2860    
2861                ## "after head" insertion mode
2862                ## As if <body>
2863                !!!insert-element ('body');
2864                $self->{insertion_mode} = IN_BODY_IM;
2865                ## reprocess
2866                redo B;
2867              } elsif ($token->{type} == END_TAG_TOKEN) {
2868                if ($token->{tag_name} eq 'head') {
2869                  if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2870                    ## As if <head>
2871                    !!!create-element ($self->{head_element}, 'head');
2872                    $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2873                    push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2874    
2875                    ## Reprocess in the "in head" insertion mode...
2876                    pop @{$self->{open_elements}};
2877                    $self->{insertion_mode} = AFTER_HEAD_IM;
2878                    !!!next-token;
2879                    redo B;
2880                  } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2881                    ## As if </noscript>
2882                    pop @{$self->{open_elements}};
2883                    !!!parse-error (type => 'in noscript:script');
2884                    
2885                    ## Reprocess in the "in head" insertion mode...
2886                    pop @{$self->{open_elements}};
2887                    $self->{insertion_mode} = AFTER_HEAD_IM;
2888                    !!!next-token;
2889                    redo B;
2890                  } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2891                    pop @{$self->{open_elements}};
2892                    $self->{insertion_mode} = AFTER_HEAD_IM;
2893                    !!!next-token;
2894                    redo B;
2895                  } else {
2896                    #
2897                  }
2898                } elsif ($token->{tag_name} eq 'noscript') {
2899                  if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2900                    pop @{$self->{open_elements}};
2901                    $self->{insertion_mode} = IN_HEAD_IM;
2902                    !!!next-token;
2903                    redo B;
2904                  } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2905                    !!!parse-error (type => 'unmatched end tag:noscript');
2906                    ## Ignore the token ## ISSUE: An issue in the spec.
2907                    !!!next-token;
2908                    redo B;
2909                  } else {
2910                    #
2911                  }
2912                } elsif ({
2913                        body => 1, html => 1,                        body => 1, html => 1,
                       p => 1, br => 1,  
2914                       }->{$token->{tag_name}}) {                       }->{$token->{tag_name}}) {
2915                  if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2916                    ## As if <head>
2917                    !!!create-element ($self->{head_element}, 'head');
2918                    $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2919                    push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2920    
2921                    $self->{insertion_mode} = IN_HEAD_IM;
2922                    ## Reprocess in the "in head" insertion mode...
2923                  } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2924                    !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
2925                    ## Ignore the token
2926                    !!!next-token;
2927                    redo B;
2928                  }
2929                  
2930                #                #
2931              } elsif ($self->{insertion_mode} eq 'in head noscript' and              } elsif ({
                      {  
2932                        p => 1, br => 1,                        p => 1, br => 1,
2933                       }->{$token->{tag_name}}) {                       }->{$token->{tag_name}}) {
2934                  if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2935                    ## As if <head>
2936                    !!!create-element ($self->{head_element}, 'head');
2937                    $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2938                    push @{$self->{open_elements}}, [$self->{head_element}, 'head'];
2939    
2940                    $self->{insertion_mode} = IN_HEAD_IM;
2941                    ## Reprocess in the "in head" insertion mode...
2942                  }
2943    
2944                #                #
2945              } elsif ($self->{insertion_mode} ne 'after head') {              } else {
2946                  if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2947                    #
2948                  } else {
2949                    !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
2950                    ## Ignore the token
2951                    !!!next-token;
2952                    redo B;
2953                  }
2954                }
2955    
2956                if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2957                  ## As if </noscript>
2958                  pop @{$self->{open_elements}};
2959                  !!!parse-error (type => 'in noscript:/'.$token->{tag_name});
2960                  
2961                  ## Reprocess in the "in head" insertion mode...
2962                  ## As if </head>
2963                  pop @{$self->{open_elements}};
2964    
2965                  ## Reprocess in the "after head" insertion mode...
2966                } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2967                  ## As if </head>
2968                  pop @{$self->{open_elements}};
2969    
2970                  ## Reprocess in the "after head" insertion mode...
2971                } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2972                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
2973                ## Ignore the token                ## Ignore the token ## ISSUE: An issue in the spec.
2974                !!!next-token;                !!!next-token;
2975                redo B;                redo B;
             } else {  
               #  
2976              }              }
           } else {  
             #  
           }  
2977    
2978            ## As if </head> or </noscript> or <body>              ## "after head" insertion mode
2979            if ($self->{insertion_mode} eq 'in head') {              ## As if <body>
             pop @{$self->{open_elements}};  
             $self->{insertion_mode} = 'after head';  
           } elsif ($self->{insertion_mode} eq 'in head noscript') {  
             pop @{$self->{open_elements}};  
             !!!parse-error (type => 'in noscript:'.(defined $token->{tag_name} ? ($token->{type} eq 'end tag' ? '/' : '') . $token->{tag_name} : '#' . $token->{type}));  
             $self->{insertion_mode} = 'in head';  
           } else { # 'after head'  
2980              !!!insert-element ('body');              !!!insert-element ('body');
2981              $self->{insertion_mode} = 'in body';              $self->{insertion_mode} = IN_BODY_IM;
2982                ## reprocess
2983                redo B;
2984              } else {
2985                die "$0: $token->{type}: Unknown token type";
2986            }            }
           ## reprocess  
           redo B;  
2987    
2988            ## ISSUE: An issue in the spec.            ## ISSUE: An issue in the spec.
2989          } elsif ($self->{insertion_mode} eq 'in body' or      } elsif ($self->{insertion_mode} == IN_BODY_IM or
2990                   $self->{insertion_mode} eq 'in cell' or               $self->{insertion_mode} == IN_CELL_IM or
2991                   $self->{insertion_mode} eq 'in caption') {               $self->{insertion_mode} == IN_CAPTION_IM) {
2992            if ($token->{type} eq 'character') {            if ($token->{type} == CHARACTER_TOKEN) {
2993              ## NOTE: There is a code clone of "character in body".              ## NOTE: There is a code clone of "character in body".
2994              $reconstruct_active_formatting_elements->($insert_to_current);              $reconstruct_active_formatting_elements->($insert_to_current);
2995                            
# Line 3658  sub _tree_construction_main ($) { Line 2997  sub _tree_construction_main ($) {
2997    
2998              !!!next-token;              !!!next-token;
2999              redo B;              redo B;
3000            } elsif ($token->{type} eq 'start tag') {            } elsif ($token->{type} == START_TAG_TOKEN) {
3001              if ({              if ({
3002                   caption => 1, col => 1, colgroup => 1, tbody => 1,                   caption => 1, col => 1, colgroup => 1, tbody => 1,
3003                   td => 1, tfoot => 1, th => 1, thead => 1, tr => 1,                   td => 1, tfoot => 1, th => 1, thead => 1, tr => 1,
3004                  }->{$token->{tag_name}}) {                  }->{$token->{tag_name}}) {
3005                if ($self->{insertion_mode} eq 'in cell') {                if ($self->{insertion_mode} == IN_CELL_IM) {
3006                  ## have an element in table scope                  ## have an element in table scope
3007                  my $tn;                  my $tn;
3008                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
# Line 3686  sub _tree_construction_main ($) { Line 3025  sub _tree_construction_main ($) {
3025                                    
3026                  ## Close the cell                  ## Close the cell
3027                  !!!back-token; # <?>                  !!!back-token; # <?>
3028                  $token = {type => 'end tag', tag_name => $tn};                  $token = {type => END_TAG_TOKEN, tag_name => $tn};
3029                  redo B;                  redo B;
3030                } elsif ($self->{insertion_mode} eq 'in caption') {                } elsif ($self->{insertion_mode} == IN_CAPTION_IM) {
3031                  !!!parse-error (type => 'not closed:caption');                  !!!parse-error (type => 'not closed:caption');
3032                                    
3033                  ## As if </caption>                  ## As if </caption>
# Line 3719  sub _tree_construction_main ($) { Line 3058  sub _tree_construction_main ($) {
3058                       tbody => 1, tfoot=> 1, thead => 1,                       tbody => 1, tfoot=> 1, thead => 1,
3059                      }->{$self->{open_elements}->[-1]->[1]}) {                      }->{$self->{open_elements}->[-1]->[1]}) {
3060                    !!!back-token; # <?>                    !!!back-token; # <?>
3061                    $token = {type => 'end tag', tag_name => 'caption'};                    $token = {type => END_TAG_TOKEN, tag_name => 'caption'};
3062                    !!!back-token;                    !!!back-token;
3063                    $token = {type => 'end tag',                    $token = {type => END_TAG_TOKEN,
3064                              tag_name => $self->{open_elements}->[-1]->[1]}; # MUST                              tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
3065                    redo B;                    redo B;
3066                  }                  }
# Line 3734  sub _tree_construction_main ($) { Line 3073  sub _tree_construction_main ($) {
3073                                    
3074                  $clear_up_to_marker->();                  $clear_up_to_marker->();
3075                                    
3076                  $self->{insertion_mode} = 'in table';                  $self->{insertion_mode} = IN_TABLE_IM;
3077                                    
3078                  ## reprocess                  ## reprocess
3079                  redo B;                  redo B;
# Line 3744  sub _tree_construction_main ($) { Line 3083  sub _tree_construction_main ($) {
3083              } else {              } else {
3084                #                #
3085              }              }
3086            } elsif ($token->{type} eq 'end tag') {            } elsif ($token->{type} == END_TAG_TOKEN) {
3087              if ($token->{tag_name} eq 'td' or $token->{tag_name} eq 'th') {              if ($token->{tag_name} eq 'td' or $token->{tag_name} eq 'th') {
3088                if ($self->{insertion_mode} eq 'in cell') {                if ($self->{insertion_mode} == IN_CELL_IM) {
3089                  ## have an element in table scope                  ## have an element in table scope
3090                  my $i;                  my $i;
3091                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
# Line 3776  sub _tree_construction_main ($) { Line 3115  sub _tree_construction_main ($) {
3115                       tbody => 1, tfoot=> 1, thead => 1,                       tbody => 1, tfoot=> 1, thead => 1,
3116                      }->{$self->{open_elements}->[-1]->[1]}) {                      }->{$self->{open_elements}->[-1]->[1]}) {
3117                    !!!back-token;                    !!!back-token;
3118                    $token = {type => 'end tag',                    $token = {type => END_TAG_TOKEN,
3119                              tag_name => $self->{open_elements}->[-1]->[1]}; # MUST                              tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
3120                    redo B;                    redo B;
3121                  }                  }
# Line 3789  sub _tree_construction_main ($) { Line 3128  sub _tree_construction_main ($) {
3128                                    
3129                  $clear_up_to_marker->();                  $clear_up_to_marker->();
3130                                    
3131                  $self->{insertion_mode} = 'in row';                  $self->{insertion_mode} = IN_ROW_IM;
3132                                    
3133                  !!!next-token;                  !!!next-token;
3134                  redo B;                  redo B;
3135                } elsif ($self->{insertion_mode} eq 'in caption') {                } elsif ($self->{insertion_mode} == IN_CAPTION_IM) {
3136                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3137                  ## Ignore the token                  ## Ignore the token
3138                  !!!next-token;                  !!!next-token;
# Line 3802  sub _tree_construction_main ($) { Line 3141  sub _tree_construction_main ($) {
3141                  #                  #
3142                }                }
3143              } elsif ($token->{tag_name} eq 'caption') {              } elsif ($token->{tag_name} eq 'caption') {
3144                if ($self->{insertion_mode} eq 'in caption') {                if ($self->{insertion_mode} == IN_CAPTION_IM) {
3145                  ## have a table element in table scope                  ## have a table element in table scope
3146                  my $i;                  my $i;
3147                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
# Line 3830  sub _tree_construction_main ($) { Line 3169  sub _tree_construction_main ($) {
3169                       tbody => 1, tfoot=> 1, thead => 1,                       tbody => 1, tfoot=> 1, thead => 1,
3170                      }->{$self->{open_elements}->[-1]->[1]}) {                      }->{$self->{open_elements}->[-1]->[1]}) {
3171                    !!!back-token;                    !!!back-token;
3172                    $token = {type => 'end tag',                    $token = {type => END_TAG_TOKEN,
3173                              tag_name => $self->{open_elements}->[-1]->[1]}; # MUST                              tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
3174                    redo B;                    redo B;
3175                  }                  }
# Line 3843  sub _tree_construction_main ($) { Line 3182  sub _tree_construction_main ($) {
3182                                    
3183                  $clear_up_to_marker->();                  $clear_up_to_marker->();
3184                                    
3185                  $self->{insertion_mode} = 'in table';                  $self->{insertion_mode} = IN_TABLE_IM;
3186                                    
3187                  !!!next-token;                  !!!next-token;
3188                  redo B;                  redo B;
3189                } elsif ($self->{insertion_mode} eq 'in cell') {                } elsif ($self->{insertion_mode} == IN_CELL_IM) {
3190                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3191                  ## Ignore the token                  ## Ignore the token
3192                  !!!next-token;                  !!!next-token;
# Line 3859  sub _tree_construction_main ($) { Line 3198  sub _tree_construction_main ($) {
3198                        table => 1, tbody => 1, tfoot => 1,                        table => 1, tbody => 1, tfoot => 1,
3199                        thead => 1, tr => 1,                        thead => 1, tr => 1,
3200                       }->{$token->{tag_name}} and                       }->{$token->{tag_name}} and
3201                       $self->{insertion_mode} eq 'in cell') {                       $self->{insertion_mode} == IN_CELL_IM) {
3202                ## have an element in table scope                ## have an element in table scope
3203                my $i;                my $i;
3204                my $tn;                my $tn;
# Line 3887  sub _tree_construction_main ($) { Line 3226  sub _tree_construction_main ($) {
3226    
3227                ## Close the cell                ## Close the cell
3228                !!!back-token; # </?>                !!!back-token; # </?>
3229                $token = {type => 'end tag', tag_name => $tn};                $token = {type => END_TAG_TOKEN, tag_name => $tn};
3230                redo B;                redo B;
3231              } elsif ($token->{tag_name} eq 'table' and              } elsif ($token->{tag_name} eq 'table' and
3232                       $self->{insertion_mode} eq 'in caption') {                       $self->{insertion_mode} == IN_CAPTION_IM) {
3233                !!!parse-error (type => 'not closed:caption');                !!!parse-error (type => 'not closed:caption');
3234    
3235                ## As if </caption>                ## As if </caption>
# Line 3921  sub _tree_construction_main ($) { Line 3260  sub _tree_construction_main ($) {
3260                     tbody => 1, tfoot=> 1, thead => 1,                     tbody => 1, tfoot=> 1, thead => 1,
3261                    }->{$self->{open_elements}->[-1]->[1]}) {                    }->{$self->{open_elements}->[-1]->[1]}) {
3262                  !!!back-token; # </table>                  !!!back-token; # </table>
3263                  $token = {type => 'end tag', tag_name => 'caption'};                  $token = {type => END_TAG_TOKEN, tag_name => 'caption'};
3264                  !!!back-token;                  !!!back-token;
3265                  $token = {type => 'end tag',                  $token = {type => END_TAG_TOKEN,
3266                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
3267                  redo B;                  redo B;
3268                }                }
# Line 3936  sub _tree_construction_main ($) { Line 3275  sub _tree_construction_main ($) {
3275    
3276                $clear_up_to_marker->();                $clear_up_to_marker->();
3277    
3278                $self->{insertion_mode} = 'in table';                $self->{insertion_mode} = IN_TABLE_IM;
3279    
3280                ## reprocess                ## reprocess
3281                redo B;                redo B;
3282              } elsif ({              } elsif ({
3283                        body => 1, col => 1, colgroup => 1, html => 1,                        body => 1, col => 1, colgroup => 1, html => 1,
3284                       }->{$token->{tag_name}}) {                       }->{$token->{tag_name}}) {
3285                if ($self->{insertion_mode} eq 'in cell' or                if ($self->{insertion_mode} == IN_CELL_IM or
3286                    $self->{insertion_mode} eq 'in caption') {                    $self->{insertion_mode} == IN_CAPTION_IM) {
3287                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3288                  ## Ignore the token                  ## Ignore the token
3289                  !!!next-token;                  !!!next-token;
# Line 3956  sub _tree_construction_main ($) { Line 3295  sub _tree_construction_main ($) {
3295                        tbody => 1, tfoot => 1,                        tbody => 1, tfoot => 1,
3296                        thead => 1, tr => 1,                        thead => 1, tr => 1,
3297                       }->{$token->{tag_name}} and                       }->{$token->{tag_name}} and
3298                       $self->{insertion_mode} eq 'in caption') {                       $self->{insertion_mode} == IN_CAPTION_IM) {
3299                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3300                ## Ignore the token                ## Ignore the token
3301                !!!next-token;                !!!next-token;
# Line 3964  sub _tree_construction_main ($) { Line 3303  sub _tree_construction_main ($) {
3303              } else {              } else {
3304                #                #
3305              }              }
3306            } else {        } else {
3307              #          die "$0: $token->{type}: Unknown token type";
3308            }        }
3309              
3310            $in_body->($insert_to_current);        $insert = $insert_to_current;
3311            redo B;        #
3312          } elsif ($self->{insertion_mode} eq 'in table') {      } elsif ($self->{insertion_mode} == IN_ROW_IM or
3313            if ($token->{type} eq 'character') {               $self->{insertion_mode} == IN_TABLE_BODY_IM or
3314                 $self->{insertion_mode} == IN_TABLE_IM) {
3315              if ($token->{type} == CHARACTER_TOKEN) {
3316              ## NOTE: There are "character in table" code clones.              ## NOTE: There are "character in table" code clones.
3317              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
3318                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
# Line 4029  sub _tree_construction_main ($) { Line 3370  sub _tree_construction_main ($) {
3370                            
3371              !!!next-token;              !!!next-token;
3372              redo B;              redo B;
3373            } elsif ($token->{type} eq 'start tag') {            } elsif ($token->{type} == START_TAG_TOKEN) {
3374              if ({              if ({
3375                   caption => 1,                   tr => ($self->{insertion_mode} != IN_ROW_IM),
3376                   colgroup => 1,                   th => 1, td => 1,
                  tbody => 1, tfoot => 1, thead => 1,  
3377                  }->{$token->{tag_name}}) {                  }->{$token->{tag_name}}) {
3378                ## Clear back to table context                if ($self->{insertion_mode} == IN_TABLE_IM) {
3379                while ($self->{open_elements}->[-1]->[1] ne 'table' and                  ## Clear back to table context
3380                       $self->{open_elements}->[-1]->[1] ne 'html') {                  while ($self->{open_elements}->[-1]->[1] ne 'table' and
3381                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                         $self->{open_elements}->[-1]->[1] ne 'html') {
3382                  pop @{$self->{open_elements}};                    !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3383                      pop @{$self->{open_elements}};
3384                    }
3385                    
3386                    !!!insert-element ('tbody');
3387                    $self->{insertion_mode} = IN_TABLE_BODY_IM;
3388                    ## reprocess in the "in table body" insertion mode...
3389                }                }
3390    
3391                push @$active_formatting_elements, ['#marker', '']                if ($self->{insertion_mode} == IN_TABLE_BODY_IM) {
3392                  if $token->{tag_name} eq 'caption';                  unless ($token->{tag_name} eq 'tr') {
3393                      !!!parse-error (type => 'missing start tag:tr');
3394                    }
3395                    
3396                    ## Clear back to table body context
3397                    while (not {
3398                      tbody => 1, tfoot => 1, thead => 1, html => 1,
3399                    }->{$self->{open_elements}->[-1]->[1]}) {
3400                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3401                      pop @{$self->{open_elements}};
3402                    }
3403                    
3404                    $self->{insertion_mode} = IN_ROW_IM;
3405                    if ($token->{tag_name} eq 'tr') {
3406                      !!!insert-element ($token->{tag_name}, $token->{attributes});
3407                      !!!next-token;
3408                      redo B;
3409                    } else {
3410                      !!!insert-element ('tr');
3411                      ## reprocess in the "in row" insertion mode
3412                    }
3413                  }
3414    
3415                  ## Clear back to table row context
3416                  while (not {
3417                    tr => 1, html => 1,
3418                  }->{$self->{open_elements}->[-1]->[1]}) {
3419                    !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3420                    pop @{$self->{open_elements}};
3421                  }
3422                  
3423                !!!insert-element ($token->{tag_name}, $token->{attributes});                !!!insert-element ($token->{tag_name}, $token->{attributes});
3424                $self->{insertion_mode} = {                $self->{insertion_mode} = IN_CELL_IM;
3425                                   caption => 'in caption',  
3426                                   colgroup => 'in column group',                push @$active_formatting_elements, ['#marker', ''];
3427                                   tbody => 'in table body',                
                                  tfoot => 'in table body',  
                                  thead => 'in table body',  
                                 }->{$token->{tag_name}};  
3428                !!!next-token;                !!!next-token;
3429                redo B;                redo B;
3430              } elsif ({              } elsif ({
3431                        col => 1,                        caption => 1, col => 1, colgroup => 1,
3432                        td => 1, th => 1, tr => 1,                        tbody => 1, tfoot => 1, thead => 1,
3433                          tr => 1, # $self->{insertion_mode} == IN_ROW_IM
3434                       }->{$token->{tag_name}}) {                       }->{$token->{tag_name}}) {
3435                ## Clear back to table context                if ($self->{insertion_mode} == IN_ROW_IM) {
3436                while ($self->{open_elements}->[-1]->[1] ne 'table' and                  ## As if </tr>
3437                       $self->{open_elements}->[-1]->[1] ne 'html') {                  ## have an element in table scope
3438                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                  my $i;
3439                    INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3440                      my $node = $self->{open_elements}->[$_];
3441                      if ($node->[1] eq 'tr') {
3442                        $i = $_;
3443                        last INSCOPE;
3444                      } elsif ({
3445                                table => 1, html => 1,
3446                               }->{$node->[1]}) {
3447                        last INSCOPE;
3448                      }
3449                    } # INSCOPE
3450                    unless (defined $i) {
3451                      !!!parse-error (type => 'unmacthed end tag:'.$token->{tag_name});
3452                      ## Ignore the token
3453                      !!!next-token;
3454                      redo B;
3455                    }
3456                    
3457                    ## Clear back to table row context
3458                    while (not {
3459                      tr => 1, html => 1,
3460                    }->{$self->{open_elements}->[-1]->[1]}) {
3461                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3462                      pop @{$self->{open_elements}};
3463                    }
3464                    
3465                    pop @{$self->{open_elements}}; # tr
3466                    $self->{insertion_mode} = IN_TABLE_BODY_IM;
3467                    if ($token->{tag_name} eq 'tr') {
3468                      ## reprocess
3469                      redo B;
3470                    } else {
3471                      ## reprocess in the "in table body" insertion mode...
3472                    }
3473                  }
3474    
3475                  if ($self->{insertion_mode} == IN_TABLE_BODY_IM) {
3476                    ## have an element in table scope
3477                    my $i;
3478                    INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3479                      my $node = $self->{open_elements}->[$_];
3480                      if ({
3481                           tbody => 1, thead => 1, tfoot => 1,
3482                          }->{$node->[1]}) {
3483                        $i = $_;
3484                        last INSCOPE;
3485                      } elsif ({
3486                                table => 1, html => 1,
3487                               }->{$node->[1]}) {
3488                        last INSCOPE;
3489                      }
3490                    } # INSCOPE
3491                    unless (defined $i) {
3492                      !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3493                      ## Ignore the token
3494                      !!!next-token;
3495                      redo B;
3496                    }
3497    
3498                    ## Clear back to table body context
3499                    while (not {
3500                      tbody => 1, tfoot => 1, thead => 1, html => 1,
3501                    }->{$self->{open_elements}->[-1]->[1]}) {
3502                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3503                      pop @{$self->{open_elements}};
3504                    }
3505                    
3506                    ## As if <{current node}>
3507                    ## have an element in table scope
3508                    ## true by definition
3509                    
3510                    ## Clear back to table body context
3511                    ## nop by definition
3512                    
3513                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
3514                    $self->{insertion_mode} = IN_TABLE_IM;
3515                    ## reprocess in "in table" insertion mode...
3516                }                }
3517    
3518                !!!insert-element ($token->{tag_name} eq 'col' ? 'colgroup' : 'tbody');                if ($token->{tag_name} eq 'col') {
3519                $self->{insertion_mode} = $token->{tag_name} eq 'col'                  ## Clear back to table context
3520                  ? 'in column group' : 'in table body';                  while ($self->{open_elements}->[-1]->[1] ne 'table' and
3521                ## reprocess                         $self->{open_elements}->[-1]->[1] ne 'html') {
3522                redo B;                    !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3523                      pop @{$self->{open_elements}};
3524                    }
3525                    
3526                    !!!insert-element ('colgroup');
3527                    $self->{insertion_mode} = IN_COLUMN_GROUP_IM;
3528                    ## reprocess
3529                    redo B;
3530                  } elsif ({
3531                            caption => 1,
3532                            colgroup => 1,
3533                            tbody => 1, tfoot => 1, thead => 1,
3534                           }->{$token->{tag_name}}) {
3535                    ## Clear back to table context
3536                    while ($self->{open_elements}->[-1]->[1] ne 'table' and
3537                           $self->{open_elements}->[-1]->[1] ne 'html') {
3538                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3539                      pop @{$self->{open_elements}};
3540                    }
3541                    
3542                    push @$active_formatting_elements, ['#marker', '']
3543                        if $token->{tag_name} eq 'caption';
3544                    
3545                    !!!insert-element ($token->{tag_name}, $token->{attributes});
3546                    $self->{insertion_mode} = {
3547                                               caption => IN_CAPTION_IM,
3548                                               colgroup => IN_COLUMN_GROUP_IM,
3549                                               tbody => IN_TABLE_BODY_IM,
3550                                               tfoot => IN_TABLE_BODY_IM,
3551                                               thead => IN_TABLE_BODY_IM,
3552                                              }->{$token->{tag_name}};
3553                    !!!next-token;
3554                    redo B;
3555                  } else {
3556                    die "$0: in table: <>: $token->{tag_name}";
3557                  }
3558              } elsif ($token->{tag_name} eq 'table') {              } elsif ($token->{tag_name} eq 'table') {
3559                ## NOTE: There are code clones for this "table in table"                ## NOTE: There are code clones for this "table in table"
3560                !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
# Line 4103  sub _tree_construction_main ($) { Line 3587  sub _tree_construction_main ($) {
3587                     tbody => 1, tfoot=> 1, thead => 1,                     tbody => 1, tfoot=> 1, thead => 1,
3588                    }->{$self->{open_elements}->[-1]->[1]}) {                    }->{$self->{open_elements}->[-1]->[1]}) {
3589                  !!!back-token; # <table>                  !!!back-token; # <table>
3590                  $token = {type => 'end tag', tag_name => 'table'};                  $token = {type => END_TAG_TOKEN, tag_name => 'table'};
3591                  !!!back-token;                  !!!back-token;
3592                  $token = {type => 'end tag',                  $token = {type => END_TAG_TOKEN,
3593                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
3594                  redo B;                  redo B;
3595                }                }
# Line 4123  sub _tree_construction_main ($) { Line 3607  sub _tree_construction_main ($) {
3607              } else {              } else {
3608                #                #
3609              }              }
3610            } elsif ($token->{type} eq 'end tag') {            } elsif ($token->{type} == END_TAG_TOKEN) {
3611              if ($token->{tag_name} eq 'table') {              if ($token->{tag_name} eq 'tr' and
3612                ## have a table element in table scope                  $self->{insertion_mode} == IN_ROW_IM) {
3613                  ## have an element in table scope
3614                my $i;                my $i;
3615                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3616                  my $node = $self->{open_elements}->[$_];                  my $node = $self->{open_elements}->[$_];
# Line 4144  sub _tree_construction_main ($) { Line 3629  sub _tree_construction_main ($) {
3629                  !!!next-token;                  !!!next-token;
3630                  redo B;                  redo B;
3631                }                }
                 
               ## generate implied end tags  
               if ({  
                    dd => 1, dt => 1, li => 1, p => 1,  
                    td => 1, th => 1, tr => 1,  
                    tbody => 1, tfoot=> 1, thead => 1,  
                   }->{$self->{open_elements}->[-1]->[1]}) {  
                 !!!back-token;  
                 $token = {type => 'end tag',  
                           tag_name => $self->{open_elements}->[-1]->[1]}; # MUST  
                 redo B;  
               }  
3632    
3633                if ($self->{open_elements}->[-1]->[1] ne 'table') {                ## Clear back to table row context
3634                  while (not {
3635                    tr => 1, html => 1,
3636                  }->{$self->{open_elements}->[-1]->[1]}) {
3637                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3638                    pop @{$self->{open_elements}};
3639                }                }
3640    
3641                splice @{$self->{open_elements}}, $i;                pop @{$self->{open_elements}}; # tr
3642                  $self->{insertion_mode} = IN_TABLE_BODY_IM;
               $self->_reset_insertion_mode;  
   
               !!!next-token;  
               redo B;  
             } 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}}) {  
               !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
               ## Ignore the token  
               !!!next-token;  
               redo B;  
             } else {  
               #  
             }  
           } else {  
             #  
           }  
   
           !!!parse-error (type => 'in table:'.$token->{tag_name});  
           $in_body->($insert_to_foster);  
           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 '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');  
                 ## Ignore the token  
                 !!!next-token;  
                 redo B;  
               } else {  
                 pop @{$self->{open_elements}}; # colgroup  
                 $self->{insertion_mode} = 'in table';  
                 !!!next-token;  
                 redo B;              
               }  
             } elsif ($token->{tag_name} eq 'col') {  
               !!!parse-error (type => 'unmatched end tag:col');  
               ## Ignore the token  
3643                !!!next-token;                !!!next-token;
3644                redo B;                redo B;
3645              } else {              } elsif ($token->{tag_name} eq 'table') {
3646                #                if ($self->{insertion_mode} == IN_ROW_IM) {
3647              }                  ## As if </tr>
3648            } else {                  ## have an element in table scope
3649              #                  my $i;
3650            }                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3651                      my $node = $self->{open_elements}->[$_];
3652            ## As if </colgroup>                    if ($node->[1] eq 'tr') {
3653            if ($self->{open_elements}->[-1]->[1] eq 'html') {                      $i = $_;
3654              !!!parse-error (type => 'unmatched end tag:colgroup');                      last INSCOPE;
3655              ## Ignore the token                    } elsif ({
3656              !!!next-token;                              table => 1, html => 1,
3657              redo B;                             }->{$node->[1]}) {
3658            } else {                      last INSCOPE;
             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.  
             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,  
                 }->{$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;  
3659                    }                    }
3660                    last OE;                  } # INSCOPE
3661                    unless (defined $i) {
3662                      !!!parse-error (type => 'unmatched end tag:'.$token->{type});
3663                      ## Ignore the token
3664                      !!!next-token;
3665                      redo B;
3666                  }                  }
3667                } # OE                  
3668                $foster_parent_element = $self->{open_elements}->[0]->[0] and                  ## Clear back to table row context
3669                $prev_sibling = $foster_parent_element->last_child                  while (not {
3670                  unless defined $foster_parent_element;                    tr => 1, html => 1,
3671                if (defined $prev_sibling and                  }->{$self->{open_elements}->[-1]->[1]}) {
3672                    $prev_sibling->node_type == 3) {                    !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3673                  $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 'start tag') {  
             if ({  
                  tr => 1,  
                  th => 1, td => 1,  
                 }->{$token->{tag_name}}) {  
               unless ($token->{tag_name} eq 'tr') {  
                 !!!parse-error (type => 'missing start tag:tr');  
               }  
   
               ## 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}};  
               }  
                 
               $self->{insertion_mode} = 'in row';  
               if ($token->{tag_name} eq 'tr') {  
                 !!!insert-element ($token->{tag_name}, $token->{attributes});  
                 !!!next-token;  
               } else {  
                 !!!insert-element ('tr');  
                 ## reprocess  
               }  
               redo B;  
             } elsif ({  
                       caption => 1, col => 1, colgroup => 1,  
                       tbody => 1, tfoot => 1, thead => 1,  
                      }->{$token->{tag_name}}) {  
               ## have an element in table scope  
               my $i;  
               INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
                 my $node = $self->{open_elements}->[$_];  
                 if ({  
                      tbody => 1, thead => 1, tfoot => 1,  
                     }->{$node->[1]}) {  
                   $i = $_;  
                   last INSCOPE;  
                 } elsif ({  
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
                   last INSCOPE;  
3674                  }                  }
3675                } # INSCOPE                  
3676                unless (defined $i) {                  pop @{$self->{open_elements}}; # tr
3677                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                  $self->{insertion_mode} = IN_TABLE_BODY_IM;
3678                  ## Ignore the token                  ## reprocess in the "in table body" insertion mode...
                 !!!next-token;  
                 redo B;  
3679                }                }
3680    
3681                ## Clear back to table body context                if ($self->{insertion_mode} == IN_TABLE_BODY_IM) {
3682                while (not {                  ## have an element in table scope
3683                  tbody => 1, tfoot => 1, thead => 1, html => 1,                  my $i;
3684                }->{$self->{open_elements}->[-1]->[1]}) {                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3685                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                    my $node = $self->{open_elements}->[$_];
3686                      if ({
3687                           tbody => 1, thead => 1, tfoot => 1,
3688                          }->{$node->[1]}) {
3689                        $i = $_;
3690                        last INSCOPE;
3691                      } elsif ({
3692                                table => 1, html => 1,
3693                               }->{$node->[1]}) {
3694                        last INSCOPE;
3695                      }
3696                    } # INSCOPE
3697                    unless (defined $i) {
3698                      !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3699                      ## Ignore the token
3700                      !!!next-token;
3701                      redo B;
3702                    }
3703                    
3704                    ## Clear back to table body context
3705                    while (not {
3706                      tbody => 1, tfoot => 1, thead => 1, html => 1,
3707                    }->{$self->{open_elements}->[-1]->[1]}) {
3708                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3709                      pop @{$self->{open_elements}};
3710                    }
3711                    
3712                    ## As if <{current node}>
3713                    ## have an element in table scope
3714                    ## true by definition
3715                    
3716                    ## Clear back to table body context
3717                    ## nop by definition
3718                    
3719                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
3720                    $self->{insertion_mode} = IN_TABLE_IM;
3721                    ## reprocess in the "in table" insertion mode...
3722                }                }
3723    
               ## 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 ($token->{tag_name} eq 'table') {  
               ## NOTE: This is a code clone of "table in table"  
               !!!parse-error (type => 'not closed:table');  
   
               ## As if </table>  
3724                ## have a table element in table scope                ## have a table element in table scope
3725                my $i;                my $i;
3726                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3727                  my $node = $self->{open_elements}->[$_];                  my $node = $self->{open_elements}->[$_];
3728                  if ($node->[1] eq 'table') {                  if ($node->[1] eq $token->{tag_name}) {
3729                    $i = $_;                    $i = $_;
3730                    last INSCOPE;                    last INSCOPE;
3731                  } elsif ({                  } elsif ({
# Line 4392  sub _tree_construction_main ($) { Line 3735  sub _tree_construction_main ($) {
3735                  }                  }
3736                } # INSCOPE                } # INSCOPE
3737                unless (defined $i) {                unless (defined $i) {
3738                  !!!parse-error (type => 'unmatched end tag:table');                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3739                  ## Ignore tokens </table><table>                  ## Ignore the token
3740                  !!!next-token;                  !!!next-token;
3741                  redo B;                  redo B;
3742                }                }
3743                  
3744                ## generate implied end tags                ## generate implied end tags
3745                if ({                if ({
3746                     dd => 1, dt => 1, li => 1, p => 1,                     dd => 1, dt => 1, li => 1, p => 1,
3747                     td => 1, th => 1, tr => 1,                     td => 1, th => 1, tr => 1,
3748                     tbody => 1, tfoot=> 1, thead => 1,                     tbody => 1, tfoot=> 1, thead => 1,
3749                    }->{$self->{open_elements}->[-1]->[1]}) {                    }->{$self->{open_elements}->[-1]->[1]}) {
                 !!!back-token; # <table>  
                 $token = {type => 'end tag', tag_name => 'table'};  
3750                  !!!back-token;                  !!!back-token;
3751                  $token = {type => 'end tag',                  $token = {type => END_TAG_TOKEN,
3752                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
3753                  redo B;                  redo B;
3754                }                }
3755                  
3756                if ($self->{open_elements}->[-1]->[1] ne 'table') {                if ($self->{open_elements}->[-1]->[1] ne 'table') {
3757                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3758                }                }
3759                    
3760                splice @{$self->{open_elements}}, $i;                splice @{$self->{open_elements}}, $i;
3761                  
3762                $self->_reset_insertion_mode;                $self->_reset_insertion_mode;
3763                  
3764                ## reprocess                !!!next-token;
3765                redo B;                redo B;
3766              } else {              } elsif ({
3767                #                        tbody => 1, tfoot => 1, thead => 1,
3768              }                       }->{$token->{tag_name}} and
3769            } elsif ($token->{type} eq 'end tag') {                       ($self->{insertion_mode} == IN_ROW_IM or
3770              if ({                        $self->{insertion_mode} == IN_TABLE_BODY_IM)) {
3771                   tbody => 1, tfoot => 1, thead => 1,                if ($self->{insertion_mode} == IN_ROW_IM) {
3772                  }->{$token->{tag_name}}) {                  ## have an element in table scope
3773                ## have an element in table scope                  my $i;
3774                my $i;                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3775                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                    my $node = $self->{open_elements}->[$_];
3776                  my $node = $self->{open_elements}->[$_];                    if ($node->[1] eq $token->{tag_name}) {
3777                  if ($node->[1] eq $token->{tag_name}) {                      $i = $_;
3778                    $i = $_;                      last INSCOPE;
3779                    last INSCOPE;                    } elsif ({
3780                  } elsif ({                              table => 1, html => 1,
3781                            table => 1, html => 1,                             }->{$node->[1]}) {
3782                           }->{$node->[1]}) {                      last INSCOPE;
3783                    last INSCOPE;                    }
3784                    } # INSCOPE
3785                      unless (defined $i) {
3786                        !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3787                        ## Ignore the token
3788                        !!!next-token;
3789                        redo B;
3790                      }
3791                    
3792                    ## As if </tr>
3793                    ## have an element in table scope
3794                    my $i;
3795                    INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3796                      my $node = $self->{open_elements}->[$_];
3797                      if ($node->[1] eq 'tr') {
3798                        $i = $_;
3799                        last INSCOPE;
3800                      } elsif ({
3801                                table => 1, html => 1,
3802                               }->{$node->[1]}) {
3803                        last INSCOPE;
3804                      }
3805                    } # INSCOPE
3806                      unless (defined $i) {
3807                        !!!parse-error (type => 'unmatched end tag:tr');
3808                        ## Ignore the token
3809                        !!!next-token;
3810                        redo B;
3811                      }
3812                    
3813                    ## Clear back to table row context
3814                    while (not {
3815                      tr => 1, html => 1,
3816                    }->{$self->{open_elements}->[-1]->[1]}) {
3817                      !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
3818                      pop @{$self->{open_elements}};
3819                  }                  }
3820                } # INSCOPE                  
3821                unless (defined $i) {                  pop @{$self->{open_elements}}; # tr
3822                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                  $self->{insertion_mode} = IN_TABLE_BODY_IM;
3823                  ## Ignore the token                  ## reprocess in the "in table body" insertion mode...
                 !!!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}};  
3824                }                }
3825    
               pop @{$self->{open_elements}};  
               $self->{insertion_mode} = 'in table';  
               !!!next-token;  
               redo B;  
             } elsif ($token->{tag_name} eq 'table') {  
3826                ## have an element in table scope                ## have an element in table scope
3827                my $i;                my $i;
3828                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3829                  my $node = $self->{open_elements}->[$_];                  my $node = $self->{open_elements}->[$_];
3830                  if ({                  if ($node->[1] eq $token->{tag_name}) {
                      tbody => 1, thead => 1, tfoot => 1,  
                     }->{$node->[1]}) {  
3831                    $i = $_;                    $i = $_;
3832                    last INSCOPE;                    last INSCOPE;
3833                  } elsif ({                  } elsif ({
# Line 4492  sub _tree_construction_main ($) { Line 3851  sub _tree_construction_main ($) {
3851                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
3852                }                }
3853    
               ## As if <{current node}>  
               ## have an element in table scope  
               ## true by definition  
   
               ## Clear back to table body context  
               ## nop by definition  
   
3854                pop @{$self->{open_elements}};                pop @{$self->{open_elements}};
3855                $self->{insertion_mode} = 'in table';                $self->{insertion_mode} = IN_TABLE_IM;
3856                ## reprocess                !!!next-token;
3857                redo B;                redo B;
3858              } elsif ({              } elsif ({
3859                        body => 1, caption => 1, col => 1, colgroup => 1,                        body => 1, caption => 1, col => 1, colgroup => 1,
3860                        html => 1, td => 1, th => 1, tr => 1,                        html => 1, td => 1, th => 1,
3861                          tr => 1, # $self->{insertion_mode} == IN_ROW_IM
3862                          tbody => 1, tfoot => 1, thead => 1, # $self->{insertion_mode} == IN_TABLE_IM
3863                       }->{$token->{tag_name}}) {                       }->{$token->{tag_name}}) {
3864                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
3865                ## Ignore the token                ## Ignore the token
# Line 4515  sub _tree_construction_main ($) { Line 3869  sub _tree_construction_main ($) {
3869                #                #
3870              }              }
3871            } else {            } else {
3872              #              die "$0: $token->{type}: Unknown token type";
3873            }            }
3874              
3875            ## As if in table        !!!parse-error (type => 'in table:'.$token->{tag_name});
3876            !!!parse-error (type => 'in table:'.$token->{tag_name});  
3877            $in_body->($insert_to_foster);        $insert = $insert_to_foster;
3878            redo B;        #
3879          } elsif ($self->{insertion_mode} eq 'in row') {      } elsif ($self->{insertion_mode} == IN_COLUMN_GROUP_IM) {
3880            if ($token->{type} eq 'character') {            if ($token->{type} == CHARACTER_TOKEN) {
             ## NOTE: This is a "character in table" code clone.  
3881              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
3882                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
                 
3883                unless (length $token->{data}) {                unless (length $token->{data}) {
3884                  !!!next-token;                  !!!next-token;
3885                  redo B;                  redo B;
3886                }                }
3887              }              }
   
             !!!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});  
               } 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});  
             }  
3888                            
3889              !!!next-token;              #
3890              redo B;            } elsif ($token->{type} == START_TAG_TOKEN) {
3891            } elsif ($token->{type} eq 'start tag') {              if ($token->{tag_name} eq 'col') {
             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}};  
               }  
                 
3892                !!!insert-element ($token->{tag_name}, $token->{attributes});                !!!insert-element ($token->{tag_name}, $token->{attributes});
3893                $self->{insertion_mode} = 'in cell';                pop @{$self->{open_elements}};
   
               push @$active_formatting_elements, ['#marker', ''];  
                 
3894                !!!next-token;                !!!next-token;
3895                redo B;                redo B;
3896              } elsif ({              } else {
                       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;  
                 }  
               } # INSCOPE  
               unless (defined $i) {  
                 !!!parse-error (type => 'unmacthed 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';  
               ## 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>  
               ## 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>  
                 !!!next-token;  
                 redo B;  
               }  
                 
               ## generate implied end tags  
               if ({  
                    dd => 1, dt => 1, li => 1, p => 1,  
                    td => 1, th => 1, tr => 1,  
                    tbody => 1, tfoot=> 1, thead => 1,  
                   }->{$self->{open_elements}->[-1]->[1]}) {  
                 !!!back-token; # <table>  
                 $token = {type => 'end tag', tag_name => 'table'};  
                 !!!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]);  
               }  
   
               splice @{$self->{open_elements}}, $i;  
   
               $self->_reset_insertion_mode;  
   
               ## reprocess  
               redo B;  
             } else {  
3897                #                #
3898              }              }
3899            } elsif ($token->{type} eq 'end tag') {            } elsif ($token->{type} == END_TAG_TOKEN) {
3900              if ($token->{tag_name} eq 'tr') {              if ($token->{tag_name} eq 'colgroup') {
3901                ## have an element in table scope                if ($self->{open_elements}->[-1]->[1] eq 'html') {
3902                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});  
                 ## 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';  
               !!!next-token;  
               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;  
             } elsif ({  
                       tbody => 1, tfoot => 1, thead => 1,  
                      }->{$token->{tag_name}}) {  
               ## 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});  
3903                  ## Ignore the token                  ## Ignore the token
3904                  !!!next-token;                  !!!next-token;
3905                  redo B;                  redo B;
3906                }                } else {
3907                    pop @{$self->{open_elements}}; # colgroup
3908                ## As if </tr>                  $self->{insertion_mode} = IN_TABLE_IM;
               ## 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:tr');  
                 ## Ignore the token  
3909                  !!!next-token;                  !!!next-token;
3910                  redo B;                  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}};  
3911                }                }
3912                } elsif ($token->{tag_name} eq 'col') {
3913                pop @{$self->{open_elements}}; # tr                !!!parse-error (type => 'unmatched end tag:col');
               $self->{insertion_mode} = 'in table body';  
               ## reprocess  
               redo B;  
             } elsif ({  
                       body => 1, caption => 1, col => 1,  
                       colgroup => 1, html => 1, td => 1, th => 1,  
                      }->{$token->{tag_name}}) {  
               !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});  
3914                ## Ignore the token                ## Ignore the token
3915                !!!next-token;                !!!next-token;
3916                redo B;                redo B;
3917              } else {              } else {
3918                #                #
3919              }              }
3920            } else {            } else {
3921              #              #
3922            }            }
3923    
3924            ## As if in table            ## As if </colgroup>
3925            !!!parse-error (type => 'in table:'.$token->{tag_name});            if ($self->{open_elements}->[-1]->[1] eq 'html') {
3926            $in_body->($insert_to_foster);              !!!parse-error (type => 'unmatched end tag:colgroup');
3927            redo B;              ## Ignore the token
3928          } elsif ($self->{insertion_mode} eq 'in select') {              !!!next-token;
3929            if ($token->{type} eq 'character') {              redo B;
3930              } else {
3931                pop @{$self->{open_elements}}; # colgroup
3932                $self->{insertion_mode} = IN_TABLE_IM;
3933                ## reprocess
3934                redo B;
3935              }
3936        } elsif ($self->{insertion_mode} == IN_SELECT_IM) {
3937              if ($token->{type} == CHARACTER_TOKEN) {
3938              $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});              $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});
3939              !!!next-token;              !!!next-token;
3940              redo B;              redo B;
3941            } elsif ($token->{type} eq 'start tag') {            } elsif ($token->{type} == START_TAG_TOKEN) {
3942              if ($token->{tag_name} eq 'option') {              if ($token->{tag_name} eq 'option') {
3943                if ($self->{open_elements}->[-1]->[1] eq 'option') {                if ($self->{open_elements}->[-1]->[1] eq 'option') {
3944                  ## As if </option>                  ## As if </option>
# Line 4892  sub _tree_construction_main ($) { Line 3994  sub _tree_construction_main ($) {
3994              } else {              } else {
3995                #                #
3996              }              }
3997            } elsif ($token->{type} eq 'end tag') {            } elsif ($token->{type} == END_TAG_TOKEN) {
3998              if ($token->{tag_name} eq 'optgroup') {              if ($token->{tag_name} eq 'optgroup') {
3999                if ($self->{open_elements}->[-1]->[1] eq 'option' and                if ($self->{open_elements}->[-1]->[1] eq 'option' and
4000                    $self->{open_elements}->[-2]->[1] eq 'optgroup') {                    $self->{open_elements}->[-2]->[1] eq 'optgroup') {
# Line 5005  sub _tree_construction_main ($) { Line 4107  sub _tree_construction_main ($) {
4107            ## Ignore the token            ## Ignore the token
4108            !!!next-token;            !!!next-token;
4109            redo B;            redo B;
4110          } elsif ($self->{insertion_mode} eq 'after body') {      } elsif ($self->{insertion_mode} == AFTER_BODY_IM or
4111            if ($token->{type} eq 'character') {               $self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4112              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {        if ($token->{type} == CHARACTER_TOKEN) {
4113                my $data = $1;          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
4114                ## As if in body            my $data = $1;
4115                $reconstruct_active_formatting_elements->($insert_to_current);            ## As if in body
4116              $reconstruct_active_formatting_elements->($insert_to_current);
4117                                
4118                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
4119              
4120              unless (length $token->{data}) {
4121                !!!next-token;
4122                redo B;
4123              }
4124            }
4125            
4126            if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4127              !!!parse-error (type => 'after html:#character');
4128    
4129                unless (length $token->{data}) {            ## Reprocess in the "main" phase, "after body" insertion mode...
4130                  !!!next-token;          }
4131                  redo B;          
4132                }          ## "after body" insertion mode
4133              }          !!!parse-error (type => 'after body:#character');
4134                
4135              #          $self->{insertion_mode} = IN_BODY_IM;
4136              !!!parse-error (type => 'after body:#character');          ## reprocess
4137            } elsif ($token->{type} eq 'start tag') {          redo B;
4138              !!!parse-error (type => 'after body:'.$token->{tag_name});        } elsif ($token->{type} == START_TAG_TOKEN) {
4139              #          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4140            } elsif ($token->{type} eq 'end tag') {            !!!parse-error (type => 'after html:'.$token->{tag_name});
4141              if ($token->{tag_name} eq 'html') {            
4142                if (defined $self->{inner_html_node}) {            ## Reprocess in the "main" phase, "after body" insertion mode...
4143                  !!!parse-error (type => 'unmatched end tag:html');          }
4144                  ## Ignore the token  
4145                  !!!next-token;          ## "after body" insertion mode
4146                  redo B;          !!!parse-error (type => 'after body:'.$token->{tag_name});
4147                } else {  
4148                  $previous_insertion_mode = $self->{insertion_mode};          $self->{insertion_mode} = IN_BODY_IM;
4149                  $self->{insertion_mode} = 'trailing end';          ## reprocess
4150                  !!!next-token;          redo B;
4151                  redo B;        } elsif ($token->{type} == END_TAG_TOKEN) {
4152                }          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4153              } else {            !!!parse-error (type => 'after html:/'.$token->{tag_name});
4154                !!!parse-error (type => 'after body:/'.$token->{tag_name});            
4155              }            $self->{insertion_mode} = AFTER_BODY_IM;
4156              ## Reprocess in the "main" phase, "after body" insertion mode...
4157            }
4158    
4159            ## "after body" insertion mode
4160            if ($token->{tag_name} eq 'html') {
4161              if (defined $self->{inner_html_node}) {
4162                !!!parse-error (type => 'unmatched end tag:html');
4163                ## Ignore the token
4164                !!!next-token;
4165                redo B;
4166            } else {            } else {
4167              die "$0: $token->{type}: Unknown token type";              $self->{insertion_mode} = AFTER_HTML_BODY_IM;
4168                !!!next-token;
4169                redo B;
4170            }            }
4171            } else {
4172              !!!parse-error (type => 'after body:/'.$token->{tag_name});
4173    
4174            $self->{insertion_mode} = 'in body';            $self->{insertion_mode} = IN_BODY_IM;
4175            ## reprocess            ## reprocess
4176            redo B;            redo B;
4177      } elsif ($self->{insertion_mode} eq 'in frameset') {          }
4178        if ($token->{type} eq 'character') {        } else {
4179            die "$0: $token->{type}: Unknown token type";
4180          }
4181        } elsif ($self->{insertion_mode} == IN_FRAMESET_IM or
4182                 $self->{insertion_mode} == AFTER_FRAMESET_IM or
4183                 $self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
4184          if ($token->{type} == CHARACTER_TOKEN) {
4185          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {
4186            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
4187              
4188            unless (length $token->{data}) {            unless (length $token->{data}) {
4189              !!!next-token;              !!!next-token;
4190              redo B;              redo B;
4191            }            }
4192          }          }
4193            
4194            if ($token->{data} =~ s/^[^\x09\x0A\x0B\x0C\x20]+//) {
4195              if ($self->{insertion_mode} == IN_FRAMESET_IM) {
4196                !!!parse-error (type => 'in frameset:#character');
4197              } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) {
4198                !!!parse-error (type => 'after frameset:#character');
4199              } else { # "after html frameset"
4200                !!!parse-error (type => 'after html:#character');
4201    
4202                $self->{insertion_mode} = AFTER_FRAMESET_IM;
4203                ## Reprocess in the "main" phase, "after frameset"...
4204                !!!parse-error (type => 'after frameset:#character');
4205              }
4206              
4207              ## Ignore the token.
4208              if (length $token->{data}) {
4209                ## reprocess the rest of characters
4210              } else {
4211                !!!next-token;
4212              }
4213              redo B;
4214            }
4215            
4216            die qq[$0: Character "$token->{data}"];
4217          } elsif ($token->{type} == START_TAG_TOKEN) {
4218            if ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
4219              !!!parse-error (type => 'after html:'.$token->{tag_name});
4220    
4221          !!!parse-error (type => 'in frameset:#character');            $self->{insertion_mode} = AFTER_FRAMESET_IM;
4222          ## Ignore the token            ## Process in the "main" phase, "after frameset" insertion mode...
4223          !!!next-token;          }
4224          redo B;  
4225        } elsif ($token->{type} eq 'start tag') {          if ($token->{tag_name} eq 'frameset' and
4226          if ($token->{tag_name} eq 'frameset') {              $self->{insertion_mode} == IN_FRAMESET_IM) {
4227            !!!insert-element ($token->{tag_name}, $token->{attributes});            !!!insert-element ($token->{tag_name}, $token->{attributes});
4228            !!!next-token;            !!!next-token;
4229            redo B;            redo B;
4230          } elsif ($token->{tag_name} eq 'frame') {          } elsif ($token->{tag_name} eq 'frame' and
4231                     $self->{insertion_mode} == IN_FRAMESET_IM) {
4232            !!!insert-element ($token->{tag_name}, $token->{attributes});            !!!insert-element ($token->{tag_name}, $token->{attributes});
4233            pop @{$self->{open_elements}};            pop @{$self->{open_elements}};
4234            !!!next-token;            !!!next-token;
# Line 5078  sub _tree_construction_main ($) { Line 4238  sub _tree_construction_main ($) {
4238            $parse_rcdata->(CDATA_CONTENT_MODEL, $insert_to_current);            $parse_rcdata->(CDATA_CONTENT_MODEL, $insert_to_current);
4239            redo B;            redo B;
4240          } else {          } else {
4241            !!!parse-error (type => 'in frameset:'.$token->{tag_name});            if ($self->{insertion_mode} == IN_FRAMESET_IM) {
4242                !!!parse-error (type => 'in frameset:'.$token->{tag_name});
4243              } else {
4244                !!!parse-error (type => 'after frameset:'.$token->{tag_name});
4245              }
4246            ## Ignore the token            ## Ignore the token
4247            !!!next-token;            !!!next-token;
4248            redo B;            redo B;
4249          }          }
4250        } elsif ($token->{type} eq 'end tag') {        } elsif ($token->{type} == END_TAG_TOKEN) {
4251          if ($token->{tag_name} eq 'frameset') {          if ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
4252              !!!parse-error (type => 'after html:/'.$token->{tag_name});
4253    
4254              $self->{insertion_mode} = AFTER_FRAMESET_IM;
4255              ## Process in the "main" phase, "after frameset" insertion mode...
4256            }
4257    
4258            if ($token->{tag_name} eq 'frameset' and
4259                $self->{insertion_mode} == IN_FRAMESET_IM) {
4260            if ($self->{open_elements}->[-1]->[1] eq 'html' and            if ($self->{open_elements}->[-1]->[1] eq 'html' and
4261                @{$self->{open_elements}} == 1) {                @{$self->{open_elements}} == 1) {
4262              !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});              !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
# Line 5097  sub _tree_construction_main ($) { Line 4269  sub _tree_construction_main ($) {
4269    
4270            if (not defined $self->{inner_html_node} and            if (not defined $self->{inner_html_node} and
4271                $self->{open_elements}->[-1]->[1] ne 'frameset') {                $self->{open_elements}->[-1]->[1] ne 'frameset') {
4272              $self->{insertion_mode} = 'after frameset';              $self->{insertion_mode} = AFTER_FRAMESET_IM;
4273            }            }
4274            redo B;            redo B;
4275            } elsif ($token->{tag_name} eq 'html' and
4276                     $self->{insertion_mode} == AFTER_FRAMESET_IM) {
4277              $self->{insertion_mode} = AFTER_HTML_FRAMESET_IM;
4278              !!!next-token;
4279              redo B;
4280          } else {          } else {
4281            !!!parse-error (type => 'in frameset:/'.$token->{tag_name});            if ($self->{insertion_mode} == IN_FRAMESET_IM) {
4282                !!!parse-error (type => 'in frameset:/'.$token->{tag_name});
4283              } else {
4284                !!!parse-error (type => 'after frameset:/'.$token->{tag_name});
4285              }
4286            ## Ignore the token            ## Ignore the token
4287            !!!next-token;            !!!next-token;
4288            redo B;            redo B;
# Line 5109  sub _tree_construction_main ($) { Line 4290  sub _tree_construction_main ($) {
4290        } else {        } else {
4291          die "$0: $token->{type}: Unknown token type";          die "$0: $token->{type}: Unknown token type";
4292        }        }
     } elsif ($self->{insertion_mode} eq 'after frameset') {  
       if ($token->{type} eq 'character') {  
             if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {  
               $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);  
4293    
4294                unless (length $token->{data}) {        ## ISSUE: An issue in spec here
4295                  !!!next-token;      } else {
4296                  redo B;        die "$0: $self->{insertion_mode}: Unknown insertion mode";
4297                }      }
             }  
4298    
4299              if ($token->{data} =~ s/^[^\x09\x0A\x0B\x0C\x20]+//) {      ## "in body" insertion mode
4300                !!!parse-error (type => 'after frameset:#character');      if ($token->{type} == START_TAG_TOKEN) {
4301          if ($token->{tag_name} eq 'script') {
4302            ## NOTE: This is an "as if in head" code clone
4303            $script_start_tag->($insert);
4304            redo B;
4305          } elsif ($token->{tag_name} eq 'style') {
4306            ## NOTE: This is an "as if in head" code clone
4307            $parse_rcdata->(CDATA_CONTENT_MODEL, $insert);
4308            redo B;
4309          } elsif ({
4310                    base => 1, link => 1,
4311                   }->{$token->{tag_name}}) {
4312            ## NOTE: This is an "as if in head" code clone, only "-t" differs
4313            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4314            pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
4315            !!!next-token;
4316            redo B;
4317          } elsif ($token->{tag_name} eq 'meta') {
4318            ## NOTE: This is an "as if in head" code clone, only "-t" differs
4319            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4320            pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.
4321    
4322                ## Ignore the token.          unless ($self->{confident}) {
4323                if (length $token->{data}) {            my $charset;
4324                  ## reprocess the rest of characters            if ($token->{attributes}->{charset}) { ## TODO: And if supported
4325                } else {              $charset = $token->{attributes}->{charset}->{value};
4326                  !!!next-token;            }
4327                }            if ($token->{attributes}->{'http-equiv'}) {
4328                redo B;              ## ISSUE: Algorithm name in the spec was incorrect so that not linked to the definition.
4329              }              if ($token->{attributes}->{'http-equiv'}->{value}
4330                    =~ /\A[^;]*;[\x09-\x0D\x20]*charset[\x09-\x0D\x20]*=
4331                        [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'|
4332                        ([^"'\x09-\x0D\x20][^\x09-\x0D\x20]*))/x) {
4333                  $charset = defined $1 ? $1 : defined $2 ? $2 : $3;
4334                } ## TODO: And if supported
4335              }
4336              ## TODO: Change the encoding
4337            }
4338    
4339          die qq[$0: Character "$token->{data}"];          !!!next-token;
4340        } elsif ($token->{type} eq 'start tag') {          redo B;
4341          if ($token->{tag_name} eq 'noframes') {        } elsif ($token->{tag_name} eq 'title') {
4342            ## NOTE: As if in body.          !!!parse-error (type => 'in body:title');
4343            $parse_rcdata->(CDATA_CONTENT_MODEL, $insert_to_current);          ## NOTE: This is an "as if in head" code clone
4344            redo B;          $parse_rcdata->(RCDATA_CONTENT_MODEL, sub {
4345          } else {            if (defined $self->{head_element}) {
4346            !!!parse-error (type => 'after frameset:'.$token->{tag_name});              $self->{head_element}->append_child ($_[0]);
4347              } else {
4348                $insert->($_[0]);
4349              }
4350            });
4351            redo B;
4352          } elsif ($token->{tag_name} eq 'body') {
4353            !!!parse-error (type => 'in body:body');
4354                  
4355            if (@{$self->{open_elements}} == 1 or
4356                $self->{open_elements}->[1]->[1] ne 'body') {
4357            ## Ignore the token            ## Ignore the token
4358            } else {
4359              my $body_el = $self->{open_elements}->[1]->[0];
4360              for my $attr_name (keys %{$token->{attributes}}) {
4361                unless ($body_el->has_attribute_ns (undef, $attr_name)) {
4362                  $body_el->set_attribute_ns
4363                    (undef, [undef, $attr_name],
4364                     $token->{attributes}->{$attr_name}->{value});
4365                }
4366              }
4367            }
4368            !!!next-token;
4369            redo B;
4370          } elsif ({
4371                    address => 1, blockquote => 1, center => 1, dir => 1,
4372                    div => 1, dl => 1, fieldset => 1, listing => 1,
4373                    menu => 1, ol => 1, p => 1, ul => 1,
4374                    pre => 1,
4375                   }->{$token->{tag_name}}) {
4376            ## has a p element in scope
4377            INSCOPE: for (reverse @{$self->{open_elements}}) {
4378              if ($_->[1] eq 'p') {
4379                !!!back-token;
4380                $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4381                redo B;
4382              } elsif ({
4383                        table => 1, caption => 1, td => 1, th => 1,
4384                        button => 1, marquee => 1, object => 1, html => 1,
4385                       }->{$_->[1]}) {
4386                last INSCOPE;
4387              }
4388            } # INSCOPE
4389              
4390            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4391            if ($token->{tag_name} eq 'pre') {
4392              !!!next-token;
4393              if ($token->{type} == CHARACTER_TOKEN) {
4394                $token->{data} =~ s/^\x0A//;
4395                unless (length $token->{data}) {
4396                  !!!next-token;
4397                }
4398              }
4399            } else {
4400            !!!next-token;            !!!next-token;
           redo B;  
4401          }          }
4402        } elsif ($token->{type} eq 'end tag') {          redo B;
4403          if ($token->{tag_name} eq 'html') {        } elsif ($token->{tag_name} eq 'form') {
4404            $previous_insertion_mode = $self->{insertion_mode};          if (defined $self->{form_element}) {
4405            $self->{insertion_mode} = 'trailing end';            !!!parse-error (type => 'in form:form');
4406              ## Ignore the token
4407            !!!next-token;            !!!next-token;
4408            redo B;            redo B;
4409          } else {          } else {
4410            !!!parse-error (type => 'after frameset:/'.$token->{tag_name});            ## has a p element in scope
4411            ## Ignore the token            INSCOPE: for (reverse @{$self->{open_elements}}) {
4412                if ($_->[1] eq 'p') {
4413                  !!!back-token;
4414                  $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4415                  redo B;
4416                } elsif ({
4417                          table => 1, caption => 1, td => 1, th => 1,
4418                          button => 1, marquee => 1, object => 1, html => 1,
4419                         }->{$_->[1]}) {
4420                  last INSCOPE;
4421                }
4422              } # INSCOPE
4423                
4424              !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4425              $self->{form_element} = $self->{open_elements}->[-1]->[0];
4426            !!!next-token;            !!!next-token;
4427            redo B;            redo B;
4428          }          }
4429        } else {        } elsif ($token->{tag_name} eq 'li') {
4430          die "$0: $token->{type}: Unknown token type";          ## 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            ## Step 1
4445            my $i = -1;
4446            my $node = $self->{open_elements}->[$i];
4447            LI: {
4448              ## Step 2
4449              if ($node->[1] eq 'li') {
4450                if ($i != -1) {
4451                  !!!parse-error (type => 'end tag missing:'.
4452                                  $self->{open_elements}->[-1]->[1]);
4453                }
4454                splice @{$self->{open_elements}}, $i;
4455                last LI;
4456              }
4457              
4458              ## Step 3
4459              if (not $formatting_category->{$node->[1]} and
4460                  #not $phrasing_category->{$node->[1]} and
4461                  ($special_category->{$node->[1]} or
4462                   $scoping_category->{$node->[1]}) and
4463                  $node->[1] ne 'address' and $node->[1] ne 'div') {
4464                last LI;
4465              }
4466              
4467              ## Step 4
4468              $i--;
4469              $node = $self->{open_elements}->[$i];
4470              redo LI;
4471            } # LI
4472              
4473            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4474            !!!next-token;
4475            redo B;
4476          } elsif ($token->{tag_name} eq 'dd' or $token->{tag_name} eq 'dt') {
4477            ## has a p element in scope
4478            INSCOPE: for (reverse @{$self->{open_elements}}) {
4479              if ($_->[1] eq 'p') {
4480                !!!back-token;
4481                $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4482                redo B;
4483              } elsif ({
4484                        table => 1, caption => 1, td => 1, th => 1,
4485                        button => 1, marquee => 1, object => 1, html => 1,
4486                       }->{$_->[1]}) {
4487                last INSCOPE;
4488              }
4489            } # INSCOPE
4490              
4491            ## Step 1
4492            my $i = -1;
4493            my $node = $self->{open_elements}->[$i];
4494            LI: {
4495              ## Step 2
4496              if ($node->[1] eq 'dt' or $node->[1] eq 'dd') {
4497                if ($i != -1) {
4498                  !!!parse-error (type => 'end tag missing:'.
4499                                  $self->{open_elements}->[-1]->[1]);
4500                }
4501                splice @{$self->{open_elements}}, $i;
4502                last LI;
4503              }
4504              
4505              ## Step 3
4506              if (not $formatting_category->{$node->[1]} and
4507                  #not $phrasing_category->{$node->[1]} and
4508                  ($special_category->{$node->[1]} or
4509                   $scoping_category->{$node->[1]}) and
4510                  $node->[1] ne 'address' and $node->[1] ne 'div') {
4511                last LI;
4512              }
4513              
4514              ## Step 4
4515              $i--;
4516              $node = $self->{open_elements}->[$i];
4517              redo LI;
4518            } # LI
4519              
4520            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4521            !!!next-token;
4522            redo B;
4523          } elsif ($token->{tag_name} eq 'plaintext') {
4524            ## has a p element in scope
4525            INSCOPE: for (reverse @{$self->{open_elements}}) {
4526              if ($_->[1] eq 'p') {
4527                !!!back-token;
4528                $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4529                redo B;
4530              } elsif ({
4531                        table => 1, caption => 1, td => 1, th => 1,
4532                        button => 1, marquee => 1, object => 1, html => 1,
4533                       }->{$_->[1]}) {
4534                last INSCOPE;
4535              }
4536            } # INSCOPE
4537              
4538            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4539              
4540            $self->{content_model} = PLAINTEXT_CONTENT_MODEL;
4541              
4542            !!!next-token;
4543            redo B;
4544          } elsif ({
4545                    h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,
4546                   }->{$token->{tag_name}}) {
4547            ## has a p element in scope
4548            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4549              my $node = $self->{open_elements}->[$_];
4550              if ($node->[1] eq 'p') {
4551                !!!back-token;
4552                $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4553                redo B;
4554              } elsif ({
4555                        table => 1, caption => 1, td => 1, th => 1,
4556                        button => 1, marquee => 1, object => 1, html => 1,
4557                       }->{$node->[1]}) {
4558                last INSCOPE;
4559              }
4560            } # INSCOPE
4561              
4562            ## NOTE: See <http://html5.org/tools/web-apps-tracker?from=925&to=926>
4563            ## has an element in scope
4564            #my $i;
4565            #INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4566            #  my $node = $self->{open_elements}->[$_];
4567            #  if ({
4568            #       h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,
4569            #      }->{$node->[1]}) {
4570            #    $i = $_;
4571            #    last INSCOPE;
4572            #  } elsif ({
4573            #            table => 1, caption => 1, td => 1, th => 1,
4574            #            button => 1, marquee => 1, object => 1, html => 1,
4575            #           }->{$node->[1]}) {
4576            #    last INSCOPE;
4577            #  }
4578            #} # INSCOPE
4579            #  
4580            #if (defined $i) {
4581            #  !!! parse-error (type => 'in hn:hn');
4582            #  splice @{$self->{open_elements}}, $i;
4583            #}
4584              
4585            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4586              
4587            !!!next-token;
4588            redo B;
4589          } elsif ($token->{tag_name} eq 'a') {
4590            AFE: for my $i (reverse 0..$#$active_formatting_elements) {
4591              my $node = $active_formatting_elements->[$i];
4592              if ($node->[1] eq 'a') {
4593                !!!parse-error (type => 'in a:a');
4594                
4595                !!!back-token;
4596                $token = {type => END_TAG_TOKEN, tag_name => 'a'};
4597                $formatting_end_tag->($token->{tag_name});
4598                
4599                AFE2: for (reverse 0..$#$active_formatting_elements) {
4600                  if ($active_formatting_elements->[$_]->[0] eq $node->[0]) {
4601                    splice @$active_formatting_elements, $_, 1;
4602                    last AFE2;
4603                  }
4604                } # AFE2
4605                OE: for (reverse 0..$#{$self->{open_elements}}) {
4606                  if ($self->{open_elements}->[$_]->[0] eq $node->[0]) {
4607                    splice @{$self->{open_elements}}, $_, 1;
4608                    last OE;
4609                  }
4610                } # OE
4611                last AFE;
4612              } elsif ($node->[0] eq '#marker') {
4613                last AFE;
4614              }
4615            } # AFE
4616              
4617            $reconstruct_active_formatting_elements->($insert_to_current);
4618    
4619        ## ISSUE: An issue in spec here          !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4620      } elsif ($self->{insertion_mode} eq 'trailing end') {          push @$active_formatting_elements, $self->{open_elements}->[-1];
4621        ## states in the main stage is preserved yet # MUST  
4622                  !!!next-token;
4623        if ($token->{type} eq 'character') {          redo B;
4624          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {        } elsif ({
4625            my $data = $1;                  b => 1, big => 1, em => 1, font => 1, i => 1,
4626            ## As if in the main phase.                  s => 1, small => 1, strile => 1,
4627            ## NOTE: The insertion mode in the main phase                  strong => 1, tt => 1, u => 1,
4628            ## just before the phase has been changed to the trailing                 }->{$token->{tag_name}}) {
4629            ## end phase is either "after body" or "after frameset".          $reconstruct_active_formatting_elements->($insert_to_current);
4630            $reconstruct_active_formatting_elements->($insert_to_current);          
4631            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4632            push @$active_formatting_elements, $self->{open_elements}->[-1];
4633            
4634            !!!next-token;
4635            redo B;
4636          } elsif ($token->{tag_name} eq 'nobr') {
4637            $reconstruct_active_formatting_elements->($insert_to_current);
4638    
4639            ## has a |nobr| element in scope
4640            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4641              my $node = $self->{open_elements}->[$_];
4642              if ($node->[1] eq 'nobr') {
4643                !!!parse-error (type => 'not closed:nobr');
4644                !!!back-token;
4645                $token = {type => END_TAG_TOKEN, tag_name => 'nobr'};
4646                redo B;
4647              } elsif ({
4648                        table => 1, caption => 1, td => 1, th => 1,
4649                        button => 1, marquee => 1, object => 1, html => 1,
4650                       }->{$node->[1]}) {
4651                last INSCOPE;
4652              }
4653            } # INSCOPE
4654            
4655            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4656            push @$active_formatting_elements, $self->{open_elements}->[-1];
4657            
4658            !!!next-token;
4659            redo B;
4660          } elsif ($token->{tag_name} eq 'button') {
4661            ## has a button element in scope
4662            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4663              my $node = $self->{open_elements}->[$_];
4664              if ($node->[1] eq 'button') {
4665                !!!parse-error (type => 'in button:button');
4666                !!!back-token;
4667                $token = {type => END_TAG_TOKEN, tag_name => 'button'};
4668                redo B;
4669              } elsif ({
4670                        table => 1, caption => 1, td => 1, th => 1,
4671                        button => 1, marquee => 1, object => 1, html => 1,
4672                       }->{$node->[1]}) {
4673                last INSCOPE;
4674              }
4675            } # INSCOPE
4676                        
4677            $self->{open_elements}->[-1]->[0]->manakai_append_text ($data);          $reconstruct_active_formatting_elements->($insert_to_current);
4678                        
4679            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4680            push @$active_formatting_elements, ['#marker', ''];
4681    
4682            !!!next-token;
4683            redo B;
4684          } elsif ($token->{tag_name} eq 'marquee' or
4685                   $token->{tag_name} eq 'object') {
4686            $reconstruct_active_formatting_elements->($insert_to_current);
4687            
4688            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4689            push @$active_formatting_elements, ['#marker', ''];
4690            
4691            !!!next-token;
4692            redo B;
4693          } elsif ($token->{tag_name} eq 'xmp') {
4694            $reconstruct_active_formatting_elements->($insert_to_current);
4695            $parse_rcdata->(CDATA_CONTENT_MODEL, $insert);
4696            redo B;
4697          } elsif ($token->{tag_name} eq 'table') {
4698            ## has a p element in scope
4699            INSCOPE: for (reverse @{$self->{open_elements}}) {
4700              if ($_->[1] eq 'p') {
4701                !!!back-token;
4702                $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4703                redo B;
4704              } elsif ({
4705                        table => 1, caption => 1, td => 1, th => 1,
4706                        button => 1, marquee => 1, object => 1, html => 1,
4707                       }->{$_->[1]}) {
4708                last INSCOPE;
4709              }
4710            } # INSCOPE
4711              
4712            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4713              
4714            $self->{insertion_mode} = IN_TABLE_IM;
4715              
4716            !!!next-token;
4717            redo B;
4718          } elsif ({
4719                    area => 1, basefont => 1, bgsound => 1, br => 1,
4720                    embed => 1, img => 1, param => 1, spacer => 1, wbr => 1,
4721                    image => 1,
4722                   }->{$token->{tag_name}}) {
4723            if ($token->{tag_name} eq 'image') {
4724              !!!parse-error (type => 'image');
4725              $token->{tag_name} = 'img';
4726            }
4727    
4728            ## NOTE: There is an "as if <br>" code clone.
4729            $reconstruct_active_formatting_elements->($insert_to_current);
4730            
4731            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4732            pop @{$self->{open_elements}};
4733            
4734            !!!next-token;
4735            redo B;
4736          } elsif ($token->{tag_name} eq 'hr') {
4737            ## has a p element in scope
4738            INSCOPE: for (reverse @{$self->{open_elements}}) {
4739              if ($_->[1] eq 'p') {
4740                !!!back-token;
4741                $token = {type => END_TAG_TOKEN, tag_name => 'p'};
4742                redo B;
4743              } elsif ({
4744                        table => 1, caption => 1, td => 1, th => 1,
4745                        button => 1, marquee => 1, object => 1, html => 1,
4746                       }->{$_->[1]}) {
4747                last INSCOPE;
4748              }
4749            } # INSCOPE
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 'input') {
4757            $reconstruct_active_formatting_elements->($insert_to_current);
4758            
4759            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4760            ## TODO: associate with $self->{form_element} if defined
4761            pop @{$self->{open_elements}};
4762            
4763            !!!next-token;
4764            redo B;
4765          } elsif ($token->{tag_name} eq 'isindex') {
4766            !!!parse-error (type => 'isindex');
4767            
4768            if (defined $self->{form_element}) {
4769              ## Ignore the token
4770              !!!next-token;
4771              redo B;
4772            } else {
4773              my $at = $token->{attributes};
4774              my $form_attrs;
4775              $form_attrs->{action} = $at->{action} if $at->{action};
4776              my $prompt_attr = $at->{prompt};
4777              $at->{name} = {name => 'name', value => 'isindex'};
4778              delete $at->{action};
4779              delete $at->{prompt};
4780              my @tokens = (
4781                            {type => START_TAG_TOKEN, tag_name => 'form',
4782                             attributes => $form_attrs},
4783                            {type => START_TAG_TOKEN, tag_name => 'hr'},
4784                            {type => START_TAG_TOKEN, tag_name => 'p'},
4785                            {type => START_TAG_TOKEN, tag_name => 'label'},
4786                           );
4787              if ($prompt_attr) {
4788                push @tokens, {type => CHARACTER_TOKEN, data => $prompt_attr->{value}};
4789              } else {
4790                push @tokens, {type => CHARACTER_TOKEN,
4791                               data => 'This is a searchable index. Insert your search keywords here: '}; # SHOULD
4792                ## TODO: make this configurable
4793              }
4794              push @tokens,
4795                            {type => START_TAG_TOKEN, tag_name => 'input', attributes => $at},
4796                            #{type => CHARACTER_TOKEN, data => ''}, # SHOULD
4797                            {type => END_TAG_TOKEN, tag_name => 'label'},
4798                            {type => END_TAG_TOKEN, tag_name => 'p'},
4799                            {type => START_TAG_TOKEN, tag_name => 'hr'},
4800                            {type => END_TAG_TOKEN, tag_name => 'form'};
4801              $token = shift @tokens;
4802              !!!back-token (@tokens);
4803              redo B;
4804            }
4805          } elsif ($token->{tag_name} eq 'textarea') {
4806            my $tag_name = $token->{tag_name};
4807            my $el;
4808            !!!create-element ($el, $token->{tag_name}, $token->{attributes});
4809            
4810            ## TODO: $self->{form_element} if defined
4811            $self->{content_model} = RCDATA_CONTENT_MODEL;
4812            delete $self->{escape}; # MUST
4813            
4814            $insert->($el);
4815            
4816            my $text = '';
4817            !!!next-token;
4818            if ($token->{type} == CHARACTER_TOKEN) {
4819              $token->{data} =~ s/^\x0A//;
4820            unless (length $token->{data}) {            unless (length $token->{data}) {
4821              !!!next-token;              !!!next-token;
             redo B;  
4822            }            }
4823          }          }
4824            while ($token->{type} == CHARACTER_TOKEN) {
4825              $text .= $token->{data};
4826              !!!next-token;
4827            }
4828            if (length $text) {
4829              $el->manakai_append_text ($text);
4830            }
4831            
4832            $self->{content_model} = PCDATA_CONTENT_MODEL;
4833            
4834            if ($token->{type} == END_TAG_TOKEN and
4835                $token->{tag_name} eq $tag_name) {
4836              ## Ignore the token
4837            } else {
4838              !!!parse-error (type => 'in RCDATA:#'.$token->{type});
4839            }
4840            !!!next-token;
4841            redo B;
4842          } elsif ({
4843                    iframe => 1,
4844                    noembed => 1,
4845                    noframes => 1,
4846                    noscript => 0, ## TODO: 1 if scripting is enabled
4847                   }->{$token->{tag_name}}) {
4848            ## NOTE: There are two "as if in body" code clones.
4849            $parse_rcdata->(CDATA_CONTENT_MODEL, $insert);
4850            redo B;
4851          } elsif ($token->{tag_name} eq 'select') {
4852            $reconstruct_active_formatting_elements->($insert_to_current);
4853            
4854            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4855            
4856            $self->{insertion_mode} = IN_SELECT_IM;
4857            !!!next-token;
4858            redo B;
4859          } elsif ({
4860                    caption => 1, col => 1, colgroup => 1, frame => 1,
4861                    frameset => 1, head => 1, option => 1, optgroup => 1,
4862                    tbody => 1, td => 1, tfoot => 1, th => 1,
4863                    thead => 1, tr => 1,
4864                   }->{$token->{tag_name}}) {
4865            !!!parse-error (type => 'in body:'.$token->{tag_name});
4866            ## Ignore the token
4867            !!!next-token;
4868            redo B;
4869            
4870            ## ISSUE: An issue on HTML5 new elements in the spec.
4871          } else {
4872            $reconstruct_active_formatting_elements->($insert_to_current);
4873            
4874            !!!insert-element-t ($token->{tag_name}, $token->{attributes});
4875            
4876            !!!next-token;
4877            redo B;
4878          }
4879        } elsif ($token->{type} == END_TAG_TOKEN) {
4880          if ($token->{tag_name} eq 'body') {
4881            if (@{$self->{open_elements}} > 1 and
4882                $self->{open_elements}->[1]->[1] eq 'body') {
4883              for (@{$self->{open_elements}}) {
4884                unless ({
4885                           dd => 1, dt => 1, li => 1, p => 1, td => 1,
4886                           th => 1, tr => 1, body => 1, html => 1,
4887                         tbody => 1, tfoot => 1, thead => 1,
4888                        }->{$_->[1]}) {
4889                  !!!parse-error (type => 'not closed:'.$_->[1]);
4890                }
4891              }
4892    
4893          !!!parse-error (type => 'after html:#character');            $self->{insertion_mode} = AFTER_BODY_IM;
4894          $self->{insertion_mode} = $previous_insertion_mode;            !!!next-token;
4895          ## reprocess            redo B;
4896            } else {
4897              !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
4898              ## Ignore the token
4899              !!!next-token;
4900              redo B;
4901            }
4902          } elsif ($token->{tag_name} eq 'html') {
4903            if (@{$self->{open_elements}} > 1 and $self->{open_elements}->[1]->[1] eq 'body') {
4904              ## ISSUE: There is an issue in the spec.
4905              if ($self->{open_elements}->[-1]->[1] ne 'body') {
4906                !!!parse-error (type => 'not closed:'.$self->{open_elements}->[1]->[1]);
4907              }
4908              $self->{insertion_mode} = AFTER_BODY_IM;
4909              ## reprocess
4910              redo B;
4911            } else {
4912              !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
4913              ## Ignore the token
4914              !!!next-token;
4915              redo B;
4916            }
4917          } elsif ({
4918                    address => 1, blockquote => 1, center => 1, dir => 1,
4919                    div => 1, dl => 1, fieldset => 1, listing => 1,
4920                    menu => 1, ol => 1, pre => 1, ul => 1,
4921                    p => 1,
4922                    dd => 1, dt => 1, li => 1,
4923                    button => 1, marquee => 1, object => 1,
4924                   }->{$token->{tag_name}}) {
4925            ## has an element in scope
4926            my $i;
4927            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4928              my $node = $self->{open_elements}->[$_];
4929              if ($node->[1] eq $token->{tag_name}) {
4930                ## generate implied end tags
4931                if ({
4932                     dd => ($token->{tag_name} ne 'dd'),
4933                     dt => ($token->{tag_name} ne 'dt'),
4934                     li => ($token->{tag_name} ne 'li'),
4935                     p => ($token->{tag_name} ne 'p'),
4936                     td => 1, th => 1, tr => 1,
4937                     tbody => 1, tfoot=> 1, thead => 1,
4938                    }->{$self->{open_elements}->[-1]->[1]}) {
4939                  !!!back-token;
4940                  $token = {type => END_TAG_TOKEN,
4941                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
4942                  redo B;
4943                }
4944                $i = $_;
4945                last INSCOPE unless $token->{tag_name} eq 'p';
4946              } elsif ({
4947                        table => 1, caption => 1, td => 1, th => 1,
4948                        button => 1, marquee => 1, object => 1, html => 1,
4949                       }->{$node->[1]}) {
4950                last INSCOPE;
4951              }
4952            } # INSCOPE
4953            
4954            if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {
4955              if (defined $i) {
4956                !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
4957              } else {
4958                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
4959              }
4960            }
4961            
4962            if (defined $i) {
4963              splice @{$self->{open_elements}}, $i;
4964            } elsif ($token->{tag_name} eq 'p') {
4965              ## As if <p>, then reprocess the current token
4966              my $el;
4967              !!!create-element ($el, 'p');
4968              $insert->($el);
4969            }
4970            $clear_up_to_marker->()
4971              if {
4972                button => 1, marquee => 1, object => 1,
4973              }->{$token->{tag_name}};
4974            !!!next-token;
4975          redo B;          redo B;
4976        } elsif ($token->{type} eq 'start tag') {        } elsif ($token->{tag_name} eq 'form') {
4977          !!!parse-error (type => 'after html:'.$token->{tag_name});          ## has an element in scope
4978          $self->{insertion_mode} = $previous_insertion_mode;          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4979          ## reprocess            my $node = $self->{open_elements}->[$_];
4980              if ($node->[1] eq $token->{tag_name}) {
4981                ## generate implied end tags
4982                if ({
4983                     dd => 1, dt => 1, li => 1, p => 1,
4984                     td => 1, th => 1, tr => 1,
4985                     tbody => 1, tfoot=> 1, thead => 1,
4986                    }->{$self->{open_elements}->[-1]->[1]}) {
4987                  !!!back-token;
4988                  $token = {type => END_TAG_TOKEN,
4989                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
4990                  redo B;
4991                }
4992                last INSCOPE;
4993              } elsif ({
4994                        table => 1, caption => 1, td => 1, th => 1,
4995                        button => 1, marquee => 1, object => 1, html => 1,
4996                       }->{$node->[1]}) {
4997                last INSCOPE;
4998              }
4999            } # INSCOPE
5000            
5001            if ($self->{open_elements}->[-1]->[1] eq $token->{tag_name}) {
5002              pop @{$self->{open_elements}};
5003            } else {
5004              !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5005            }
5006    
5007            undef $self->{form_element};
5008            !!!next-token;
5009          redo B;          redo B;
5010        } elsif ($token->{type} eq 'end tag') {        } elsif ({
5011          !!!parse-error (type => 'after html:/'.$token->{tag_name});                  h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,
5012          $self->{insertion_mode} = $previous_insertion_mode;                 }->{$token->{tag_name}}) {
5013          ## reprocess          ## has an element in scope
5014            my $i;
5015            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5016              my $node = $self->{open_elements}->[$_];
5017              if ({
5018                   h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,
5019                  }->{$node->[1]}) {
5020                ## generate implied end tags
5021                if ({
5022                     dd => 1, dt => 1, li => 1, p => 1,
5023                     td => 1, th => 1, tr => 1,
5024                     tbody => 1, tfoot=> 1, thead => 1,
5025                    }->{$self->{open_elements}->[-1]->[1]}) {
5026                  !!!back-token;
5027                  $token = {type => END_TAG_TOKEN,
5028                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
5029                  redo B;
5030                }
5031                $i = $_;
5032                last INSCOPE;
5033              } elsif ({
5034                        table => 1, caption => 1, td => 1, th => 1,
5035                        button => 1, marquee => 1, object => 1, html => 1,
5036                       }->{$node->[1]}) {
5037                last INSCOPE;
5038              }
5039            } # INSCOPE
5040            
5041            if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {
5042              !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5043            }
5044            
5045            splice @{$self->{open_elements}}, $i if defined $i;
5046            !!!next-token;
5047            redo B;
5048          } elsif ({
5049                    a => 1,
5050                    b => 1, big => 1, em => 1, font => 1, i => 1,
5051                    nobr => 1, s => 1, small => 1, strile => 1,
5052                    strong => 1, tt => 1, u => 1,
5053                   }->{$token->{tag_name}}) {
5054            $formatting_end_tag->($token->{tag_name});
5055            redo B;
5056          } elsif ($token->{tag_name} eq 'br') {
5057            !!!parse-error (type => 'unmatched end tag:br');
5058    
5059            ## As if <br>
5060            $reconstruct_active_formatting_elements->($insert_to_current);
5061            
5062            my $el;
5063            !!!create-element ($el, 'br');
5064            $insert->($el);
5065            
5066            ## Ignore the token.
5067            !!!next-token;
5068          redo B;          redo B;
5069          } elsif ({
5070                    caption => 1, col => 1, colgroup => 1, frame => 1,
5071                    frameset => 1, head => 1, option => 1, optgroup => 1,
5072                    tbody => 1, td => 1, tfoot => 1, th => 1,
5073                    thead => 1, tr => 1,
5074                    area => 1, basefont => 1, bgsound => 1,
5075                    embed => 1, hr => 1, iframe => 1, image => 1,
5076                    img => 1, input => 1, isindex => 1, noembed => 1,
5077                    noframes => 1, param => 1, select => 1, spacer => 1,
5078                    table => 1, textarea => 1, wbr => 1,
5079                    noscript => 0, ## TODO: if scripting is enabled
5080                   }->{$token->{tag_name}}) {
5081            !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
5082            ## Ignore the token
5083            !!!next-token;
5084            redo B;
5085            
5086            ## ISSUE: Issue on HTML5 new elements in spec
5087            
5088        } else {        } else {
5089          die "$0: $token->{type}: Unknown token";          ## Step 1
5090            my $node_i = -1;
5091            my $node = $self->{open_elements}->[$node_i];
5092    
5093            ## Step 2
5094            S2: {
5095              if ($node->[1] eq $token->{tag_name}) {
5096                ## Step 1
5097                ## generate implied end tags
5098                if ({
5099                     dd => 1, dt => 1, li => 1, p => 1,
5100                     td => 1, th => 1, tr => 1,
5101                     tbody => 1, tfoot => 1, thead => 1,
5102                    }->{$self->{open_elements}->[-1]->[1]}) {
5103                  !!!back-token;
5104                  $token = {type => END_TAG_TOKEN,
5105                            tag_name => $self->{open_elements}->[-1]->[1]}; # MUST
5106                  redo B;
5107                }
5108            
5109                ## Step 2
5110                if ($token->{tag_name} ne $self->{open_elements}->[-1]->[1]) {
5111                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]);
5112                }
5113                
5114                ## Step 3
5115                splice @{$self->{open_elements}}, $node_i;
5116    
5117                !!!next-token;
5118                last S2;
5119              } else {
5120                ## Step 3
5121                if (not $formatting_category->{$node->[1]} and
5122                    #not $phrasing_category->{$node->[1]} and
5123                    ($special_category->{$node->[1]} or
5124                     $scoping_category->{$node->[1]})) {
5125                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name});
5126                  ## Ignore the token
5127                  !!!next-token;
5128                  last S2;
5129                }
5130              }
5131              
5132              ## Step 4
5133              $node_i--;
5134              $node = $self->{open_elements}->[$node_i];
5135              
5136              ## Step 5;
5137              redo S2;
5138            } # S2
5139            redo B;
5140        }        }
     } else {  
       die "$0: $self->{insertion_mode}: Unknown insertion mode";  
5141      }      }
5142        redo B;
5143    } # B    } # B
5144    
5145      ## NOTE: The "trailing end" phase in HTML5 is split into
5146      ## two insertion modes: "after html body" and "after html frameset".
5147      ## NOTE: States in the main stage is preserved while
5148      ## the parser stays in the trailing end phase. # MUST
5149    
5150    ## Stop parsing # MUST    ## Stop parsing # MUST
5151        
5152    ## TODO: script stuffs    ## TODO: script stuffs
Legend:
Removed from v.1.44  
changed lines
  Added in v.1.55
admin@suikawiki.org
 ViewVC Help
Powered by ViewVC 1.1.24