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

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

Parent Directory | Revision Log | View Patch Patch

-revision 1.76 by wakaba,
Mon Mar  3 09:17:10 2008 UTC
+revision 1.98 by wakaba,
Sun Mar  9 03:23:43 2008 UTC
 Line 304 
 sub ROW_IMS ()        { 0b10000000 }
  sub BODY_AFTER_IMS () { 0b100000000 }
  sub FRAME_IMS ()      { 0b1000000000 }
+ ## NOTE: "initial" and "before html" insertion modes have no constants.
+ ## NOTE: "after after body" insertion mode.
  sub AFTER_HTML_BODY_IM () { AFTER_HTML_IMS | BODY_AFTER_IMS }
+ ## NOTE: "after after frameset" insertion mode.
  sub AFTER_HTML_FRAMESET_IM () { AFTER_HTML_IMS | FRAME_IMS }
  sub IN_HEAD_IM () { HEAD_IMS | 0b00 }
  sub IN_HEAD_NOSCRIPT_IM () { HEAD_IMS | 0b01 }
  sub AFTER_HEAD_IM () { HEAD_IMS | 0b10 }
-Line 387 
 sub _get_next_token ($) {
+Line 393 
 sub _get_next_token ($) {
        if ($self->{next_char} == 0x0026) { # &
          if ($self->{content_model} & CM_ENTITY and # PCDATA | RCDATA
              not $self->{escape}) {
+           !!!cp (1);
            $self->{state} = ENTITY_DATA_STATE;
            !!!next-input-character;
            redo A;
          } else {
+           !!!cp (2);
            #
          }
        } elsif ($self->{next_char} == 0x002D) { # -
-Line 399 
 sub _get_next_token ($) {
+Line 407 
 sub _get_next_token ($) {
              if ($self->{prev_char}->[0] == 0x002D and # -
                  $self->{prev_char}->[1] == 0x0021 and # !
                  $self->{prev_char}->[2] == 0x003C) { # <
+               !!!cp (3);
                $self->{escape} = 1;
+             } else {
+               !!!cp (4);
              }
+           } else {
+             !!!cp (5);
            }
          }
-Line 409 
 sub _get_next_token ($) {
+Line 422 
 sub _get_next_token ($) {
          if ($self->{content_model} & CM_FULL_MARKUP or # PCDATA
              (($self->{content_model} & CM_LIMITED_MARKUP) and # CDATA | RCDATA
               not $self->{escape})) {
+           !!!cp (6);
            $self->{state} = TAG_OPEN_STATE;
            !!!next-input-character;
            redo A;
          } else {
+           !!!cp (7);
            #
          }
        } elsif ($self->{next_char} == 0x003E) { # >
-Line 420 
 sub _get_next_token ($) {
+Line 435 
 sub _get_next_token ($) {
              ($self->{content_model} & CM_LIMITED_MARKUP)) { # RCDATA | CDATA
            if ($self->{prev_char}->[0] == 0x002D and # -
                $self->{prev_char}->[1] == 0x002D) { # -
+             !!!cp (8);
              delete $self->{escape};
+           } else {
+             !!!cp (9);
            }
+         } else {
+           !!!cp (10);
          }
          #
        } elsif ($self->{next_char} == -1) {
+         !!!cp (11);
          !!!emit ({type => END_OF_FILE_TOKEN});
          last A; ## TODO: ok?
+       } else {
+         !!!cp (12);
        }
        # Anything else
        my $token = {type => CHARACTER_TOKEN,
-Line 447 
 sub _get_next_token ($) {
+Line 470 
 sub _get_next_token ($) {
        # next-input-character is already done
        unless (defined $token) {
+         !!!cp (13);
          !!!emit ({type => CHARACTER_TOKEN, data => '&'});
        } else {
+         !!!cp (14);
          !!!emit ($token);
        }
-Line 456 
 sub _get_next_token ($) {
+Line 481 
 sub _get_next_token ($) {
      } elsif ($self->{state} == TAG_OPEN_STATE) {
        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
          if ($self->{next_char} == 0x002F) { # /
+           !!!cp (15);
            !!!next-input-character;
            $self->{state} = CLOSE_TAG_OPEN_STATE;
            redo A;
          } else {
+           !!!cp (16);
            ## reconsume
            $self->{state} = DATA_STATE;
-Line 469 
 sub _get_next_token ($) {
+Line 496 
 sub _get_next_token ($) {
          }
        } elsif ($self->{content_model} & CM_FULL_MARKUP) { # PCDATA
          if ($self->{next_char} == 0x0021) { # !
+           !!!cp (17);
            $self->{state} = MARKUP_DECLARATION_OPEN_STATE;
            !!!next-input-character;
            redo A;
          } elsif ($self->{next_char} == 0x002F) { # /
+           !!!cp (18);
            $self->{state} = CLOSE_TAG_OPEN_STATE;
            !!!next-input-character;
            redo A;
          } elsif (0x0041 <= $self->{next_char} and
                   $self->{next_char} <= 0x005A) { # A..Z
+           !!!cp (19);
            $self->{current_token}
              = {type => START_TAG_TOKEN,
                 tag_name => chr ($self->{next_char} + 0x0020)};
-Line 486 
 sub _get_next_token ($) {
+Line 516 
 sub _get_next_token ($) {
            redo A;
          } elsif (0x0061 <= $self->{next_char} and
                   $self->{next_char} <= 0x007A) { # a..z
+           !!!cp (20);
            $self->{current_token} = {type => START_TAG_TOKEN,
                              tag_name => chr ($self->{next_char})};
            $self->{state} = TAG_NAME_STATE;
            !!!next-input-character;
            redo A;
          } elsif ($self->{next_char} == 0x003E) { # >
+           !!!cp (21);
            !!!parse-error (type => 'empty start tag');
            $self->{state} = DATA_STATE;
            !!!next-input-character;
-Line 500 
 sub _get_next_token ($) {
+Line 532 
 sub _get_next_token ($) {
            redo A;
          } elsif ($self->{next_char} == 0x003F) { # ?
+           !!!cp (22);
            !!!parse-error (type => 'pio');
            $self->{state} = BOGUS_COMMENT_STATE;
            ## $self->{next_char} is intentionally left as is
            redo A;
          } else {
+           !!!cp (23);
            !!!parse-error (type => 'bare stago');
            $self->{state} = DATA_STATE;
            ## reconsume
-Line 526 
 sub _get_next_token ($) {
+Line 560 
 sub _get_next_token ($) {
              my $c = ord substr ($self->{last_emitted_start_tag_name}, $i, 1);
              my $C = 0x0061 <= $c && $c <= 0x007A ? $c - 0x0020 : $c;
              if ($self->{next_char} == $c or $self->{next_char} == $C) {
+               !!!cp (24);
                !!!next-input-character;
                next TAGNAME;
              } else {
+               !!!cp (25);
                $self->{next_char} = shift @next_char; # reconsume
                !!!back-next-input-character (@next_char);
                $self->{state} = DATA_STATE;
-Line 548 
 sub _get_next_token ($) {
+Line 584 
 sub _get_next_token ($) {
                    $self->{next_char} == 0x003E or # >
                    $self->{next_char} == 0x002F or # /
                    $self->{next_char} == -1) {
+             !!!cp (26);
              $self->{next_char} = shift @next_char; # reconsume
              !!!back-next-input-character (@next_char);
              $self->{state} = DATA_STATE;
              !!!emit ({type => CHARACTER_TOKEN, data => '</'});
              redo A;
            } else {
+             !!!cp (27);
              $self->{next_char} = shift @next_char;
              !!!back-next-input-character (@next_char);
              # and consume...
            }
          } else {
            ## No start tag token has ever been emitted
+           !!!cp (28);
            # next-input-character is already done
            $self->{state} = DATA_STATE;
            !!!emit ({type => CHARACTER_TOKEN, data => '</'});
-Line 569 
 sub _get_next_token ($) {
+Line 608 
 sub _get_next_token ($) {
        if (0x0041 <= $self->{next_char} and
            $self->{next_char} <= 0x005A) { # A..Z
+         !!!cp (29);
          $self->{current_token} = {type => END_TAG_TOKEN,
                            tag_name => chr ($self->{next_char} + 0x0020)};
          $self->{state} = TAG_NAME_STATE;
-Line 576 
 sub _get_next_token ($) {
+Line 616 
 sub _get_next_token ($) {
          redo A;
        } elsif (0x0061 <= $self->{next_char} and
                 $self->{next_char} <= 0x007A) { # a..z
+         !!!cp (30);
          $self->{current_token} = {type => END_TAG_TOKEN,
                            tag_name => chr ($self->{next_char})};
          $self->{state} = TAG_NAME_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x003E) { # >
+         !!!cp (31);
          !!!parse-error (type => 'empty end tag');
          $self->{state} = DATA_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == -1) {
+         !!!cp (32);
          !!!parse-error (type => 'bare etago');
          $self->{state} = DATA_STATE;
          # reconsume
-Line 595 
 sub _get_next_token ($) {
+Line 638 
 sub _get_next_token ($) {
          redo A;
        } else {
+         !!!cp (33);
          !!!parse-error (type => 'bogus end tag');
          $self->{state} = BOGUS_COMMENT_STATE;
          ## $self->{next_char} is intentionally left as is
-Line 606 
 sub _get_next_token ($) {
+Line 650 
 sub _get_next_token ($) {
            $self->{next_char} == 0x000B or # VT
            $self->{next_char} == 0x000C or # FF
            $self->{next_char} == 0x0020) { # SP
+         !!!cp (34);
          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x003E) { # >
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (35);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
-           if ($self->{current_token}->{attributes}) {
+           #if ($self->{current_token}->{attributes}) {
-             !!!parse-error (type => 'end tag attribute');
+           #  ## NOTE: This should never be reached.
-           }
+           #  !!! cp (36);
+           #  !!! parse-error (type => 'end tag attribute');
+           #} else {
+             !!!cp (37);
+           #}
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
          }
-Line 630 
 sub _get_next_token ($) {
+Line 680 
 sub _get_next_token ($) {
          redo A;
        } elsif (0x0041 <= $self->{next_char} and
                 $self->{next_char} <= 0x005A) { # A..Z
+         !!!cp (38);
          $self->{current_token}->{tag_name} .= chr ($self->{next_char} + 0x0020);
            # start tag or end tag
          ## Stay in this state
-Line 638 
 sub _get_next_token ($) {
+Line 689 
 sub _get_next_token ($) {
        } elsif ($self->{next_char} == -1) {
          !!!parse-error (type => 'unclosed tag');
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (39);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
-           if ($self->{current_token}->{attributes}) {
+           #if ($self->{current_token}->{attributes}) {
-             !!!parse-error (type => 'end tag attribute');
+           #  ## NOTE: This state should never be reached.
-           }
+           #  !!! cp (40);
+           #  !!! parse-error (type => 'end tag attribute');
+           #} else {
+             !!!cp (41);
+           #}
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
          }
-Line 661 
 sub _get_next_token ($) {
+Line 717 
 sub _get_next_token ($) {
              $self->{current_token}->{type} == START_TAG_TOKEN and
              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
            # permitted slash
+           !!!cp (42);
            #
          } else {
+           !!!cp (43);
            !!!parse-error (type => 'nestc');
          }
          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
          # next-input-character is already done
          redo A;
        } else {
+         !!!cp (44);
          $self->{current_token}->{tag_name} .= chr $self->{next_char};
            # start tag or end tag
          ## Stay in the state
-Line 681 
 sub _get_next_token ($) {
+Line 740 
 sub _get_next_token ($) {
            $self->{next_char} == 0x000B or # VT
            $self->{next_char} == 0x000C or # FF
            $self->{next_char} == 0x0020) { # SP
+         !!!cp (45);
          ## Stay in the state
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x003E) { # >
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (46);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{current_token}->{attributes}) {
+             !!!cp (47);
              !!!parse-error (type => 'end tag attribute');
+           } else {
+             !!!cp (48);
            }
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
-Line 705 
 sub _get_next_token ($) {
+Line 769 
 sub _get_next_token ($) {
          redo A;
        } elsif (0x0041 <= $self->{next_char} and
                 $self->{next_char} <= 0x005A) { # A..Z
+         !!!cp (49);
          $self->{current_attribute} = {name => chr ($self->{next_char} + 0x0020),
                                value => ''};
          $self->{state} = ATTRIBUTE_NAME_STATE;
-Line 716 
 sub _get_next_token ($) {
+Line 781 
 sub _get_next_token ($) {
              $self->{current_token}->{type} == START_TAG_TOKEN and
              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
            # permitted slash
+           !!!cp (50);
            #
          } else {
+           !!!cp (51);
            !!!parse-error (type => 'nestc');
          }
          ## Stay in the state
-Line 726 
 sub _get_next_token ($) {
+Line 793 
 sub _get_next_token ($) {
        } elsif ($self->{next_char} == -1) {
          !!!parse-error (type => 'unclosed tag');
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (52);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{current_token}->{attributes}) {
+             !!!cp (53);
              !!!parse-error (type => 'end tag attribute');
+           } else {
+             !!!cp (54);
            }
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
-Line 749 
 sub _get_next_token ($) {
+Line 820 
 sub _get_next_token ($) {
 x0027 => 1, # '
 x003D => 1, # =
              }->{$self->{next_char}}) {
+           !!!cp (55);
            !!!parse-error (type => 'bad attribute name');
+         } else {
+           !!!cp (56);
          }
          $self->{current_attribute} = {name => chr ($self->{next_char}),
                                value => ''};
-Line 761 
 sub _get_next_token ($) {
+Line 835 
 sub _get_next_token ($) {
        my $before_leave = sub {
          if (exists $self->{current_token}->{attributes} # start tag or end tag
              ->{$self->{current_attribute}->{name}}) { # MUST
+           !!!cp (57);
            !!!parse-error (type => 'duplicate attribute:'.$self->{current_attribute}->{name});
            ## Discard $self->{current_attribute} # MUST
          } else {
+           !!!cp (58);
            $self->{current_token}->{attributes}->{$self->{current_attribute}->{name}}
              = $self->{current_attribute};
          }
-Line 774 
 sub _get_next_token ($) {
+Line 850 
 sub _get_next_token ($) {
            $self->{next_char} == 0x000B or # VT
            $self->{next_char} == 0x000C or # FF
            $self->{next_char} == 0x0020) { # SP
+         !!!cp (59);
          $before_leave->();
          $self->{state} = AFTER_ATTRIBUTE_NAME_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x003D) { # =
+         !!!cp (60);
          $before_leave->();
          $self->{state} = BEFORE_ATTRIBUTE_VALUE_STATE;
          !!!next-input-character;
-Line 786 
 sub _get_next_token ($) {
+Line 864 
 sub _get_next_token ($) {
        } elsif ($self->{next_char} == 0x003E) { # >
          $before_leave->();
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (61);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
+           !!!cp (62);
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{current_token}->{attributes}) {
              !!!parse-error (type => 'end tag attribute');
-Line 805 
 sub _get_next_token ($) {
+Line 885 
 sub _get_next_token ($) {
          redo A;
        } elsif (0x0041 <= $self->{next_char} and
                 $self->{next_char} <= 0x005A) { # A..Z
+         !!!cp (63);
          $self->{current_attribute}->{name} .= chr ($self->{next_char} + 0x0020);
          ## Stay in the state
          !!!next-input-character;
-Line 816 
 sub _get_next_token ($) {
+Line 897 
 sub _get_next_token ($) {
              $self->{current_token}->{type} == START_TAG_TOKEN and
              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
            # permitted slash
+           !!!cp (64);
            #
          } else {
+           !!!cp (65);
            !!!parse-error (type => 'nestc');
          }
          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
-Line 827 
 sub _get_next_token ($) {
+Line 910 
 sub _get_next_token ($) {
          !!!parse-error (type => 'unclosed tag');
          $before_leave->();
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (66);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{current_token}->{attributes}) {
+             !!!cp (67);
              !!!parse-error (type => 'end tag attribute');
+           } else {
+             ## NOTE: This state should never be reached.
+             !!!cp (68);
            }
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
-Line 847 
 sub _get_next_token ($) {
+Line 935 
 sub _get_next_token ($) {
        } else {
          if ($self->{next_char} == 0x0022 or # "
              $self->{next_char} == 0x0027) { # '
+           !!!cp (69);
            !!!parse-error (type => 'bad attribute name');
+         } else {
+           !!!cp (70);
          }
          $self->{current_attribute}->{name} .= chr ($self->{next_char});
          ## Stay in the state
-Line 860 
 sub _get_next_token ($) {
+Line 951 
 sub _get_next_token ($) {
            $self->{next_char} == 0x000B or # VT
            $self->{next_char} == 0x000C or # FF
            $self->{next_char} == 0x0020) { # SP
+         !!!cp (71);
          ## Stay in the state
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x003D) { # =
+         !!!cp (72);
          $self->{state} = BEFORE_ATTRIBUTE_VALUE_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x003E) { # >
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (73);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{current_token}->{attributes}) {
+             !!!cp (74);
              !!!parse-error (type => 'end tag attribute');
+           } else {
+             ## NOTE: This state should never be reached.
+             !!!cp (75);
            }
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
-Line 888 
 sub _get_next_token ($) {
+Line 986 
 sub _get_next_token ($) {
          redo A;
        } elsif (0x0041 <= $self->{next_char} and
                 $self->{next_char} <= 0x005A) { # A..Z
+         !!!cp (76);
          $self->{current_attribute} = {name => chr ($self->{next_char} + 0x0020),
                                value => ''};
          $self->{state} = ATTRIBUTE_NAME_STATE;
-Line 899 
 sub _get_next_token ($) {
+Line 998 
 sub _get_next_token ($) {
              $self->{current_token}->{type} == START_TAG_TOKEN and
              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
            # permitted slash
+           !!!cp (77);
            #
          } else {
+           !!!cp (78);
            !!!parse-error (type => 'nestc');
            ## TODO: Different error type for <aa / bb> than <aa/>
          }
-Line 910 
 sub _get_next_token ($) {
+Line 1011 
 sub _get_next_token ($) {
        } elsif ($self->{next_char} == -1) {
          !!!parse-error (type => 'unclosed tag');
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (79);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{current_token}->{attributes}) {
+             !!!cp (80);
              !!!parse-error (type => 'end tag attribute');
+           } else {
+             ## NOTE: This state should never be reached.
+             !!!cp (81);
            }
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
-Line 928 
 sub _get_next_token ($) {
+Line 1034 
 sub _get_next_token ($) {
          redo A;
        } else {
+         !!!cp (82);
          $self->{current_attribute} = {name => chr ($self->{next_char}),
                                value => ''};
          $self->{state} = ATTRIBUTE_NAME_STATE;
-Line 940 
 sub _get_next_token ($) {
+Line 1047 
 sub _get_next_token ($) {
            $self->{next_char} == 0x000B or # VT
            $self->{next_char} == 0x000C or # FF
            $self->{next_char} == 0x0020) { # SP
+         !!!cp (83);
          ## Stay in the state
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x0022) { # "
+         !!!cp (84);
          $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x0026) { # &
+         !!!cp (85);
          $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
          ## reconsume
          redo A;
        } elsif ($self->{next_char} == 0x0027) { # '
+         !!!cp (86);
          $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x003E) { # >
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (87);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{current_token}->{attributes}) {
+             !!!cp (88);
              !!!parse-error (type => 'end tag attribute');
+           } else {
+             ## NOTE: This state should never be reached.
+             !!!cp (89);
            }
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
-Line 977 
 sub _get_next_token ($) {
+Line 1093 
 sub _get_next_token ($) {
        } elsif ($self->{next_char} == -1) {
          !!!parse-error (type => 'unclosed tag');
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (90);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{current_token}->{attributes}) {
+             !!!cp (91);
              !!!parse-error (type => 'end tag attribute');
+           } else {
+             ## NOTE: This state should never be reached.
+             !!!cp (92);
            }
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
-Line 996 
 sub _get_next_token ($) {
+Line 1117 
 sub _get_next_token ($) {
          redo A;
        } else {
          if ($self->{next_char} == 0x003D) { # =
+           !!!cp (93);
            !!!parse-error (type => 'bad attribute value');
+         } else {
+           !!!cp (94);
          }
          $self->{current_attribute}->{value} .= chr ($self->{next_char});
          $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
-Line 1005 
 sub _get_next_token ($) {
+Line 1129 
 sub _get_next_token ($) {
        }
      } elsif ($self->{state} == ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE) {
        if ($self->{next_char} == 0x0022) { # "
+         !!!cp (95);
          $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x0026) { # &
+         !!!cp (96);
          $self->{last_attribute_value_state} = $self->{state};
          $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;
          !!!next-input-character;
-Line 1016 
 sub _get_next_token ($) {
+Line 1142 
 sub _get_next_token ($) {
        } elsif ($self->{next_char} == -1) {
          !!!parse-error (type => 'unclosed attribute value');
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (97);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{current_token}->{attributes}) {
+             !!!cp (98);
              !!!parse-error (type => 'end tag attribute');
+           } else {
+             ## NOTE: This state should never be reached.
+             !!!cp (99);
            }
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
-Line 1034 
 sub _get_next_token ($) {
+Line 1165 
 sub _get_next_token ($) {
          redo A;
        } else {
+         !!!cp (100);
          $self->{current_attribute}->{value} .= chr ($self->{next_char});
          ## Stay in the state
          !!!next-input-character;
-Line 1041 
 sub _get_next_token ($) {
+Line 1173 
 sub _get_next_token ($) {
        }
      } elsif ($self->{state} == ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE) {
        if ($self->{next_char} == 0x0027) { # '
+         !!!cp (101);
          $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x0026) { # &
+         !!!cp (102);
          $self->{last_attribute_value_state} = $self->{state};
          $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;
          !!!next-input-character;
-Line 1052 
 sub _get_next_token ($) {
+Line 1186 
 sub _get_next_token ($) {
        } elsif ($self->{next_char} == -1) {
          !!!parse-error (type => 'unclosed attribute value');
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (103);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{current_token}->{attributes}) {
+             !!!cp (104);
              !!!parse-error (type => 'end tag attribute');
+           } else {
+             ## NOTE: This state should never be reached.
+             !!!cp (105);
            }
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
-Line 1070 
 sub _get_next_token ($) {
+Line 1209 
 sub _get_next_token ($) {
          redo A;
        } else {
+         !!!cp (106);
          $self->{current_attribute}->{value} .= chr ($self->{next_char});
          ## Stay in the state
          !!!next-input-character;
-Line 1081 
 sub _get_next_token ($) {
+Line 1221 
 sub _get_next_token ($) {
            $self->{next_char} == 0x000B or # HT
            $self->{next_char} == 0x000C or # FF
            $self->{next_char} == 0x0020) { # SP
+         !!!cp (107);
          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x0026) { # &
+         !!!cp (108);
          $self->{last_attribute_value_state} = $self->{state};
          $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x003E) { # >
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (109);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{current_token}->{attributes}) {
+             !!!cp (110);
              !!!parse-error (type => 'end tag attribute');
+           } else {
+             ## NOTE: This state should never be reached.
+             !!!cp (111);
            }
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
-Line 1111 
 sub _get_next_token ($) {
+Line 1258 
 sub _get_next_token ($) {
        } elsif ($self->{next_char} == -1) {
          !!!parse-error (type => 'unclosed tag');
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (112);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{current_token}->{attributes}) {
+             !!!cp (113);
              !!!parse-error (type => 'end tag attribute');
+           } else {
+             ## NOTE: This state should never be reached.
+             !!!cp (114);
            }
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
-Line 1134 
 sub _get_next_token ($) {
+Line 1286 
 sub _get_next_token ($) {
 x0027 => 1, # '
 x003D => 1, # =
              }->{$self->{next_char}}) {
+           !!!cp (115);
            !!!parse-error (type => 'bad attribute value');
+         } else {
+           !!!cp (116);
          }
          $self->{current_attribute}->{value} .= chr ($self->{next_char});
          ## Stay in the state
-Line 1151 
 sub _get_next_token ($) {
+Line 1306 
 sub _get_next_token ($) {
             -1);
        unless (defined $token) {
+         !!!cp (117);
          $self->{current_attribute}->{value} .= '&';
        } else {
+         !!!cp (118);
          $self->{current_attribute}->{value} .= $token->{data};
          $self->{current_attribute}->{has_reference} = $token->{has_reference};
          ## ISSUE: spec says "append the returned character token to the current attribute's value"
-Line 1167 
 sub _get_next_token ($) {
+Line 1324 
 sub _get_next_token ($) {
            $self->{next_char} == 0x000B or # VT
            $self->{next_char} == 0x000C or # FF
            $self->{next_char} == 0x0020) { # SP
+         !!!cp (118);
          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x003E) { # >
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
+           !!!cp (119);
            $self->{current_token}->{first_start_tag}
                = not defined $self->{last_emitted_start_tag_name};
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
          } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{current_token}->{attributes}) {
+             !!!cp (120);
              !!!parse-error (type => 'end tag attribute');
+           } else {
+             ## NOTE: This state should never be reached.
+             !!!cp (121);
            }
          } else {
            die "$0: $self->{current_token}->{type}: Unknown token type";
-Line 1195 
 sub _get_next_token ($) {
+Line 1358 
 sub _get_next_token ($) {
              $self->{current_token}->{type} == START_TAG_TOKEN and
              $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {
            # permitted slash
+           !!!cp (122);
            #
          } else {
+           !!!cp (123);
            !!!parse-error (type => 'nestc');
          }
          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
          # next-input-character is already done
          redo A;
        } else {
+         !!!cp (124);
          !!!parse-error (type => 'no space between attributes');
          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
          ## reconsume
-Line 1215 
 sub _get_next_token ($) {
+Line 1381 
 sub _get_next_token ($) {
        BC: {
          if ($self->{next_char} == 0x003E) { # >
+           !!!cp (124);
            $self->{state} = DATA_STATE;
            !!!next-input-character;
-Line 1222 
 sub _get_next_token ($) {
+Line 1389 
 sub _get_next_token ($) {
            redo A;
          } elsif ($self->{next_char} == -1) {
+           !!!cp (125);
            $self->{state} = DATA_STATE;
            ## reconsume
-Line 1229 
 sub _get_next_token ($) {
+Line 1397 
 sub _get_next_token ($) {
            redo A;
          } else {
+           !!!cp (126);
            $token->{data} .= chr ($self->{next_char});
            !!!next-input-character;
            redo BC;
          }
        } # BC
+       die "$0: _get_next_token: unexpected case [BC]";
      } elsif ($self->{state} == MARKUP_DECLARATION_OPEN_STATE) {
        ## (only happen if PCDATA state)
-Line 1244 
 sub _get_next_token ($) {
+Line 1415 
 sub _get_next_token ($) {
          !!!next-input-character;
          push @next_char, $self->{next_char};
          if ($self->{next_char} == 0x002D) { # -
+           !!!cp (127);
            $self->{current_token} = {type => COMMENT_TOKEN, data => ''};
            $self->{state} = COMMENT_START_STATE;
            !!!next-input-character;
            redo A;
+         } else {
+           !!!cp (128);
          }
        } elsif ($self->{next_char} == 0x0044 or # D
                 $self->{next_char} == 0x0064) { # d
-Line 1275 
 sub _get_next_token ($) {
+Line 1449 
 sub _get_next_token ($) {
                    push @next_char, $self->{next_char};
                    if ($self->{next_char} == 0x0045 or # E
                        $self->{next_char} == 0x0065) { # e
-                     ## ISSUE: What a stupid code this is!
+                     !!!cp (129);
+                     ## TODO: What a stupid code this is!
                      $self->{state} = DOCTYPE_STATE;
                      !!!next-input-character;
                      redo A;
+                   } else {
+                     !!!cp (130);
                    }
+                 } else {
+                   !!!cp (131);
                  }
+               } else {
+                 !!!cp (132);
                }
+             } else {