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

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

Parent Directory | Revision Log | View Patch Patch

-revision 1.11 by wakaba,
Wed Oct 15 10:50:38 2008 UTC
+revision 1.25 by wakaba,
Sun Oct 19 15:17:01 2008 UTC
 Line 15 
 BEGIN {
      CHARACTER_TOKEN
      PI_TOKEN
      ABORT_TOKEN
+     END_OF_DOCTYPE_TOKEN
+     ATTLIST_TOKEN
+     ELEMENT_TOKEN
+     GENERAL_ENTITY_TOKEN
+     PARAMETER_ENTITY_TOKEN
+     NOTATION_TOKEN
    );
    our %EXPORT_TAGS = (
-Line 27 
 BEGIN {
+Line 33 
 BEGIN {
        CHARACTER_TOKEN
        PI_TOKEN
        ABORT_TOKEN
+       END_OF_DOCTYPE_TOKEN
+       ATTLIST_TOKEN
+       ELEMENT_TOKEN
+       GENERAL_ENTITY_TOKEN
+       PARAMETER_ENTITY_TOKEN
+       NOTATION_TOKEN
      )],
    );
  }
+ ## NOTE: Differences from the XML5 draft are marked as "XML5:".
  ## Token types
- sub DOCTYPE_TOKEN () { 1 }
+ sub DOCTYPE_TOKEN () { 1 } ## XML5: No DOCTYPE token.
  sub COMMENT_TOKEN () { 2 }
  sub START_TAG_TOKEN () { 3 }
  sub END_TAG_TOKEN () { 4 }
  sub END_OF_FILE_TOKEN () { 5 }
  sub CHARACTER_TOKEN () { 6 }
- sub PI_TOKEN () { 7 } # XML5
+ sub PI_TOKEN () { 7 } ## NOTE: XML only.
- sub ABORT_TOKEN () { 8 } # Not a token actually
+ sub ABORT_TOKEN () { 8 } ## NOTE: For internal processing.
+ sub END_OF_DOCTYPE_TOKEN () { 9 } ## NOTE: XML only.
+ sub ATTLIST_TOKEN () { 10 } ## NOTE: XML only.
+ sub ELEMENT_TOKEN () { 11 } ## NOTE: XML only.
+ sub GENERAL_ENTITY_TOKEN () { 12 } ## NOTE: XML only.
+ sub PARAMETER_ENTITY_TOKEN () { 13 } ## NOTE: XML only.
+ sub NOTATION_TOKEN () { 14 } ## NOTE: XML only.
+ ## XML5: XML5 has "empty tag token".  In this implementation, it is
+ ## represented as a start tag token with $self->{self_closing} flag
+ ## set to true.
+ ## XML5: XML5 has "short end tag token".  In this implementation, it
+ ## is represented as an end tag token with $token->{tag_name} flag set
+ ## to an empty string.
  package Whatpm::HTML;
-Line 114 
 sub HEXREF_HEX_STATE () { 48 }
+Line 142 
 sub HEXREF_HEX_STATE () { 48 }
  sub ENTITY_NAME_STATE () { 49 }
  sub PCDATA_STATE () { 50 } # "data state" in the spec
- ## XML states
+ ## XML-only states
  sub PI_STATE () { 51 }
  sub PI_TARGET_STATE () { 52 }
  sub PI_TARGET_AFTER_STATE () { 53 }
  sub PI_DATA_STATE () { 54 }
  sub PI_AFTER_STATE () { 55 }
  sub PI_DATA_AFTER_STATE () { 56 }
+ sub DOCTYPE_INTERNAL_SUBSET_STATE () { 57 }
+ sub DOCTYPE_INTERNAL_SUBSET_AFTER_STATE () { 58 }
+ sub BOGUS_DOCTYPE_INTERNAL_SUBSET_AFTER_STATE () { 59 }
+ sub DOCTYPE_TAG_STATE () { 60 }
+ sub DOCTYPE_MARKUP_DECLARATION_OPEN_STATE () { 61 }
+ sub MD_ATTLIST_STATE () { 62 }
+ sub MD_E_STATE () { 63 }
+ sub MD_ELEMENT_STATE () { 64 }
+ sub MD_ENTITY_STATE () { 65 }
+ sub MD_NOTATION_STATE () { 66 }
+ sub DOCTYPE_MD_STATE () { 67 }
+ sub BEFORE_MD_NAME_STATE () { 68 }
+ sub MD_NAME_STATE () { 69 }
+ sub DOCTYPE_ENTITY_PARAMETER_BEFORE_STATE () { 70 }
+ sub DOCTYPE_ATTLIST_NAME_AFTER_STATE () { 71 }
+ sub DOCTYPE_ATTLIST_ATTRIBUTE_NAME_STATE () { 72 }
+ sub DOCTYPE_ATTLIST_ATTRIBUTE_NAME_AFTER_STATE () { 73 }
+ sub DOCTYPE_ATTLIST_ATTRIBUTE_TYPE_STATE () { 74 }
+ sub DOCTYPE_ATTLIST_ATTRIBUTE_TYPE_AFTER_STATE () { 75 }
+ sub BEFORE_ALLOWED_TOKEN_STATE () { 76 }
+ sub ALLOWED_TOKEN_STATE () { 77 }
+ sub AFTER_ALLOWED_TOKEN_STATE () { 78 }
+ sub AFTER_ALLOWED_TOKENS_STATE () { 79 }
+ sub BEFORE_ATTR_DEFAULT_STATE () { 80 }
+ sub DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_BEFORE_STATE () { 81 }
+ sub DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_STATE () { 82 }
+ sub DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_AFTER_STATE () { 83 }
+ sub AFTER_ATTLIST_ATTR_VALUE_QUOTED_STATE () { 84 }
+ sub BEFORE_NDATA_STATE () { 85 }
+ sub NDATA_STATE () { 86 }
+ sub AFTER_NDATA_STATE () { 87 }
+ sub BEFORE_NOTATION_NAME_STATE () { 88 }
+ sub NOTATION_NAME_STATE () { 89 }
+ sub DOCTYPE_ENTITY_VALUE_DOUBLE_QUOTED_STATE () { 90 }
+ sub DOCTYPE_ENTITY_VALUE_SINGLE_QUOTED_STATE () { 91 }
+ sub ENTITY_VALUE_ENTITY_STATE () { 92 }
+ sub AFTER_ELEMENT_NAME_STATE () { 93 }
+ sub BEFORE_ELEMENT_CONTENT_STATE () { 94 }
+ sub CONTENT_KEYWORD_STATE () { 95 }
+ sub AFTER_CM_GROUP_OPEN_STATE () { 96 }
+ sub CM_ELEMENT_NAME_STATE () { 97 }
+ sub AFTER_CM_ELEMENT_NAME_STATE () { 98 }
+ sub AFTER_CM_GROUP_CLOSE_STATE () { 99 }
+ sub AFTER_MD_DEF_STATE () { 100 }
+ sub BOGUS_MD_STATE () { 101 }
  ## Tree constructor state constants (see Whatpm::HTML for the full
  ## list and descriptions)
-Line 186 
 sub _initialize_tokenizer ($) {
+Line 259 
 sub _initialize_tokenizer ($) {
    #$self->{is_xml} (if XML)
    $self->{state} = DATA_STATE; # MUST
-   $self->{s_kwd} = ''; # state keyword
+   $self->{s_kwd} = ''; # Data state keyword
+   #$self->{kwd} = ''; # State-dependent keyword; initialized when used
    #$self->{entity__value}; # initialized when used
    #$self->{entity__match}; # initialized when used
    $self->{content_model} = PCDATA_CONTENT_MODEL; # be
-Line 221 
 sub _initialize_tokenizer ($) {
+Line 295 
 sub _initialize_tokenizer ($) {
  ##   ->{data} (COMMENT_TOKEN, CHARACTER_TOKEN, PI_TOKEN)
  ##   ->{has_reference} == 1 or 0 (CHARACTER_TOKEN)
  ##   ->{last_index} (ELEMENT_TOKEN): Next attribute's index - 1.
+ ##   ->{has_internal_subset} = 1 or 0 (DOCTYPE_TOKEN)
  ## NOTE: The "self-closing flag" is hold as |$self->{self_closing}|.
  ##     |->{self_closing}| is used to save the value of |$self->{self_closing}|
  ##     while the token is pushed back to the stack.
-Line 240 
 my $is_space = {
+Line 316 
 my $is_space = {
 x0009 => 1, # CHARACTER TABULATION (HT)
 x000A => 1, # LINE FEED (LF)
    #0x000B => 0, # LINE TABULATION (VT)
-x000C => 1, # FORM FEED (FF)
+x000C => 1, # FORM FEED (FF) ## XML5: Not a space character.
    #0x000D => 1, # CARRIAGE RETURN (CR)
 x0020 => 1, # SPACE (SP)
  };
-Line 450 
 sub _get_next_token ($) {
+Line 526 
 sub _get_next_token ($) {
            redo A;
          } elsif ($self->{nc} == 0x0021) { # !
            !!!cp (15.1);
-           $self->{s_kwd} = '<' unless $self->{escape};
+           $self->{s_kwd} = $self->{escaped} ? '' : '<';
            #
          } else {
            !!!cp (16);
+           $self->{s_kwd} = '';
            #
          }
          ## reconsume
          $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
          !!!emit ({type => CHARACTER_TOKEN, data => '<',
                    line => $self->{line_prev},
                    column => $self->{column_prev},
-Line 570 
 sub _get_next_token ($) {
+Line 646 
 sub _get_next_token ($) {
        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
          if (defined $self->{last_stag_name}) {
            $self->{state} = CDATA_RCDATA_CLOSE_TAG_STATE;
-           $self->{s_kwd} = '';
+           $self->{kwd} = '';
            ## Reconsume.
            redo A;
          } else {
-Line 673 
 sub _get_next_token ($) {
+Line 749 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == CDATA_RCDATA_CLOSE_TAG_STATE) {
-       my $ch = substr $self->{last_stag_name}, length $self->{s_kwd}, 1;
+       my $ch = substr $self->{last_stag_name}, length $self->{kwd}, 1;
        if (length $ch) {
          my $CH = $ch;
          $ch =~ tr/a-z/A-Z/;
-Line 681 
 sub _get_next_token ($) {
+Line 757 
 sub _get_next_token ($) {
          if ($nch eq $ch or $nch eq $CH) {
            !!!cp (24);
            ## Stay in the state.
-           $self->{s_kwd} .= $nch;
+           $self->{kwd} .= $nch;
            !!!next-input-character;
            redo A;
          } else {
-Line 690 
 sub _get_next_token ($) {
+Line 766 
 sub _get_next_token ($) {
            $self->{s_kwd} = '';
            ## Reconsume.
            !!!emit ({type => CHARACTER_TOKEN,
-                     data => '</' . $self->{s_kwd},
+                     data => '</' . $self->{kwd},
                      line => $self->{line_prev},
-                     column => $self->{column_prev} - 1 - length $self->{s_kwd},
+                     column => $self->{column_prev} - 1 - length $self->{kwd},
                     });
            redo A;
          }
-Line 708 
 sub _get_next_token ($) {
+Line 784 
 sub _get_next_token ($) {
            $self->{state} = DATA_STATE;
            $self->{s_kwd} = '';
            !!!emit ({type => CHARACTER_TOKEN,
-                     data => '</' . $self->{s_kwd},
+                     data => '</' . $self->{kwd},
                      line => $self->{line_prev},
-                     column => $self->{column_prev} - 1 - length $self->{s_kwd},
+                     column => $self->{column_prev} - 1 - length $self->{kwd},
                     });
            redo A;
          } else {
-Line 719 
 sub _get_next_token ($) {
+Line 795 
 sub _get_next_token ($) {
                = {type => END_TAG_TOKEN,
                   tag_name => $self->{last_stag_name},
                   line => $self->{line_prev},
-                  column => $self->{column_prev} - 1 - length $self->{s_kwd}};
+                  column => $self->{column_prev} - 1 - length $self->{kwd}};
            $self->{state} = TAG_NAME_STATE;
            ## Reconsume.
            redo A;
-Line 1211 
 sub _get_next_token ($) {
+Line 1287 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE) {
-       ## XML5: "Tag attribute value double quoted state".
+       ## XML5: "Tag attribute value double quoted state" and "DOCTYPE
+       ## ATTLIST attribute value double quoted state".
        if ($self->{nc} == 0x0022) { # "
-         !!!cp (95);
+         if ($self->{ct}->{type} == ATTLIST_TOKEN) {
-         ## XML5: "Tag attribute name before state".
+           !!!cp (95.1);
-         $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
+           ## XML5: "DOCTYPE ATTLIST name after state".
+           push @{$self->{ct}->{attrdefs}}, $self->{ca};
+           $self->{state} = AFTER_ATTLIST_ATTR_VALUE_QUOTED_STATE;
+         } else {
+           !!!cp (95);
+           ## XML5: "Tag attribute name before state".
+           $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
+         }
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == 0x0026) { # &
-Line 1232 
 sub _get_next_token ($) {
+Line 1316 
 sub _get_next_token ($) {
          $self->{state} = ENTITY_STATE;
          !!!next-input-character;
          redo A;
+       } elsif ($self->{is_xml} and
+                $is_space->{$self->{nc}}) {
+         !!!cp (97.1);
+         $self->{ca}->{value} .= ' ';
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
        } elsif ($self->{nc} == -1) {
          !!!parse-error (type => 'unclosed attribute value');
          if ($self->{ct}->{type} == START_TAG_TOKEN) {
            !!!cp (97);
            $self->{last_stag_name} = $self->{ct}->{tag_name};
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           ## reconsume
+           !!!emit ($self->{ct}); # start tag
+           redo A;
          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{ct}->{attributes}) {
-Line 1246 
 sub _get_next_token ($) {
+Line 1343 
 sub _get_next_token ($) {
              ## NOTE: This state should never be reached.
              !!!cp (99);
            }
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           ## reconsume
+           !!!emit ($self->{ct}); # end tag
+           redo A;
+         } elsif ($self->{ct}->{type} == ATTLIST_TOKEN) {
+           ## XML5: No parse error above; not defined yet.
+           push @{$self->{ct}->{attrdefs}}, $self->{ca};
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+           ## Reconsume.
+           !!!emit ($self->{ct}); # ATTLIST
+           redo A;
          } else {
            die "$0: $self->{ct}->{type}: Unknown token type";
          }
-         $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
-         ## reconsume
-         !!!emit ($self->{ct}); # start tag or end tag
-         redo A;
        } else {
+         ## XML5 [ATTLIST]: Not defined yet.
          if ($self->{is_xml} and $self->{nc} == 0x003C) { # <
            !!!cp (100);
            ## XML5: Not a parse error.
-Line 1266 
 sub _get_next_token ($) {
+Line 1370 
 sub _get_next_token ($) {
          }
          $self->{ca}->{value} .= chr ($self->{nc});
          $self->{read_until}->($self->{ca}->{value},
-                               q["&<],
+                               qq["&<\x09\x0C\x20],
                                length $self->{ca}->{value});
          ## Stay in the state
-Line 1274 
 sub _get_next_token ($) {
+Line 1378 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE) {
-       ## XML5: "Tag attribute value single quoted state".
+       ## XML5: "Tag attribute value single quoted state" and "DOCTYPE
+       ## ATTLIST attribute value single quoted state".
        if ($self->{nc} == 0x0027) { # '
-         !!!cp (101);
+         if ($self->{ct}->{type} == ATTLIST_TOKEN) {
-         ## XML5: "Before attribute name state" (sic).
+           !!!cp (101.1);
-         $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
+           ## XML5: "DOCTYPE ATTLIST name after state".
+           push @{$self->{ct}->{attrdefs}}, $self->{ca};
+           $self->{state} = AFTER_ATTLIST_ATTR_VALUE_QUOTED_STATE;
+         } else {
+           !!!cp (101);
+           ## XML5: "Before attribute name state" (sic).
+           $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
+         }
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == 0x0026) { # &
-Line 1295 
 sub _get_next_token ($) {
+Line 1407 
 sub _get_next_token ($) {
          $self->{state} = ENTITY_STATE;
          !!!next-input-character;
          redo A;
+       } elsif ($self->{is_xml} and
+                $is_space->{$self->{nc}}) {
+         !!!cp (103.1);
+         $self->{ca}->{value} .= ' ';
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
        } elsif ($self->{nc} == -1) {
          !!!parse-error (type => 'unclosed attribute value');
          if ($self->{ct}->{type} == START_TAG_TOKEN) {
            !!!cp (103);
            $self->{last_stag_name} = $self->{ct}->{tag_name};
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           ## reconsume
+           !!!emit ($self->{ct}); # start tag
+           redo A;
          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{ct}->{attributes}) {
-Line 1309 
 sub _get_next_token ($) {
+Line 1434 
 sub _get_next_token ($) {
              ## NOTE: This state should never be reached.
              !!!cp (105);
            }
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           ## reconsume
+           !!!emit ($self->{ct}); # end tag
+           redo A;
+         } elsif ($self->{ct}->{type} == ATTLIST_TOKEN) {
+           ## XML5: No parse error above; not defined yet.
+           push @{$self->{ct}->{attrdefs}}, $self->{ca};
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+           ## Reconsume.
+           !!!emit ($self->{ct}); # ATTLIST
+           redo A;
          } else {
            die "$0: $self->{ct}->{type}: Unknown token type";
          }
-         $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
-         ## reconsume
-         !!!emit ($self->{ct}); # start tag or end tag
-         redo A;
        } else {
+         ## XML5 [ATTLIST]: Not defined yet.
          if ($self->{is_xml} and $self->{nc} == 0x003C) { # <
            !!!cp (106);
            ## XML5: Not a parse error.
-Line 1329 
 sub _get_next_token ($) {
+Line 1461 
 sub _get_next_token ($) {
          }
          $self->{ca}->{value} .= chr ($self->{nc});
          $self->{read_until}->($self->{ca}->{value},
-                               q['&<],
+                               qq['&<\x09\x0C\x20],
                                length $self->{ca}->{value});
          ## Stay in the state
-Line 1340 
 sub _get_next_token ($) {
+Line 1472 
 sub _get_next_token ($) {
        ## XML5: "Tag attribute value unquoted state".
        if ($is_space->{$self->{nc}}) {
-         !!!cp (107);
+         if ($self->{ct}->{type} == ATTLIST_TOKEN) {
-         ## XML5: "Tag attribute name before state".
+           !!!cp (107.1);
-         $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
+           push @{$self->{ct}->{attrdefs}}, $self->{ca};
+           $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;
+         } else {
+           !!!cp (107);
+           ## XML5: "Tag attribute name before state".
+           $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
+         }
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == 0x0026) { # &
-Line 1363 
 sub _get_next_token ($) {
+Line 1501 
 sub _get_next_token ($) {
          if ($self->{ct}->{type} == START_TAG_TOKEN) {
            !!!cp (109);
            $self->{last_stag_name} = $self->{ct}->{tag_name};
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           !!!next-input-character;
+           !!!emit ($self->{ct}); # start tag
+           redo A;
          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{ct}->{attributes}) {
-Line 1372 
 sub _get_next_token ($) {
+Line 1516 
 sub _get_next_token ($) {
              ## NOTE: This state should never be reached.
              !!!cp (111);
            }
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           !!!next-input-character;
+           !!!emit ($self->{ct}); # end tag
+           redo A;
+         } elsif ($self->{ct}->{type} == ATTLIST_TOKEN) {
+           push @{$self->{ct}->{attrdefs}}, $self->{ca};
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+           !!!next-input-character;
+           !!!emit ($self->{ct}); # ATTLIST
+           redo A;
          } else {
            die "$0: $self->{ct}->{type}: Unknown token type";
          }
-         $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
-         !!!next-input-character;
-         !!!emit ($self->{ct}); # start tag or end tag
-         redo A;
        } elsif ($self->{nc} == -1) {
-         !!!parse-error (type => 'unclosed tag');
          if ($self->{ct}->{type} == START_TAG_TOKEN) {
            !!!cp (112);
+           !!!parse-error (type => 'unclosed tag');
            $self->{last_stag_name} = $self->{ct}->{tag_name};
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           ## reconsume
+           !!!emit ($self->{ct}); # start tag
+           redo A;
          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {
+           !!!parse-error (type => 'unclosed tag');
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
            if ($self->{ct}->{attributes}) {
              !!!cp (113);
-Line 1396 
 sub _get_next_token ($) {
+Line 1552 
 sub _get_next_token ($) {
              ## NOTE: This state should never be reached.
              !!!cp (114);
            }
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           ## reconsume
+           !!!emit ($self->{ct}); # end tag
+           redo A;
+         } elsif ($self->{ct}->{type} == ATTLIST_TOKEN) {
+           !!!parse-error (type => 'unclosed md'); ## TODO: type
+           push @{$self->{ct}->{attrdefs}}, $self->{ca};
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+           ## Reconsume.
+           !!!emit ($self->{ct}); # ATTLIST
+           redo A;
          } else {
            die "$0: $self->{ct}->{type}: Unknown token type";
          }
-         $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
-         ## reconsume
-         !!!emit ($self->{ct}); # start tag or end tag
-         redo A;
        } else {
          if ({
 x0022 => 1, # "
-Line 1420 
 sub _get_next_token ($) {
+Line 1582 
 sub _get_next_token ($) {
          }
          $self->{ca}->{value} .= chr ($self->{nc});
          $self->{read_until}->($self->{ca}->{value},
-                               q["'=& >],
+                               qq["'=& \x09\x0C>],
                                length $self->{ca}->{value});
          ## Stay in the state
-Line 1548 
 sub _get_next_token ($) {
+Line 1710 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == BOGUS_COMMENT_STATE) {
-       ## (only happen if PCDATA state)
+       ## XML5: "Bogus comment state" and "DOCTYPE bogus comment state".
        ## NOTE: Unlike spec's "bogus comment state", this implementation
        ## consumes characters one-by-one basis.
        if ($self->{nc} == 0x003E) { # >
-         !!!cp (124);
+         if ($self->{in_subset}) {
-         $self->{state} = DATA_STATE;
+           !!!cp (123);
-         $self->{s_kwd} = '';
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           !!!cp (124);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          !!!next-input-character;
          !!!emit ($self->{ct}); # comment
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (125);
+         if ($self->{in_subset}) {
-         $self->{state} = DATA_STATE;
+           !!!cp (125.1);
-         $self->{s_kwd} = '';
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           !!!cp (125);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          ## reconsume
          !!!emit ($self->{ct}); # comment
-Line 1581 
 sub _get_next_token ($) {
+Line 1753 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == MARKUP_DECLARATION_OPEN_STATE) {
-       ## (only happen if PCDATA state)
+       ## XML5: "Markup declaration state".
        if ($self->{nc} == 0x002D) { # -
          !!!cp (133);
-Line 1593 
 sub _get_next_token ($) {
+Line 1765 
 sub _get_next_token ($) {
          ## ASCII case-insensitive.
          !!!cp (130);
          $self->{state} = MD_DOCTYPE_STATE;
-         $self->{s_kwd} = chr $self->{nc};
+         $self->{kwd} = chr $self->{nc};
          !!!next-input-character;
          redo A;
        } elsif ((($self->{insertion_mode} & IN_FOREIGN_CONTENT_IM and
-Line 1602 
 sub _get_next_token ($) {
+Line 1774 
 sub _get_next_token ($) {
                 $self->{nc} == 0x005B) { # [
          !!!cp (135.4);
          $self->{state} = MD_CDATA_STATE;
-         $self->{s_kwd} = '[';
+         $self->{kwd} = '[';
          !!!next-input-character;
          redo A;
        } else {
-Line 1652 
 sub _get_next_token ($) {
+Line 1824 
 sub _get_next_token ($) {
 x0054, # T
 x0059, # Y
 x0050, # P
-           ]->[length $self->{s_kwd}] or
+           ]->[length $self->{kwd}] or
            $self->{nc} == [
              undef,
 x006F, # o
-Line 1660 
 sub _get_next_token ($) {
+Line 1832 
 sub _get_next_token ($) {
 x0074, # t
 x0079, # y
 x0070, # p
-           ]->[length $self->{s_kwd}]) {
+           ]->[length $self->{kwd}]) {
          !!!cp (131);
          ## Stay in the state.
-         $self->{s_kwd} .= chr $self->{nc};
+         $self->{kwd} .= chr $self->{nc};
          !!!next-input-character;
          redo A;
-       } elsif ((length $self->{s_kwd}) == 6 and
+       } elsif ((length $self->{kwd}) == 6 and
                 ($self->{nc} == 0x0045 or # E
                  $self->{nc} == 0x0065)) { # e
-         if ($self->{s_kwd} ne 'DOCTYP') {
+         if ($self->{is_xml} and
+             ($self->{kwd} ne 'DOCTYP' or $self->{nc} == 0x0065)) {
            !!!cp (129);
            ## XML5: case-sensitive.
            !!!parse-error (type => 'lowercase keyword', ## TODO
-Line 1691 
 sub _get_next_token ($) {
+Line 1864 
 sub _get_next_token ($) {
          !!!cp (132);
          !!!parse-error (type => 'bogus comment',
                          line => $self->{line_prev},
-                         column => $self->{column_prev} - 1 - length $self->{s_kwd});
+                         column => $self->{column_prev} - 1 - length $self->{kwd});
          $self->{state} = BOGUS_COMMENT_STATE;
          ## Reconsume.
          $self->{ct} = {type => COMMENT_TOKEN,
-                                   data => $self->{s_kwd},
+                                   data => $self->{kwd},
                                    line => $self->{line_prev},
-                                   column => $self->{column_prev} - 1 - length $self->{s_kwd},
+                                   column => $self->{column_prev} - 1 - length $self->{kwd},
                                   };
          redo A;
        }
-Line 1708 
 sub _get_next_token ($) {
+Line 1881 
 sub _get_next_token ($) {
              '[CD' => 0x0041, # A
              '[CDA' => 0x0054, # T
              '[CDAT' => 0x0041, # A
-           }->{$self->{s_kwd}}) {
+           }->{$self->{kwd}}) {
          !!!cp (135.1);
          ## Stay in the state.
-         $self->{s_kwd} .= chr $self->{nc};
+         $self->{kwd} .= chr $self->{nc};
          !!!next-input-character;
          redo A;
-       } elsif ($self->{s_kwd} eq '[CDATA' and
+       } elsif ($self->{kwd} eq '[CDATA' and
                 $self->{nc} == 0x005B) { # [
          if ($self->{is_xml} and
              not $self->{tainted} and
-Line 1739 
 sub _get_next_token ($) {
+Line 1912 
 sub _get_next_token ($) {
          !!!cp (135.3);
          !!!parse-error (type => 'bogus comment',
                          line => $self->{line_prev},
-                         column => $self->{column_prev} - 1 - length $self->{s_kwd});
+                         column => $self->{column_prev} - 1 - length $self->{kwd});
          $self->{state} = BOGUS_COMMENT_STATE;
          ## Reconsume.
          $self->{ct} = {type => COMMENT_TOKEN,
-                                   data => $self->{s_kwd},
+                                   data => $self->{kwd},
                                    line => $self->{line_prev},
-                                   column => $self->{column_prev} - 1 - length $self->{s_kwd},
+                                   column => $self->{column_prev} - 1 - length $self->{kwd},
                                   };
          redo A;
        }
-Line 1756 
 sub _get_next_token ($) {
+Line 1929 
 sub _get_next_token ($) {
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
-         !!!cp (138);
          !!!parse-error (type => 'bogus comment');
-         $self->{state} = DATA_STATE;
+         if ($self->{in_subset}) {
-         $self->{s_kwd} = '';
+           !!!cp (138.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           !!!cp (138);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          !!!next-input-character;
          !!!emit ($self->{ct}); # comment
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (139);
          !!!parse-error (type => 'unclosed comment');
-         $self->{state} = DATA_STATE;
+         if ($self->{in_subset}) {
-         $self->{s_kwd} = '';
+           !!!cp (139.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           !!!cp (139);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          ## reconsume
          !!!emit ($self->{ct}); # comment
-Line 1790 
 sub _get_next_token ($) {
+Line 1973 
 sub _get_next_token ($) {
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
-         !!!cp (142);
          !!!parse-error (type => 'bogus comment');
-         $self->{state} = DATA_STATE;
+         if ($self->{in_subset}) {
-         $self->{s_kwd} = '';
+           !!!cp (142.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           !!!cp (142);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          !!!next-input-character;
          !!!emit ($self->{ct}); # comment
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (143);
          !!!parse-error (type => 'unclosed comment');
-         $self->{state} = DATA_STATE;
+         if ($self->{in_subset}) {
-         $self->{s_kwd} = '';
+           !!!cp (143.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           !!!cp (143);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          ## reconsume
          !!!emit ($self->{ct}); # comment
-Line 1818 
 sub _get_next_token ($) {
+Line 2011 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == COMMENT_STATE) {
+       ## XML5: "Comment state" and "DOCTYPE comment state".
        if ($self->{nc} == 0x002D) { # -
          !!!cp (145);
          $self->{state} = COMMENT_END_DASH_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (146);
          !!!parse-error (type => 'unclosed comment');
-         $self->{state} = DATA_STATE;
+         if ($self->{in_subset}) {
-         $self->{s_kwd} = '';
+           !!!cp (146.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           !!!cp (146);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          ## reconsume
          !!!emit ($self->{ct}); # comment
-Line 1845 
 sub _get_next_token ($) {
+Line 2045 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == COMMENT_END_DASH_STATE) {
-       ## XML5: "comment dash state".
+       ## XML5: "Comment dash state" and "DOCTYPE comment dash state".
        if ($self->{nc} == 0x002D) { # -
          !!!cp (148);
-Line 1853 
 sub _get_next_token ($) {
+Line 2053 
 sub _get_next_token ($) {
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (149);
          !!!parse-error (type => 'unclosed comment');
-         $self->{s_kwd} = '';
+         if ($self->{in_subset}) {
-         $self->{state} = DATA_STATE;
+           !!!cp (149.1);
-         $self->{s_kwd} = '';
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           !!!cp (149);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          ## reconsume
          !!!emit ($self->{ct}); # comment
-Line 1871 
 sub _get_next_token ($) {
+Line 2075 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == COMMENT_END_STATE) {
+       ## XML5: "Comment end state" and "DOCTYPE comment end state".
        if ($self->{nc} == 0x003E) { # >
-         !!!cp (151);
+         if ($self->{in_subset}) {
-         $self->{state} = DATA_STATE;
+           !!!cp (151.1);
-         $self->{s_kwd} = '';
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           !!!cp (151);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          !!!next-input-character;
          !!!emit ($self->{ct}); # comment
-Line 1891 
 sub _get_next_token ($) {
+Line 2102 
 sub _get_next_token ($) {
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (153);
          !!!parse-error (type => 'unclosed comment');
-         $self->{state} = DATA_STATE;
+         if ($self->{in_subset}) {
-         $self->{s_kwd} = '';
+           !!!cp (153.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           !!!cp (153);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          ## reconsume
          !!!emit ($self->{ct}); # comment
-Line 1919 
 sub _get_next_token ($) {
+Line 2135 
 sub _get_next_token ($) {
          redo A;
        } else {
          !!!cp (156);
+         ## XML5: Unless EOF, swith to the bogus comment state.
          !!!parse-error (type => 'no space before DOCTYPE name');
          $self->{state} = BEFORE_DOCTYPE_NAME_STATE;
          ## reconsume
          redo A;
        }
      } elsif ($self->{state} == BEFORE_DOCTYPE_NAME_STATE) {
+       ## XML5: "DOCTYPE root name before state".
        if ($is_space->{$self->{nc}}) {
          !!!cp (157);
          ## Stay in the state
-Line 1932 
 sub _get_next_token ($) {
+Line 2151 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
          !!!cp (158);
+         ## XML5: No parse error.
          !!!parse-error (type => 'no DOCTYPE name');
          $self->{state} = DATA_STATE;
          $self->{s_kwd} = '';
-Line 1950 
 sub _get_next_token ($) {
+Line 2170 
 sub _get_next_token ($) {
          !!!emit ($self->{ct}); # DOCTYPE (quirks)
          redo A;
+       } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [
+         !!!cp (159.1);
+         !!!parse-error (type => 'no DOCTYPE name');
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
+         $self->{in_subset} = 1;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # DOCTYPE
+         redo A;
        } else {
          !!!cp (160);
          $self->{ct}->{name} = chr $self->{nc};
-Line 1959 
 sub _get_next_token ($) {
+Line 2188 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == DOCTYPE_NAME_STATE) {
- ## ISSUE: Redundant "First," in the spec.
+       ## XML5: "DOCTYPE root name state".
+       ## ISSUE: Redundant "First," in the spec.
        if ($is_space->{$self->{nc}}) {
          !!!cp (161);
          $self->{state} = AFTER_DOCTYPE_NAME_STATE;
-Line 1985 
 sub _get_next_token ($) {
+Line 2217 
 sub _get_next_token ($) {
          !!!emit ($self->{ct}); # DOCTYPE
          redo A;
+       } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [
+         !!!cp (163.1);
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
+         $self->{in_subset} = 1;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # DOCTYPE
+         redo A;
        } else {
          !!!cp (164);
          $self->{ct}->{name}
-Line 1994 
 sub _get_next_token ($) {
+Line 2234 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == AFTER_DOCTYPE_NAME_STATE) {
+       ## XML5: Corresponding to XML5's "DOCTYPE root name after
+       ## state", but implemented differently.
        if ($is_space->{$self->{nc}}) {
          !!!cp (165);
          ## Stay in the state
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
-         !!!cp (166);
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{state} = DATA_STATE;
+           !!!cp (166);
-         $self->{s_kwd} = '';
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         } else {
+           !!!cp (166.1);
+           !!!parse-error (type => 'no md def'); ## TODO: type
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
          !!!next-input-character;
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         !!!emit ($self->{ct}); # DOCTYPE
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (167);
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         !!!parse-error (type => 'unclosed DOCTYPE');
+           !!!cp (167);
-         $self->{state} = DATA_STATE;
+           !!!parse-error (type => 'unclosed DOCTYPE');
-         $self->{s_kwd} = '';
+           $self->{state} = DATA_STATE;
-         ## reconsume
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
-         $self->{ct}->{quirks} = 1;
+         } else {
-         !!!emit ($self->{ct}); # DOCTYPE
+           !!!cp (167.12);
+           !!!parse-error (type => 'unclosed md'); ## TODO: type
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
+         ## Reconsume.
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
          redo A;
        } elsif ($self->{nc} == 0x0050 or # P
                 $self->{nc} == 0x0070) { # p
+         !!!cp (167.1);
          $self->{state} = PUBLIC_STATE;
-         $self->{s_kwd} = chr $self->{nc};
+         $self->{kwd} = chr $self->{nc};
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == 0x0053 or # S
                 $self->{nc} == 0x0073) { # s
+         !!!cp (167.2);
          $self->{state} = SYSTEM_STATE;
-         $self->{s_kwd} = chr $self->{nc};
+         $self->{kwd} = chr $self->{nc};
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0022 and # "
+                ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN or
+                 $self->{ct}->{type} == PARAMETER_ENTITY_TOKEN)) {
+         !!!cp (167.21);
+         $self->{state} = DOCTYPE_ENTITY_VALUE_DOUBLE_QUOTED_STATE;
+         $self->{ct}->{value} = ''; # ENTITY
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0027 and # '
+                ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN or
+                 $self->{ct}->{type} == PARAMETER_ENTITY_TOKEN)) {
+         !!!cp (167.22);
+         $self->{state} = DOCTYPE_ENTITY_VALUE_SINGLE_QUOTED_STATE;
+         $self->{ct}->{value} = ''; # ENTITY
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{is_xml} and
+                $self->{ct}->{type} == DOCTYPE_TOKEN and
+                $self->{nc} == 0x005B) { # [
+         !!!cp (167.3);
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
+         $self->{in_subset} = 1;
          !!!next-input-character;
+         !!!emit ($self->{ct}); # DOCTYPE
          redo A;
        } else {
-         !!!cp (180);
+         !!!parse-error (type => 'string after DOCTYPE name'); ## TODO: type
-         !!!parse-error (type => 'string after DOCTYPE name');
-         $self->{ct}->{quirks} = 1;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           !!!cp (180);
+           $self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           !!!cp (180.1);
+           $self->{state} = BOGUS_MD_STATE;
+         }
-         $self->{state} = BOGUS_DOCTYPE_STATE;
          !!!next-input-character;
          redo A;
        }
-Line 2048 
 sub _get_next_token ($) {
+Line 2335 
 sub _get_next_token ($) {
 x0042, # B
 x004C, # L
 x0049, # I
-           ]->[length $self->{s_kwd}] or
+           ]->[length $self->{kwd}] or
            $self->{nc} == [
              undef,
 x0075, # u
 x0062, # b
 x006C, # l
 x0069, # i
-           ]->[length $self->{s_kwd}]) {
+           ]->[length $self->{kwd}]) {
          !!!cp (175);
          ## Stay in the state.
-         $self->{s_kwd} .= chr $self->{nc};
+         $self->{kwd} .= chr $self->{nc};
          !!!next-input-character;
          redo A;
-       } elsif ((length $self->{s_kwd}) == 5 and
+       } elsif ((length $self->{kwd}) == 5 and
                 ($self->{nc} == 0x0043 or # C
                  $self->{nc} == 0x0063)) { # c
-         !!!cp (168);
+         if ($self->{is_xml} and
+             ($self->{kwd} ne 'PUBLI' or $self->{nc} == 0x0063)) { # c
+           !!!cp (168.1);
+           !!!parse-error (type => 'lowercase keyword', ## TODO: type
+                           text => 'PUBLIC',
+                           line => $self->{line_prev},
+                           column => $self->{column_prev} - 4);
+         } else {
+           !!!cp (168);
+         }
          $self->{state} = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
          !!!next-input-character;
          redo A;
        } else {
-         !!!cp (169);
+         !!!parse-error (type => 'string after DOCTYPE name', ## TODO: type
-         !!!parse-error (type => 'string after DOCTYPE name',
                          line => $self->{line_prev},
-                         column => $self->{column_prev} + 1 - length $self->{s_kwd});
+                         column => $self->{column_prev} + 1 - length $self->{kwd});
-         $self->{ct}->{quirks} = 1;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           !!!cp (169);
-         $self->{state} = BOGUS_DOCTYPE_STATE;
+           $self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           !!!cp (169.1);
+           $self->{state} = BOGUS_MD_STATE;
+         }
          ## Reconsume.
          redo A;
        }
-Line 2087 
 sub _get_next_token ($) {
+Line 2387 
 sub _get_next_token ($) {
 x0053, # S
 x0054, # T
 x0045, # E
-           ]->[length $self->{s_kwd}] or
+           ]->[length $self->{kwd}] or
            $self->{nc} == [
              undef,
 x0079, # y
 x0073, # s
 x0074, # t
 x0065, # e
-           ]->[length $self->{s_kwd}]) {
+           ]->[length $self->{kwd}]) {
          !!!cp (170);
          ## Stay in the state.
-         $self->{s_kwd} .= chr $self->{nc};
+         $self->{kwd} .= chr $self->{nc};
          !!!next-input-character;
          redo A;
-       } elsif ((length $self->{s_kwd}) == 5 and
+       } elsif ((length $self->{kwd}) == 5 and
                 ($self->{nc} == 0x004D or # M
                  $self->{nc} == 0x006D)) { # m
-         !!!cp (171);
+         if ($self->{is_xml} and
+             ($self->{kwd} ne 'SYSTE' or $self->{nc} == 0x006D)) { # m
+           !!!cp (171.1);
+           !!!parse-error (type => 'lowercase keyword', ## TODO: type
+                           text => 'SYSTEM',
+                           line => $self->{line_prev},
+                           column => $self->{column_prev} - 4);
+         } else {
+           !!!cp (171);
+         }
          $self->{state} = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
          !!!next-input-character;
          redo A;
        } else {
-         !!!cp (172);
+         !!!parse-error (type => 'string after DOCTYPE name', ## TODO: type
-         !!!parse-error (type => 'string after DOCTYPE name',
                          line => $self->{line_prev},
-                         column => $self->{column_prev} + 1 - length $self->{s_kwd});
+                         column => $self->{column_prev} + 1 - length $self->{kwd});
-         $self->{ct}->{quirks} = 1;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           !!!cp (172);
-         $self->{state} = BOGUS_DOCTYPE_STATE;
+           $self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           !!!cp (172.1);
+           $self->{state} = BOGUS_MD_STATE;
+         }
          ## Reconsume.
          redo A;
        }
-Line 2137 
 sub _get_next_token ($) {
+Line 2450 
 sub _get_next_token ($) {
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} eq 0x003E) { # >
-         !!!cp (184);
          !!!parse-error (type => 'no PUBLIC literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           !!!cp (184);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           !!!cp (184.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
          !!!next-input-character;
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{ct}->{quirks} = 1;
-         !!!emit ($self->{ct}); # DOCTYPE
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (185);
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         !!!parse-error (type => 'unclosed DOCTYPE');
+           !!!cp (185);
+           !!!parse-error (type => 'unclosed DOCTYPE');
-         $self->{state} = DATA_STATE;
+           $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           !!!cp (185.1);
+           !!!parse-error (type => 'unclosed md'); ## TODO: type
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
          ## reconsume
-         $self->{ct}->{quirks} = 1;
          !!!emit ($self->{ct}); # DOCTYPE
+         redo A;
+       } elsif ($self->{is_xml} and
+                $self->{ct}->{type} == DOCTYPE_TOKEN and
+                $self->{nc} == 0x005B) { # [
+         !!!cp (186.1);
+         !!!parse-error (type => 'no PUBLIC literal');
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
+         $self->{in_subset} = 1;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # DOCTYPE
          redo A;
        } else {
-         !!!cp (186);
          !!!parse-error (type => 'string after PUBLIC');
-         $self->{ct}->{quirks} = 1;
-         $self->{state} = BOGUS_DOCTYPE_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           !!!cp (186);
+           $self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           !!!cp (186.2);
+           $self->{state} = BOGUS_MD_STATE;
+         }
          !!!next-input-character;
          redo A;
        }
-Line 2176 
 sub _get_next_token ($) {
+Line 2514 
 sub _get_next_token ($) {
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
-         !!!cp (188);
          !!!parse-error (type => 'unclosed PUBLIC literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           !!!cp (188);
-         !!!next-input-character;
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
-         $self->{ct}->{quirks} = 1;
+           $self->{ct}->{quirks} = 1;
-         !!!emit ($self->{ct}); # DOCTYPE
+         } else {
+           !!!cp (188.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (189);
          !!!parse-error (type => 'unclosed PUBLIC literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           !!!cp (189);
-         ## reconsume
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
-         $self->{ct}->{quirks} = 1;
+           $self->{ct}->{quirks} = 1;
+         } else {
+           !!!cp (189.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
+         ## Reconsume.
          !!!emit ($self->{ct}); # DOCTYPE
          redo A;
        } else {
          !!!cp (190);
-         $self->{ct}->{pubid} # DOCTYPE
+         $self->{ct}->{pubid} .= chr $self->{nc}; # DOCTYPE/ENTITY/NOTATION
-             .= chr $self->{nc};
          $self->{read_until}->($self->{ct}->{pubid}, q[">],
                                length $self->{ct}->{pubid});
-Line 2217 
 sub _get_next_token ($) {
+Line 2562 
 sub _get_next_token ($) {
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
-         !!!cp (192);
          !!!parse-error (type => 'unclosed PUBLIC literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           !!!cp (192);
-         !!!next-input-character;
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
-         $self->{ct}->{quirks} = 1;
+           $self->{ct}->{quirks} = 1;
-         !!!emit ($self->{ct}); # DOCTYPE
+         } else {
+           !!!cp (192.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (193);
          !!!parse-error (type => 'unclosed PUBLIC literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           !!!cp (193);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           !!!cp (193.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
          ## reconsume
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{ct}->{quirks} = 1;
-         !!!emit ($self->{ct}); # DOCTYPE
          redo A;
        } else {
          !!!cp (194);
-         $self->{ct}->{pubid} # DOCTYPE
+         $self->{ct}->{pubid} .= chr $self->{nc}; # DOCTYPE/ENTITY/NOTATION
-             .= chr $self->{nc};
          $self->{read_until}->($self->{ct}->{pubid}, q['>],
                                length $self->{ct}->{pubid});
-Line 2259 
 sub _get_next_token ($) {
+Line 2611 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == 0x0022) { # "
          !!!cp (196);
-         $self->{ct}->{sysid} = ''; # DOCTYPE
+         $self->{ct}->{sysid} = ''; # DOCTYPE/ENTITY/NOTATION
          $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == 0x0027) { # '
          !!!cp (197);
-         $self->{ct}->{sysid} = ''; # DOCTYPE
+         $self->{ct}->{sysid} = ''; # DOCTYPE/ENTITY/NOTATION
          $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
-         !!!cp (198);
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{state} = DATA_STATE;
+           if ($self->{is_xml}) {
-         $self->{s_kwd} = '';
+             !!!cp (198.1);
+             !!!parse-error (type => 'no SYSTEM literal');
+           } else {
+             !!!cp (198);
+           }
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         } else {
+           if ($self->{ct}->{type} == NOTATION_TOKEN) {
+             !!!cp (198.2);
+           } else {
+             !!!cp (198.3);
+             !!!parse-error (type => 'no SYSTEM literal');
+           }
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
          !!!next-input-character;
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         !!!emit ($self->{ct}); # DOCTYPE
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (199);
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         !!!parse-error (type => 'unclosed DOCTYPE');
+           !!!cp (199);
+           !!!parse-error (type => 'unclosed DOCTYPE');
-         $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           !!!parse-error (type => 'unclosed md'); ## TODO: type
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
          ## reconsume
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{ct}->{quirks} = 1;
+         redo A;
+       } elsif ($self->{is_xml} and
+                $self->{ct}->{type} == DOCTYPE_TOKEN and
+                $self->{nc} == 0x005B) { # [
+         !!!cp (200.1);
+         !!!parse-error (type => 'no SYSTEM literal');
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
+         $self->{in_subset} = 1;
+         !!!next-input-character;
          !!!emit ($self->{ct}); # DOCTYPE
          redo A;
        } else {
-         !!!cp (200);
          !!!parse-error (type => 'string after PUBLIC literal');
-         $self->{ct}->{quirks} = 1;
-         $self->{state} = BOGUS_DOCTYPE_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           !!!cp (200);
+           $self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           !!!cp (200.2);
+           $self->{state} = BOGUS_MD_STATE;
+         }
          !!!next-input-character;
          redo A;
        }
-Line 2318 
 sub _get_next_token ($) {
+Line 2705 
 sub _get_next_token ($) {
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
-         !!!cp (204);
          !!!parse-error (type => 'no SYSTEM literal');
-         $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
          !!!next-input-character;
-         $self->{ct}->{quirks} = 1;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         !!!emit ($self->{ct}); # DOCTYPE
+           !!!cp (204);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           !!!cp (204.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (205);
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         !!!parse-error (type => 'unclosed DOCTYPE');
+           !!!cp (205);
+           !!!parse-error (type => 'unclosed DOCTYPE');
-         $self->{state} = DATA_STATE;
+           $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           !!!cp (205.1);
+           !!!parse-error (type => 'unclosed md'); ## TODO: type
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
          ## reconsume
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
+         redo A;
+       } elsif ($self->{is_xml} and
+                $self->{ct}->{type} == DOCTYPE_TOKEN and
+                $self->{nc} == 0x005B) { # [
+         !!!cp (206.1);
+         !!!parse-error (type => 'no SYSTEM literal');
-         $self->{ct}->{quirks} = 1;
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
+         $self->{in_subset} = 1;
+         !!!next-input-character;
          !!!emit ($self->{ct}); # DOCTYPE
          redo A;
        } else {
-         !!!cp (206);
          !!!parse-error (type => 'string after SYSTEM');
-         $self->{ct}->{quirks} = 1;
-         $self->{state} = BOGUS_DOCTYPE_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           !!!cp (206);
+           $self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           !!!cp (206.2);
+           $self->{state} = BOGUS_MD_STATE;
+         }
          !!!next-input-character;
          redo A;
        }
-Line 2355 
 sub _get_next_token ($) {
+Line 2769 
 sub _get_next_token ($) {
          $self->{state} = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
          !!!next-input-character;
          redo A;
-       } elsif ($self->{nc} == 0x003E) { # >
+       } elsif (not $self->{is_xml} and $self->{nc} == 0x003E) { # >
-         !!!cp (208);
          !!!parse-error (type => 'unclosed SYSTEM literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           !!!cp (208);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           !!!cp (208.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
          !!!next-input-character;
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{ct}->{quirks} = 1;
-         !!!emit ($self->{ct}); # DOCTYPE
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (209);
          !!!parse-error (type => 'unclosed SYSTEM literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           !!!cp (209);
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           !!!cp (209.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
          ## reconsume
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{ct}->{quirks} = 1;
-         !!!emit ($self->{ct}); # DOCTYPE
          redo A;
        } else {
          !!!cp (210);
-         $self->{ct}->{sysid} # DOCTYPE
+         $self->{ct}->{sysid} .= chr $self->{nc}; # DOCTYPE/ENTITY/NOTATION
-             .= chr $self->{nc};
          $self->{read_until}->($self->{ct}->{sysid}, q[">],
                                length $self->{ct}->{sysid});
-Line 2396 
 sub _get_next_token ($) {
+Line 2817 
 sub _get_next_token ($) {
          $self->{state} = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
          !!!next-input-character;
          redo A;
-       } elsif ($self->{nc} == 0x003E) { # >
+       } elsif (not $self->{is_xml} and $self->{nc} == 0x003E) { # >
          !!!cp (212);
          !!!parse-error (type => 'unclosed SYSTEM literal');
-Line 2409 
 sub _get_next_token ($) {
+Line 2830 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (213);
          !!!parse-error (type => 'unclosed SYSTEM literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           !!!cp (213);
-         ## reconsume
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
-         $self->{ct}->{quirks} = 1;
+           $self->{ct}->{quirks} = 1;
-         !!!emit ($self->{ct}); # DOCTYPE
+         } else {
+           !!!cp (213.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
+         ## reconsume
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
          redo A;
        } else {
          !!!cp (214);
-         $self->{ct}->{sysid} # DOCTYPE
+         $self->{ct}->{sysid} .= chr $self->{nc}; # DOCTYPE/ENTITY/NOTATION
-             .= chr $self->{nc};
          $self->{read_until}->($self->{ct}->{sysid}, q['>],
                                length $self->{ct}->{sysid});
-Line 2433 
 sub _get_next_token ($) {
+Line 2857 
 sub _get_next_token ($) {
        }
      } elsif ($self->{state} == AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {
        if ($is_space->{$self->{nc}}) {
-         !!!cp (215);
+         if ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN) {
-         ## Stay in the state
+           !!!cp (215.1);
+           $self->{state} = BEFORE_NDATA_STATE;
+         } else {
+           !!!cp (215);
+           ## Stay in the state
+         }
          !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
-         !!!cp (216);
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{state} = DATA_STATE;
+           !!!cp (216);
-         $self->{s_kwd} = '';
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         } else {
+           !!!cp (216.1);
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
          !!!next-input-character;
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
+         redo A;
+       } elsif ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN and
+                ($self->{nc} == 0x004E or # N
+                 $self->{nc} == 0x006E)) { # n
+         !!!cp (216.2);
+         !!!parse-error (type => 'no space before NDATA'); ## TODO: type
+         $self->{state} = NDATA_STATE;
+         $self->{kwd} = chr $self->{nc};
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           !!!cp (217);
+           !!!parse-error (type => 'unclosed DOCTYPE');
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           !!!cp (217.1);
+           !!!parse-error (type => 'unclosed md'); ## TODO: type
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
+         ## reconsume
+         !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
+         redo A;
+       } elsif ($self->{is_xml} and
+                $self->{ct}->{type} == DOCTYPE_TOKEN and
+                $self->{nc} == 0x005B) { # [
+         !!!cp (218.1);
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
+         $self->{in_subset} = 1;
+         !!!next-input-character;
          !!!emit ($self->{ct}); # DOCTYPE
+         redo A;
+       } else {
+         !!!parse-error (type => 'string after SYSTEM literal');
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           !!!cp (218);
+           #$self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           !!!cp (218.2);
+           $self->{state} = BOGUS_MD_STATE;
+         }
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == BEFORE_NDATA_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         !!!cp (218.3);
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         !!!cp (218.4);
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ENTITY
+         redo A;
+       } elsif ($self->{nc} == 0x004E or # N
+                $self->{nc} == 0x006E) { # n
+         !!!cp (218.5);
+         $self->{state} = NDATA_STATE;
+         $self->{kwd} = chr $self->{nc};
+         !!!next-input-character;
          redo A;
        } elsif ($self->{nc} == -1) {
-         !!!cp (217);
+         !!!cp (218.6);
-         !!!parse-error (type => 'unclosed DOCTYPE');
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
-         $self->{state} = DATA_STATE;
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
-         $self->{s_kwd} = '';
          ## reconsume
+         !!!emit ($self->{ct}); # ENTITY
-         $self->{ct}->{quirks} = 1;
-         !!!emit ($self->{ct}); # DOCTYPE
          redo A;
        } else {
-         !!!cp (218);
+         !!!cp (218.7);
          !!!parse-error (type => 'string after SYSTEM literal');
-         #$self->{ct}->{quirks} = 1;
+         $self->{state} = BOGUS_MD_STATE;
-         $self->{state} = BOGUS_DOCTYPE_STATE;
          !!!next-input-character;
          redo A;
        }
-Line 2476 
 sub _get_next_token ($) {
+Line 2972 
 sub _get_next_token ($) {
          !!!emit ($self->{ct}); # DOCTYPE
          redo A;
+       } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [
+         !!!cp (220.1);
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
+         $self->{in_subset} = 1;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # DOCTYPE
+         redo A;
        } elsif ($self->{nc} == -1) {
          !!!cp (220);
          $self->{state} = DATA_STATE;
-Line 2488 
 sub _get_next_token ($) {
+Line 2992 
 sub _get_next_token ($) {
        } else {
          !!!cp (221);
          my $s = '';
-         $self->{read_until}->($s, q[>], 0);
+         $self->{read_until}->($s, q{>[}, 0);
          ## Stay in the state
          !!!next-input-character;
-Line 2588 
 sub _get_next_token ($) {
+Line 3092 
 sub _get_next_token ($) {
 x003C => 1, 0x0026 => 1, -1 => 1, # <, &
              $self->{entity_add} => 1,
            }->{$self->{nc}}) {
-         !!!cp (1001);
+         if ($self->{is_xml}) {
+           !!!cp (1001.1);
+           !!!parse-error (type => 'bare ero',
+                           line => $self->{line_prev},
+                           column => $self->{column_prev}
+                               + ($self->{nc} == -1 ? 1 : 0));
+         } else {
+           !!!cp (1001);
+           ## No error
+         }
          ## Don't consume
-         ## No error
          ## Return nothing.
          #
        } elsif ($self->{nc} == 0x0023) { # #
          !!!cp (999);
          $self->{state} = ENTITY_HASH_STATE;
-         $self->{s_kwd} = '#';
+         $self->{kwd} = '#';
          !!!next-input-character;
          redo A;
-       } elsif ((0x0041 <= $self->{nc} and
+       } elsif ($self->{is_xml} or
+                (0x0041 <= $self->{nc} and
                  $self->{nc} <= 0x005A) or # A..Z
                 (0x0061 <= $self->{nc} and
                  $self->{nc} <= 0x007A)) { # a..z
          !!!cp (998);
          require Whatpm::_NamedEntityList;
          $self->{state} = ENTITY_NAME_STATE;
-         $self->{s_kwd} = chr $self->{nc};
+         $self->{kwd} = chr $self->{nc};
-         $self->{entity__value} = $self->{s_kwd};
+         $self->{entity__value} = $self->{kwd};
          $self->{entity__match} = 0;
          !!!next-input-character;
          redo A;
-Line 2643 
 sub _get_next_token ($) {
+Line 3156 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == ENTITY_HASH_STATE) {
-       if ($self->{nc} == 0x0078 or # x
+       if ($self->{nc} == 0x0078) { # x
-           $self->{nc} == 0x0058) { # X
          !!!cp (995);
          $self->{state} = HEXREF_X_STATE;
-         $self->{s_kwd} .= chr $self->{nc};
+         $self->{kwd} .= chr $self->{nc};
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0058) { # X
+         !!!cp (995.1);
+         if ($self->{is_xml}) {
+           !!!parse-error (type => 'uppercase hcro'); ## TODO: type
+         }
+         $self->{state} = HEXREF_X_STATE;
+         $self->{kwd} .= chr $self->{nc};
          !!!next-input-character;
          redo A;
        } elsif (0x0030 <= $self->{nc} and
                 $self->{nc} <= 0x0039) { # 0..9
          !!!cp (994);
          $self->{state} = NCR_NUM_STATE;
-         $self->{s_kwd} = $self->{nc} - 0x0030;
+         $self->{kwd} = $self->{nc} - 0x0030;
          !!!next-input-character;
          redo A;
        } else {
-Line 2690 
 sub _get_next_token ($) {
+Line 3211 
 sub _get_next_token ($) {
        if (0x0030 <= $self->{nc} and
            $self->{nc} <= 0x0039) { # 0..9
          !!!cp (1012);
-         $self->{s_kwd} *= 10;
+         $self->{kwd} *= 10;
-         $self->{s_kwd} += $self->{nc} - 0x0030;
+         $self->{kwd} += $self->{nc} - 0x0030;
          ## Stay in the state.
          !!!next-input-character;
-Line 2707 
 sub _get_next_token ($) {
+Line 3228 
 sub _get_next_token ($) {
          #
        }
-       my $code = $self->{s_kwd};
+       my $code = $self->{kwd};
        my $l = $self->{line_prev};
        my $c = $self->{column_prev};
-       if ($charref_map->{$code}) {
+       if ((not $self->{is_xml} and $charref_map->{$code}) or
+           ($self->{is_xml} and 0xD800 <= $code and $code <= 0xDFFF) or
+           ($self->{is_xml} and $code == 0x0000)) {
          !!!cp (1015);
          !!!parse-error (type => 'invalid character reference',
                          text => (sprintf 'U+%04X', $code),
-Line 2750 
 sub _get_next_token ($) {
+Line 3273 
 sub _get_next_token ($) {
          # 0..9, A..F, a..f
          !!!cp (990);
          $self->{state} = HEXREF_HEX_STATE;
-         $self->{s_kwd} = 0;
+         $self->{kwd} = 0;
          ## Reconsume.
          redo A;
        } else {
-Line 2768 
 sub _get_next_token ($) {
+Line 3291 
 sub _get_next_token ($) {
            $self->{s_kwd} = '';
            ## Reconsume.
            !!!emit ({type => CHARACTER_TOKEN,
-                     data => '&' . $self->{s_kwd},
+                     data => '&' . $self->{kwd},
                      line => $self->{line_prev},
-                     column => $self->{column_prev} - length $self->{s_kwd},
+                     column => $self->{column_prev} - length $self->{kwd},
                     });
            redo A;
          } else {
            !!!cp (989);
-           $self->{ca}->{value} .= '&' . $self->{s_kwd};
+           $self->{ca}->{value} .= '&' . $self->{kwd};
            $self->{state} = $self->{prev_state};
            $self->{s_kwd} = '';
            ## Reconsume.
-Line 2786 
 sub _get_next_token ($) {
+Line 3309 
 sub _get_next_token ($) {
        if (0x0030 <= $self->{nc} and $self->{nc} <= 0x0039) {
          # 0..9
          !!!cp (1002);
-         $self->{s_kwd} *= 0x10;
+         $self->{kwd} *= 0x10;
-         $self->{s_kwd} += $self->{nc} - 0x0030;
+         $self->{kwd} += $self->{nc} - 0x0030;
          ## Stay in the state.
          !!!next-input-character;
          redo A;
        } elsif (0x0061 <= $self->{nc} and
                 $self->{nc} <= 0x0066) { # a..f
          !!!cp (1003);
-         $self->{s_kwd} *= 0x10;
+         $self->{kwd} *= 0x10;
-         $self->{s_kwd} += $self->{nc} - 0x0060 + 9;
+         $self->{kwd} += $self->{nc} - 0x0060 + 9;
          ## Stay in the state.
          !!!next-input-character;
          redo A;
        } elsif (0x0041 <= $self->{nc} and
                 $self->{nc} <= 0x0046) { # A..F
          !!!cp (1004);
-         $self->{s_kwd} *= 0x10;
+         $self->{kwd} *= 0x10;
-         $self->{s_kwd} += $self->{nc} - 0x0040 + 9;
+         $self->{kwd} += $self->{nc} - 0x0040 + 9;
          ## Stay in the state.
          !!!next-input-character;
          redo A;
-Line 2820 
 sub _get_next_token ($) {
+Line 3343 
 sub _get_next_token ($) {
          #
        }
-       my $code = $self->{s_kwd};
+       my $code = $self->{kwd};
        my $l = $self->{line_prev};
        my $c = $self->{column_prev};
-       if ($charref_map->{$code}) {
+       if ((not $self->{is_xml} and $charref_map->{$code}) or
+           ($self->{is_xml} and 0xD800 <= $code and $code <= 0xDFFF) or
+           ($self->{is_xml} and $code == 0x0000)) {
          !!!cp (1008);
          !!!parse-error (type => 'invalid character reference',
                          text => (sprintf 'U+%04X', $code),
-Line 2857 
 sub _get_next_token ($) {
+Line 3382 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == ENTITY_NAME_STATE) {
-       if (length $self->{s_kwd} < 30 and
+       if ((0x0041 <= $self->{nc} and # a
-           ## NOTE: Some number greater than the maximum length of entity name
+            $self->{nc} <= 0x005A) or # x
-           ((0x0041 <= $self->{nc} and # a
+           (0x0061 <= $self->{nc} and # a
-             $self->{nc} <= 0x005A) or # x
+            $self->{nc} <= 0x007A) or # z
-            (0x0061 <= $self->{nc} and # a
+           (0x0030 <= $self->{nc} and # 0
-             $self->{nc} <= 0x007A) or # z
+            $self->{nc} <= 0x0039) or # 9
-            (0x0030 <= $self->{nc} and # 0
+           $self->{nc} == 0x003B or # ;
-             $self->{nc} <= 0x0039) or # 9
+           ($self->{is_xml} and
-            $self->{nc} == 0x003B)) { # ;
+            not ($is_space->{$self->{nc}} or
+                 {
+x003C => 1, 0x0026 => 1, -1 => 1, # <, &
+                   $self->{entity_add} => 1,
+                 }->{$self->{nc}}))) {
          our $EntityChar;
-         $self->{s_kwd} .= chr $self->{nc};
+         $self->{kwd} .= chr $self->{nc};
-         if (defined $EntityChar->{$self->{s_kwd}}) {
+         if (defined $EntityChar->{$self->{kwd}} or
+             $self->{ge}->{$self->{kwd}}) {
            if ($self->{nc} == 0x003B) { # ;
-             !!!cp (1020);
+             if (defined $self->{ge}->{$self->{kwd}}) {
-             $self->{entity__value} = $EntityChar->{$self->{s_kwd}};
+               if ($self->{ge}->{$self->{kwd}}->{only_text}) {
+                 !!!cp (1020.1);
+                 $self->{entity__value} = $self->{ge}->{$self->{kwd}}->{value};
+               } else {
+                 if (defined $self->{ge}->{$self->{kwd}}->{notation}) {
+                   !!!cp (1020.2);
+                   !!!parse-error (type => 'unparsed entity', ## TODO: type
+                                   value => $self->{kwd});
+                 } else {
+                   !!!cp (1020.3);
+                 }
+                 $self->{entity__value} = '&' . $self->{kwd}; ## TODO: expand
+               }
+             } else {
+               if ($self->{is_xml}) {
+                 !!!cp (1020.4);
+                 !!!parse-error (type => 'entity not declared', ## TODO: type
+                                 value => $self->{kwd},
+                                 level => {
+                                           'amp;' => $self->{level}->{warn},
+                                           'quot;' => $self->{level}->{warn},
+                                           'lt;' => $self->{level}->{warn},
+                                           'gt;' => $self->{level}->{warn},
+                                           'apos;' => $self->{level}->{warn},
+                                          }->{$self->{kwd}} ||
+                                          $self->{level}->{must});
+               } else {
+                 !!!cp (1020);
+               }
+               $self->{entity__value} = $EntityChar->{$self->{kwd}};
+             }
              $self->{entity__match} = 1;
              !!!next-input-character;
              #
            } else {
              !!!cp (1021);
-             $self->{entity__value} = $EntityChar->{$self->{s_kwd}};
+             $self->{entity__value} = $EntityChar->{$self->{kwd}};
              $self->{entity__match} = -1;
              ## Stay in the state.
              !!!next-input-character;
-Line 2905 
 sub _get_next_token ($) {
+Line 3465 
 sub _get_next_token ($) {
          if ($self->{prev_state} != DATA_STATE and # in attribute
              $self->{entity__match} < -1) {
            !!!cp (1024);
-           $data = '&' . $self->{s_kwd};
+           $data = '&' . $self->{kwd};
            #
          } else {
            !!!cp (1025);
-Line 2917 
 sub _get_next_token ($) {
+Line 3477 
 sub _get_next_token ($) {
          !!!cp (1026);
          !!!parse-error (type => 'bare ero',
                          line => $self->{line_prev},
-                         column => $self->{column_prev} - length $self->{s_kwd});
+                         column => $self->{column_prev} - length $self->{kwd});
-         $data = '&' . $self->{s_kwd};
+         $data = '&' . $self->{kwd};
          #
        }
-Line 2941 
 sub _get_next_token ($) {
+Line 3501 
 sub _get_next_token ($) {
                    data => $data,
                    has_reference => $has_ref,
                    line => $self->{line_prev},
-                   column => $self->{column_prev} + 1 - length $self->{s_kwd},
+                   column => $self->{column_prev} + 1 - length $self->{kwd},
                   });
          redo A;
        } else {
-Line 2957 
 sub _get_next_token ($) {
+Line 3517 
 sub _get_next_token ($) {
      ## XML-only states
      } elsif ($self->{state} == PI_STATE) {
+       ## XML5: "Pi state" and "DOCTYPE pi state".
        if ($is_space->{$self->{nc}} or
-           $self->{nc} == 0x003F or # ? ## XML5: Same as "Anything else"
+           $self->{nc} == 0x003F or # ?
            $self->{nc} == -1) {
+         ## XML5: U+003F: "pi state": Same as "Anything else"; "DOCTYPE
+         ## pi state": Switch to the "DOCTYPE pi after state".  EOF:
+         ## "DOCTYPE pi state": Parse error, switch to the "data
+         ## state".
          !!!parse-error (type => 'bare pio', ## TODO: type
                          line => $self->{line_prev},
                          column => $self->{column_prev}
-Line 2974 
 sub _get_next_token ($) {
+Line 3540 
 sub _get_next_token ($) {
                        };
          redo A;
        } else {
+         ## XML5: "DOCTYPE pi state": Stay in the state.
          $self->{ct} = {type => PI_TOKEN,
                         target => chr $self->{nc},
                         data => '',
-Line 2991 
 sub _get_next_token ($) {
+Line 3558 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == -1) {
          !!!parse-error (type => 'no pic'); ## TODO: type
-         $self->{state} = DATA_STATE;
+         if ($self->{in_subset}) {
-         $self->{s_kwd} = '';
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          ## Reconsume.
          !!!emit ($self->{ct}); # pi
          redo A;
-Line 3023 
 sub _get_next_token ($) {
+Line 3594 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == -1) {
          !!!parse-error (type => 'no pic'); ## TODO: type
-         $self->{state} = DATA_STATE;
+         if ($self->{in_subset}) {
-         $self->{s_kwd} = '';
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state"
+         } else {
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          ## Reprocess.
          !!!emit ($self->{ct}); # pi
          redo A;
-Line 3038 
 sub _get_next_token ($) {
+Line 3613 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == PI_AFTER_STATE) {
+       ## XML5: Part of "Pi after state".
        if ($self->{nc} == 0x003E) { # >
-         $self->{state} = DATA_STATE;
+         if ($self->{in_subset}) {
-         $self->{s_kwd} = '';
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          !!!next-input-character;
          !!!emit ($self->{ct}); # pi
          redo A;
-Line 3063 
 sub _get_next_token ($) {
+Line 3644 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == PI_DATA_AFTER_STATE) {
-       ## XML5: Same as "pi after state" in XML5
+       ## XML5: Same as "pi after state" and "DOCTYPE pi after state".
        if ($self->{nc} == 0x003E) { # >
-         $self->{state} = DATA_STATE;
+         if ($self->{in_subset}) {
-         $self->{s_kwd} = '';
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
          !!!next-input-character;
          !!!emit ($self->{ct}); # pi
          redo A;
-Line 3081 
 sub _get_next_token ($) {
+Line 3667 
 sub _get_next_token ($) {
          ## Reprocess.
          redo A;
        }
+     } elsif ($self->{state} == DOCTYPE_INTERNAL_SUBSET_STATE) {
+       if ($self->{nc} == 0x003C) { # <
+         $self->{state} = DOCTYPE_TAG_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0025) { # %
+         ## XML5: Not defined yet.
+         ## TODO:
+         if (not $self->{stop_processing} and
+             not $self->{document}->xml_standalone) {
+           !!!parse-error (type => 'stop processing', ## TODO: type
+                           level => $self->{level}->{info});
+           $self->{stop_processing} = 1;
+         }
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x005D) { # ]
+         delete $self->{in_subset};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_AFTER_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed internal subset'); ## TODO: type
+         delete $self->{in_subset};
+         $self->{state} = DATA_STATE;
+         $self->{s_kwd} = '';
+         ## Reconsume.
+         !!!emit ({type => END_OF_DOCTYPE_TOKEN});
+         redo A;
+       } else {
+         unless ($self->{internal_subset_tainted}) {
+           ## XML5: No parse error.
+           !!!parse-error (type => 'string in internal subset');
+           $self->{internal_subset_tainted} = 1;
+         }
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_INTERNAL_SUBSET_AFTER_STATE) {
+       if ($self->{nc} == 0x003E) { # >
+         $self->{state} = DATA_STATE;
+         $self->{s_kwd} = '';
+         !!!next-input-character;
+         !!!emit ({type => END_OF_DOCTYPE_TOKEN});
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed DOCTYPE');
+         $self->{state} = DATA_STATE;
+         $self->{s_kwd} = '';
+         ## Reconsume.
+         !!!emit ({type => END_OF_DOCTYPE_TOKEN});
+         redo A;
+       } else {
+         ## XML5: No parse error and stay in the state.
+         !!!parse-error (type => 'string after internal subset'); ## TODO: type
+         $self->{state} = BOGUS_DOCTYPE_INTERNAL_SUBSET_AFTER_STATE;
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == BOGUS_DOCTYPE_INTERNAL_SUBSET_AFTER_STATE) {
+       if ($self->{nc} == 0x003E) { # >
+         $self->{state} = DATA_STATE;
+         $self->{s_kwd} = '';
+         !!!next-input-character;
+         !!!emit ({type => END_OF_DOCTYPE_TOKEN});
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{state} = DATA_STATE;
+         $self->{s_kwd} = '';
+         ## Reconsume.
+         !!!emit ({type => END_OF_DOCTYPE_TOKEN});
+         redo A;
+       } else {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_TAG_STATE) {
+       if ($self->{nc} == 0x0021) { # !
+         $self->{state} = DOCTYPE_MARKUP_DECLARATION_OPEN_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003F) { # ?
+         $self->{state} = PI_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'bare stago');
+         $self->{state} = DATA_STATE;
+         $self->{s_kwd} = '';
+         ## Reconsume.
+         redo A;
+       } else {
+         !!!parse-error (type => 'bare stago', ## XML5: Not a parse error.
+                         line => $self->{line_prev},
+                         column => $self->{column_prev});
+         $self->{state} = BOGUS_COMMENT_STATE;
+         $self->{ct} = {type => COMMENT_TOKEN,
+                        data => '',
+                       }; ## NOTE: Will be discarded.
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_MARKUP_DECLARATION_OPEN_STATE) {
+       ## XML5: "DOCTYPE markup declaration state".
+       if ($self->{nc} == 0x002D) { # -
+         $self->{state} = MD_HYPHEN_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0045 or # E
+                $self->{nc} == 0x0065) { # e
+         $self->{state} = MD_E_STATE;
+         $self->{kwd} = chr $self->{nc};
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0041 or # A
+                $self->{nc} == 0x0061) { # a
+         $self->{state} = MD_ATTLIST_STATE;
+         $self->{kwd} = chr $self->{nc};
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x004E or # N
+                $self->{nc} == 0x006E) { # n
+         $self->{state} = MD_NOTATION_STATE;
+         $self->{kwd} = chr $self->{nc};
+         !!!next-input-character;
+         redo A;
+       } else {
+         #
+       }
+       ## XML5: No parse error.
+       !!!parse-error (type => 'bogus comment',
+                       line => $self->{line_prev},
+                       column => $self->{column_prev} - 1);
+       ## Reconsume.
+       $self->{state} = BOGUS_COMMENT_STATE;
+       $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded.
+       redo A;
+     } elsif ($self->{state} == MD_E_STATE) {
+       if ($self->{nc} == 0x004E or # N
+           $self->{nc} == 0x006E) { # n
+         $self->{state} = MD_ENTITY_STATE;
+         $self->{kwd} .= chr $self->{nc};
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x004C or # L
+                $self->{nc} == 0x006C) { # l
+         ## XML5: <!ELEMENT> not supported.
+         $self->{state} = MD_ELEMENT_STATE;
+         $self->{kwd} .= chr $self->{nc};
+         !!!next-input-character;
+         redo A;
+       } else {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'bogus comment',
+                         line => $self->{line_prev},
+                         column => $self->{column_prev} - 2
+                             + 1 * ($self->{nc} == -1));
+         ## Reconsume.
+         $self->{state} = BOGUS_COMMENT_STATE;
+         $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded
+         redo A;
+       }
+     } elsif ($self->{state} == MD_ENTITY_STATE) {
+       if ($self->{nc} == [
+             undef,
+             undef,
+x0054, # T
+x0049, # I
+x0054, # T
+           ]->[length $self->{kwd}] or
+           $self->{nc} == [
+             undef,
+             undef,
+x0074, # t
+x0069, # i
+x0074, # t
+           ]->[length $self->{kwd}]) {
+         ## Stay in the state.
+         $self->{kwd} .= chr $self->{nc};
+         !!!next-input-character;
+         redo A;
+       } elsif ((length $self->{kwd}) == 5 and
+                ($self->{nc} == 0x0059 or # Y
+                 $self->{nc} == 0x0079)) { # y
+         if ($self->{kwd} ne 'ENTIT' or $self->{nc} == 0x0079) {
+           !!!parse-error (type => 'lowercase keyword', ## TODO: type
+                           text => 'ENTITY',
+                           line => $self->{line_prev},
+                           column => $self->{column_prev} - 4);
+         }
+         $self->{ct} = {type => GENERAL_ENTITY_TOKEN, name => '',
+                        line => $self->{line_prev},
+                        column => $self->{column_prev} - 6};
+         $self->{state} = DOCTYPE_MD_STATE;
+         !!!next-input-character;
+         redo A;
+       } else {
+         !!!parse-error (type => 'bogus comment',
+                         line => $self->{line_prev},
+                         column => $self->{column_prev} - 1
+                             - (length $self->{kwd})
+                             + 1 * ($self->{nc} == -1));
+         $self->{state} = BOGUS_COMMENT_STATE;
+         ## Reconsume.
+         $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded
+         redo A;
+       }
+     } elsif ($self->{state} == MD_ELEMENT_STATE) {
+       if ($self->{nc} == [
+            undef,
+            undef,
+x0045, # E
+x004D, # M
+x0045, # E
+x004E, # N
+           ]->[length $self->{kwd}] or
+           $self->{nc} == [
+            undef,
+            undef,
+x0065, # e
+x006D, # m
+x0065, # e
+x006E, # n
+           ]->[length $self->{kwd}]) {
+         ## Stay in the state.
+         $self->{kwd} .= chr $self->{nc};
+         !!!next-input-character;
+         redo A;
+       } elsif ((length $self->{kwd}) == 6 and
+                ($self->{nc} == 0x0054 or # T
+                 $self->{nc} == 0x0074)) { # t
+         if ($self->{kwd} ne 'ELEMEN' or $self->{nc} == 0x0074) {
+           !!!parse-error (type => 'lowercase keyword', ## TODO: type
+                           text => 'ELEMENT',
+                           line => $self->{line_prev},
+                           column => $self->{column_prev} - 5);
+         }
+         $self->{ct} = {type => ELEMENT_TOKEN, name => '',
+                        line => $self->{line_prev},
+                        column => $self->{column_prev} - 7};
+         $self->{state} = DOCTYPE_MD_STATE;
+         !!!next-input-character;
+         redo A;
+       } else {
+         !!!parse-error (type => 'bogus comment',
+                         line => $self->{line_prev},
+                         column => $self->{column_prev} - 1
+                             - (length $self->{kwd})
+                             + 1 * ($self->{nc} == -1));
+         $self->{state} = BOGUS_COMMENT_STATE;
+         ## Reconsume.
+         $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded
+         redo A;
+       }
+     } elsif ($self->{state} == MD_ATTLIST_STATE) {
+       if ($self->{nc} == [
+            undef,
+x0054, # T
+x0054, # T
+x004C, # L
+x0049, # I
+x0053, # S
+           ]->[length $self->{kwd}] or
+           $self->{nc} == [
+            undef,
+x0074, # t
+x0074, # t
+x006C, # l
+x0069, # i
+x0073, # s
+           ]->[length $self->{kwd}]) {
+         ## Stay in the state.
+         $self->{kwd} .= chr $self->{nc};
+         !!!next-input-character;
+         redo A;
+       } elsif ((length $self->{kwd}) == 6 and
+                ($self->{nc} == 0x0054 or # T
+                 $self->{nc} == 0x0074)) { # t
+         if ($self->{kwd} ne 'ATTLIS' or $self->{nc} == 0x0074) {
+           !!!parse-error (type => 'lowercase keyword', ## TODO: type
+                           text => 'ATTLIST',
+                           line => $self->{line_prev},
+                           column => $self->{column_prev} - 5);
+         }
+         $self->{ct} = {type => ATTLIST_TOKEN, name => '',
+                        attrdefs => [],
+                        line => $self->{line_prev},
+                        column => $self->{column_prev} - 7};
+         $self->{state} = DOCTYPE_MD_STATE;
+         !!!next-input-character;
+         redo A;
+       } else {
+         !!!parse-error (type => 'bogus comment',
+                         line => $self->{line_prev},
+                         column => $self->{column_prev} - 1
+                              - (length $self->{kwd})
+                              + 1 * ($self->{nc} == -1));
+         $self->{state} = BOGUS_COMMENT_STATE;
+         ## Reconsume.
+         $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded
+         redo A;
+       }
+     } elsif ($self->{state} == MD_NOTATION_STATE) {
+       if ($self->{nc} == [
+            undef,
+x004F, # O
+x0054, # T
+x0041, # A
+x0054, # T
+x0049, # I
+x004F, # O
+           ]->[length $self->{kwd}] or
+           $self->{nc} == [
+            undef,
+x006F, # o
+x0074, # t
+x0061, # a
+x0074, # t
+x0069, # i
+x006F, # o
+           ]->[length $self->{kwd}]) {
+         ## Stay in the state.
+         $self->{kwd} .= chr $self->{nc};
+         !!!next-input-character;
+         redo A;
+       } elsif ((length $self->{kwd}) == 7 and
+                ($self->{nc} == 0x004E or # N
+                 $self->{nc} == 0x006E)) { # n
+         if ($self->{kwd} ne 'NOTATIO' or $self->{nc} == 0x006E) {
+           !!!parse-error (type => 'lowercase keyword', ## TODO: type
+                           text => 'NOTATION',
+                           line => $self->{line_prev},
+                           column => $self->{column_prev} - 6);
+         }
+         $self->{ct} = {type => NOTATION_TOKEN, name => '',
+                        line => $self->{line_prev},
+                        column => $self->{column_prev} - 8};
+         $self->{state} = DOCTYPE_MD_STATE;
+         !!!next-input-character;
+         redo A;
+       } else {
+         !!!parse-error (type => 'bogus comment',
+                         line => $self->{line_prev},
+                         column => $self->{column_prev} - 1
+                             - (length $self->{kwd})
+                             + 1 * ($self->{nc} == -1));
+         $self->{state} = BOGUS_COMMENT_STATE;
+         ## Reconsume.
+         $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_MD_STATE) {
+       ## XML5: "DOCTYPE ENTITY state", "DOCTYPE ATTLIST state", and
+       ## "DOCTYPE NOTATION state".
+       if ($is_space->{$self->{nc}}) {
+         ## XML5: [NOTATION] Switch to the "DOCTYPE NOTATION identifier state".
+         $self->{state} = BEFORE_MD_NAME_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN and
+                $self->{nc} == 0x0025) { # %
+         ## XML5: Switch to the "DOCTYPE bogus comment state".
+         !!!parse-error (type => 'no space before md name'); ## TODO: type
+         $self->{state} = DOCTYPE_ENTITY_PARAMETER_BEFORE_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         ## Reconsume.
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         ## XML5: Switch to the "DOCTYPE bogus comment state".
+         !!!parse-error (type => 'no md name'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         redo A;
+       } else {
+         ## XML5: Switch to the "DOCTYPE bogus comment state".
+         !!!parse-error (type => 'no space before md name'); ## TODO: type
+         $self->{state} = BEFORE_MD_NAME_STATE;
+         redo A;
+       }
+     } elsif ($self->{state} == BEFORE_MD_NAME_STATE) {
+       ## XML5: "DOCTYPE ENTITY parameter state", "DOCTYPE ENTITY type
+       ## before state", "DOCTYPE ATTLIST name before state".
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN and
+                $self->{nc} == 0x0025) { # %
+         $self->{state} = DOCTYPE_ENTITY_PARAMETER_BEFORE_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         ## XML5: Same as "Anything else".
+         !!!parse-error (type => 'no md name'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         ## Reconsume.
+         redo A;
+       } else {
+         ## XML5: [ATTLIST] Not defined yet.
+         $self->{ct}->{name} .= chr $self->{nc};
+         $self->{state} = MD_NAME_STATE;
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_ENTITY_PARAMETER_BEFORE_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## XML5: Switch to the "DOCTYPE ENTITY parameter state".
+         $self->{ct}->{type} = PARAMETER_ENTITY_TOKEN;
+         $self->{state} = BEFORE_MD_NAME_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         ## XML5: Same as "Anything else".
+         !!!parse-error (type => 'no md name'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md');
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         ## Reconsume.
+         redo A;
+       } else {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'no space after ENTITY percent'); ## TODO: type
+         $self->{state} = BOGUS_COMMENT_STATE;
+         $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == MD_NAME_STATE) {
+       ## XML5: "DOCTYPE ENTITY name state" and "DOCTYPE ATTLIST name state".
+       if ($is_space->{$self->{nc}}) {
+         if ($self->{ct}->{type} == ATTLIST_TOKEN) {
+           $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;
+         } elsif ($self->{ct}->{type} == ELEMENT_TOKEN) {
+           $self->{state} = AFTER_ELEMENT_NAME_STATE;
+         } else { # ENTITY/NOTATION
+           $self->{state} = AFTER_DOCTYPE_NAME_STATE;
+         }
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         if ($self->{ct}->{type} == ATTLIST_TOKEN) {
+           #
+         } else {
+           !!!parse-error (type => 'no md def'); ## TODO: type
+         }
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ELEMENT/ENTITY/ATTLIST/NOTATION
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         ## XML5: [ATTLIST] No parse error.
+         !!!parse-error (type => 'unclosed md');
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         ## Reconsume.
+         !!!emit ($self->{ct}); # ELEMENT/ENTITY/ATTLIST/NOTATION
+         redo A;
+       } else {
+         ## XML5: [ATTLIST] Not defined yet.
+         $self->{ct}->{name} .= chr $self->{nc};
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_ATTLIST_NAME_AFTER_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         !!!emit ($self->{ct});
+         redo A;
+       } else {
+         ## XML5: Not defined yet.
+         $self->{ca} = {name => chr ($self->{nc}), # attrdef
+                        tokens => [],
+                        line => $self->{line}, column => $self->{column}};
+         $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_NAME_STATE;
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_NAME_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_NAME_AFTER_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         ## XML5: Same as "anything else".
+         !!!parse-error (type => 'no attr type'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } elsif ($self->{nc} == 0x0028) { # (
+         ## XML5: Same as "anything else".
+         !!!parse-error (type => 'no space before paren'); ## TODO: type
+         $self->{state} = BEFORE_ALLOWED_TOKEN_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } else {
+         ## XML5: Not defined yet.
+         $self->{ca}->{name} .= chr $self->{nc};
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_NAME_AFTER_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         ## XML5: Same as "anything else".
+         !!!parse-error (type => 'no attr type'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } elsif ($self->{nc} == 0x0028) { # (
+         ## XML5: Same as "anything else".
+         $self->{state} = BEFORE_ALLOWED_TOKEN_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         !!!next-input-character;
+         !!!emit ($self->{ct});
+         redo A;
+       } else {
+         ## XML5: Not defined yet.
+         $self->{ca}->{type} = chr $self->{nc};
+         $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_TYPE_STATE;
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_TYPE_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_TYPE_AFTER_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0023) { # #
+         ## XML5: Same as "anything else".
+         !!!parse-error (type => 'no space before default value'); ## TODO: type
+         $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_BEFORE_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0022) { # "
+         ## XML5: Same as "anything else".
+         !!!parse-error (type => 'no space before default value'); ## TODO: type
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0027) { # '
+         ## XML5: Same as "anything else".
+         !!!parse-error (type => 'no space before default value'); ## TODO: type
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         ## XML5: Same as "anything else".
+         !!!parse-error (type => 'no attr default'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } elsif ($self->{nc} == 0x0028) { # (
+         ## XML5: Same as "anything else".
+         !!!parse-error (type => 'no space before paren'); ## TODO: type
+         $self->{state} = BEFORE_ALLOWED_TOKEN_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         !!!next-input-character;
+         !!!emit ($self->{ct});
+         redo A;
+       } else {
+         ## XML5: Not defined yet.
+         $self->{ca}->{type} .= chr $self->{nc};
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_TYPE_AFTER_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0028) { # (
+         ## XML5: Same as "anything else".
+         $self->{state} = BEFORE_ALLOWED_TOKEN_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0023) { # #
+         $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_BEFORE_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0022) { # "
+         ## XML5: Same as "anything else".
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0027) { # '
+         ## XML5: Same as "anything else".
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         ## XML5: Same as "anything else".
+         !!!parse-error (type => 'no attr default'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         !!!next-input-character;
+         !!!emit ($self->{ct});
+         redo A;
+       } else {
+         ## XML5: Switch to the "DOCTYPE bogus comment state".
+         !!!parse-error (type => 'unquoted attr value'); ## TODO: type
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == BEFORE_ALLOWED_TOKEN_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x007C) { # |
+         !!!parse-error (type => 'empty allowed token'); ## TODO: type
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0029) { # )
+         !!!parse-error (type => 'empty allowed token'); ## TODO: type
+         $self->{state} = AFTER_ALLOWED_TOKENS_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         !!!parse-error (type => 'unclosed allowed tokens'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         !!!next-input-character;
+         !!!emit ($self->{ct});
+         redo A;
+       } else {
+         push @{$self->{ca}->{tokens}}, chr $self->{nc};
+         $self->{state} = ALLOWED_TOKEN_STATE;
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == ALLOWED_TOKEN_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = AFTER_ALLOWED_TOKEN_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x007C) { # |
+         $self->{state} = BEFORE_ALLOWED_TOKEN_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0029) { # )
+         $self->{state} = AFTER_ALLOWED_TOKENS_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         !!!parse-error (type => 'unclosed allowed tokens'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         !!!next-input-character;
+         !!!emit ($self->{ct});
+         redo A;
+       } else {
+         $self->{ca}->{tokens}->[-1] .= chr $self->{nc};
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == AFTER_ALLOWED_TOKEN_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x007C) { # |
+         $self->{state} = BEFORE_ALLOWED_TOKEN_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0029) { # )
+         $self->{state} = AFTER_ALLOWED_TOKENS_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         !!!parse-error (type => 'unclosed allowed tokens'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         !!!next-input-character;
+         !!!emit ($self->{ct});
+         redo A;
+       } else {
+         !!!parse-error (type => 'space in allowed token', ## TODO: type
+                         line => $self->{line_prev},
+                         column => $self->{column_prev});
+         $self->{ca}->{tokens}->[-1] .= ' ' . chr $self->{nc};
+         $self->{state} = ALLOWED_TOKEN_STATE;
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == AFTER_ALLOWED_TOKENS_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = BEFORE_ATTR_DEFAULT_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0023) { # #
+         !!!parse-error (type => 'no space before default value'); ## TODO: type
+         $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_BEFORE_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0022) { # "
+         !!!parse-error (type => 'no space before default value'); ## TODO: type
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0027) { # '
+         !!!parse-error (type => 'no space before default value'); ## TODO: type
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         !!!parse-error (type => 'no attr default'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct});
+         redo A;
+       } else {
+         !!!parse-error (type => 'unquoted attr value'); ## TODO: type
+         $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == BEFORE_ATTR_DEFAULT_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0023) { # #
+         $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_BEFORE_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0022) { # "
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0027) { # '
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         !!!parse-error (type => 'no attr default'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct});
+         redo A;
+       } else {
+         !!!parse-error (type => 'unquoted attr value'); ## TODO: type
+         $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_BEFORE_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'no default type'); ## TODO: type
+         $self->{state} = BOGUS_MD_STATE;
+         ## Reconsume.
+         redo A;
+       } elsif ($self->{nc} == 0x0022) { # "
+         ## XML5: Same as "anything else".
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0027) { # '
+         ## XML5: Same as "anything else".
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         ## XML5: Same as "anything else".
+         !!!parse-error (type => 'no attr default'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         !!!next-input-character;
+         !!!emit ($self->{ct});
+         redo A;
+       } else {
+         $self->{ca}->{default} = chr $self->{nc};
+         $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_STATE;
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_AFTER_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0022) { # "
+         ## XML5: Same as "anything else".
+         !!!parse-error (type => 'no space before default value'); ## TODO: type
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0027) { # '
+         ## XML5: Same as "anything else".
+         !!!parse-error (type => 'no space before default value'); ## TODO: type
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         ## XML5: Same as "anything else".
+         push @{$self->{ct}->{attrdefs}}, $self->{ca};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         push @{$self->{ct}->{attrdefs}}, $self->{ca};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         !!!next-input-character;
+         !!!emit ($self->{ct});
+         redo A;
+       } else {
+         $self->{ca}->{default} .= chr $self->{nc};
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_AFTER_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0022) { # "
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0027) { # '
+         $self->{ca}->{value} = '';
+         $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         push @{$self->{ct}->{attrdefs}}, $self->{ca};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         ## XML5: No parse error.
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         push @{$self->{ct}->{attrdefs}}, $self->{ca};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
+         !!!next-input-character;
+         !!!emit ($self->{ct});
+         redo A;
+       } else {
+         ## XML5: Not defined yet.
+         if ($self->{ca}->{default} eq 'FIXED') {
+           $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
+         } else {
+           push @{$self->{ct}->{attrdefs}}, $self->{ca};
+           $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;
+         }
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == AFTER_ATTLIST_ATTR_VALUE_QUOTED_STATE) {
+       if ($is_space->{$self->{nc}} or
+           $self->{nc} == -1 or
+           $self->{nc} == 0x003E) { # >
+         $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;
+         ## Reconsume.
+         redo A;
+       } else {
+         !!!parse-error (type => 'no space before attr name'); ## TODO: type
+         $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == NDATA_STATE) {
+       ## ASCII case-insensitive
+       if ($self->{nc} == [
+             undef,
+x0044, # D
+x0041, # A
+x0054, # T
+           ]->[length $self->{kwd}] or
+           $self->{nc} == [
+             undef,
+x0064, # d
+x0061, # a
+x0074, # t
+           ]->[length $self->{kwd}]) {
+         !!!cp (172.2);
+         ## Stay in the state.
+         $self->{kwd} .= chr $self->{nc};
+         !!!next-input-character;
+         redo A;
+       } elsif ((length $self->{kwd}) == 4 and
+                ($self->{nc} == 0x0041 or # A
+                 $self->{nc} == 0x0061)) { # a
+         if ($self->{kwd} ne 'NDAT' or $self->{nc} == 0x0061) { # a
+           !!!cp (172.3);
+           !!!parse-error (type => 'lowercase keyword', ## TODO: type
+                           text => 'NDATA',
+                           line => $self->{line_prev},
+                           column => $self->{column_prev} - 4);
+         } else {
+           !!!cp (172.4);
+         }
+         $self->{state} = AFTER_NDATA_STATE;
+         !!!next-input-character;
+         redo A;
+       } else {
+         !!!parse-error (type => 'string after literal', ## TODO: type
+                         line => $self->{line_prev},
+                         column => $self->{column_prev} + 1
+                             - length $self->{kwd});
+         !!!cp (172.5);
+         $self->{state} = BOGUS_MD_STATE;
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == AFTER_NDATA_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = BEFORE_NOTATION_NAME_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         !!!parse-error (type => 'no notation name'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ENTITY
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ENTITY
+         redo A;
+       } else {
+         !!!parse-error (type => 'string after literal', ## TODO: type
+                         line => $self->{line_prev},
+                         column => $self->{column_prev} + 1
+                             - length $self->{kwd});
+         $self->{state} = BOGUS_MD_STATE;
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == BEFORE_NOTATION_NAME_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         !!!parse-error (type => 'no notation name'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ENTITY
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ENTITY
+         redo A;
+       } else {
+         $self->{ct}->{notation} = chr $self->{nc}; # ENTITY
+         $self->{state} = NOTATION_NAME_STATE;
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == NOTATION_NAME_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = AFTER_MD_DEF_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ENTITY
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ENTITY
+         redo A;
+       } else {
+         $self->{ct}->{notation} .= chr $self->{nc}; # ENTITY
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_ENTITY_VALUE_DOUBLE_QUOTED_STATE) {
+       if ($self->{nc} == 0x0022) { # "
+         $self->{state} = AFTER_MD_DEF_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0026) { # &
+         $self->{prev_state} = $self->{state};
+         $self->{state} = ENTITY_VALUE_ENTITY_STATE;
+         $self->{entity_add} = 0x0022; # "
+         !!!next-input-character;
+         redo A;
+ ## TODO: %
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed entity value'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         ## Reconsume.
+         !!!emit ($self->{ct}); # ENTITY
+         redo A;
+       } else {
+         $self->{ct}->{value} .= chr $self->{nc}; # ENTITY
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_ENTITY_VALUE_SINGLE_QUOTED_STATE) {
+       if ($self->{nc} == 0x0027) { # '
+         $self->{state} = AFTER_MD_DEF_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0026) { # &
+         $self->{prev_state} = $self->{state};
+         $self->{state} = ENTITY_VALUE_ENTITY_STATE;
+         $self->{entity_add} = 0x0027; # '
+         !!!next-input-character;
+         redo A;
+ ## TODO: %
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed entity value'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         ## Reconsume.
+         !!!emit ($self->{ct}); # ENTITY
+         redo A;
+       } else {
+         $self->{ct}->{value} .= chr $self->{nc}; # ENTITY
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == ENTITY_VALUE_ENTITY_STATE) {
+       if ($is_space->{$self->{nc}} or
+           {
+x003C => 1, 0x0026 => 1, -1 => 1, # <, &
+             $self->{entity_add} => 1,
+           }->{$self->{nc}}) {
+         !!!parse-error (type => 'bare ero',
+                         line => $self->{line_prev},
+                         column => $self->{column_prev}
+                             + ($self->{nc} == -1 ? 1 : 0));
+         ## Don't consume
+         ## Return nothing.
+         #
+       } elsif ($self->{nc} == 0x0023) { # #
+         $self->{ca} = $self->{ct};
+         $self->{state} = ENTITY_HASH_STATE;
+         $self->{kwd} = '#';
+         !!!next-input-character;
+         redo A;
+       } else {
+         #
+       }
+       $self->{ct}->{value} .= '&';
+       $self->{state} = $self->{prev_state};
+       ## Reconsume.
+       redo A;
+     } elsif ($self->{state} == AFTER_ELEMENT_NAME_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = BEFORE_ELEMENT_CONTENT_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0028) { # (
+         $self->{state} = AFTER_CM_GROUP_OPEN_STATE;
+         $self->{ct}->{content} = ['('];
+         $self->{group_depth} = 1;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         !!!parse-error (type => 'no md def'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ELEMENT
+         redo A;
+       } else {
+         $self->{ct}->{content} = [chr $self->{nc}];
+         $self->{state} = CONTENT_KEYWORD_STATE;
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == CONTENT_KEYWORD_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = AFTER_MD_DEF_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ELEMENT
+         redo A;
+       } else {
+         $self->{ct}->{content}->[-1] .= chr $self->{nc}; # ELEMENT
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == AFTER_CM_GROUP_OPEN_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0028) { # (
+         $self->{group_depth}++;
+         push @{$self->{ct}->{content}}, chr $self->{nc};
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x007C or # |
+                $self->{nc} == 0x002C) { # ,
+         !!!parse-error (type => 'empty element name'); ## TODO: type
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0029) { # )
+         !!!parse-error (type => 'empty element name'); ## TODO: type
+         push @{$self->{ct}->{content}}, chr $self->{nc};
+         $self->{group_depth}--;
+         $self->{state} = AFTER_CM_GROUP_CLOSE_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         !!!parse-error (type => 'unclosed cm group'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ELEMENT
+         redo A;
+       } else {
+         push @{$self->{ct}->{content}}, chr $self->{nc};
+         $self->{state} = CM_ELEMENT_NAME_STATE;
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == CM_ELEMENT_NAME_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x002A or # *
+                $self->{nc} == 0x002B or # +
+                $self->{nc} == 0x003F) { # ?
+         push @{$self->{ct}->{content}}, chr $self->{nc};
+         $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x007C or # |
+                $self->{nc} == 0x002C) { # ,
+         push @{$self->{ct}->{content}}, $self->{nc} == 0x007C ? ' | ' : ', ';
+         $self->{state} = AFTER_CM_GROUP_OPEN_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0029) { # )
+         $self->{group_depth}--;
+         push @{$self->{ct}->{content}}, chr $self->{nc};
+         $self->{state} = AFTER_CM_GROUP_CLOSE_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         !!!parse-error (type => 'unclosed cm group'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ELEMENT
+         redo A;
+       } else {
+         $self->{ct}->{content}->[-1] .= chr $self->{nc};
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == AFTER_CM_ELEMENT_NAME_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x007C or # |
+                $self->{nc} == 0x002C) { # ,
+         push @{$self->{ct}->{content}}, $self->{nc} == 0x007C ? ' | ' : ', ';
+         $self->{state} = AFTER_CM_GROUP_OPEN_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0029) { # )
+         $self->{group_depth}--;
+         push @{$self->{ct}->{content}}, chr $self->{nc};
+         $self->{state} = AFTER_CM_GROUP_CLOSE_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         !!!parse-error (type => 'unclosed cm group'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ELEMENT
+         redo A;
+       } else {
+         !!!parse-error (type => 'after element name'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = BOGUS_MD_STATE;
+         !!!next-input-character;
+         redo A;
+       }
+     } elsif ($self->{state} == AFTER_CM_GROUP_CLOSE_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         if ($self->{group_depth}) {
+           $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
+         } else {
+           $self->{state} = AFTER_MD_DEF_STATE;
+         }
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x002A or # *
+                $self->{nc} == 0x002B or # +
+                $self->{nc} == 0x003F) { # ?
+         push @{$self->{ct}->{content}}, chr $self->{nc};
+         if ($self->{group_depth}) {
+           $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
+         } else {
+           $self->{state} = AFTER_MD_DEF_STATE;
+         }
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x0029) { # )
+         if ($self->{group_depth}) {
+           $self->{group_depth}--;
+           push @{$self->{ct}->{content}}, chr $self->{nc};
+           ## Stay in the state.
+           !!!next-input-character;
+           redo A;
+         } else {
+           !!!parse-error (type => 'string after md def'); ## TODO: type
+           $self->{state} = BOGUS_MD_STATE;
+           ## Reconsume.
+           redo A;
+         }
+       } elsif ($self->{nc} == 0x003E) { # >
+         if ($self->{group_depth}) {
+           !!!parse-error (type => 'unclosed cm group'); ## TODO: type
+           push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         }
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ELEMENT
+         redo A;
+       } else {
+         if ($self->{group_depth}) {
+           $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
+         } else {
+           !!!parse-error (type => 'string after md def'); ## TODO: type
+           $self->{state} = BOGUS_MD_STATE;
+         }
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == AFTER_MD_DEF_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ENTITY/ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         !!!parse-error (type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ENTITY/ELEMENT
+         redo A;
+       } else {
+         !!!parse-error (type => 'string after md def'); ## TODO: type
+         $self->{state} = BOGUS_MD_STATE;
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == BOGUS_MD_STATE) {
+       if ($self->{nc} == 0x003E) { # >
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         !!!next-input-character;
+         !!!emit ($self->{ct}); # ATTLIST/ENTITY/NOTATION
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         ## Reconsume.
+         !!!emit ($self->{ct}); # ATTLIST/ENTITY/NOTATION
+         redo A;
+       } else {
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       }
      } else {
        die "$0: $self->{state}: Unknown state";
      }
-Line 3092 
 sub _get_next_token ($) {
+Line 5128 
 sub _get_next_token ($) {
 ;
  ## $Date$

 Legend:



Removed from v.1.11
 


changed lines


 
Added in v.1.25
 Legend:



Removed from v.1.11
 


changed lines


 
Added in v.1.25
-Removed from v.1.11
+Added in v.1.25

admin@suikawiki.org	ViewVC Help
Powered by ViewVC 1.1.24