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

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

Parent Directory | Revision Log | View Patch Patch

-revision 1.15 by wakaba,
Sat Oct 18 08:05:29 2008 UTC
+revision 1.34 by wakaba,
Sat Sep  5 11:31:58 2009 UTC
 Line 105 
 sub COMMENT_START_STATE () { 14 }
  sub COMMENT_START_DASH_STATE () { 15 }
  sub COMMENT_STATE () { 16 }
  sub COMMENT_END_STATE () { 17 }
+ sub COMMENT_END_BANG_STATE () { 102 }
+ sub COMMENT_END_SPACE_STATE () { 103 } ## LAST
  sub COMMENT_END_DASH_STATE () { 18 }
  sub BOGUS_COMMENT_STATE () { 19 }
  sub DOCTYPE_STATE () { 20 }
-Line 177 
 sub DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATIO
+Line 179 
 sub DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATIO
  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 187 
 sub FOREIGN_EL () { 0b1_00000000000 }
+Line 206 
 sub FOREIGN_EL () { 0b1_00000000000 }
  ## Character reference mappings
  my $charref_map = {
+x00 => 0xFFFD, # REPLACEMENT CHARACTER
 x0D => 0x000A,
 x80 => 0x20AC,
-x81 => 0xFFFD,
+x81 => 0x0081,
 x82 => 0x201A,
 x83 => 0x0192,
 x84 => 0x201E,
-Line 201 
 my $charref_map = {
+Line 221 
 my $charref_map = {
 x8A => 0x0160,
 x8B => 0x2039,
 x8C => 0x0152,
-x8D => 0xFFFD,
+x8D => 0x008D,
 x8E => 0x017D,
-x8F => 0xFFFD,
+x8F => 0x008F,
-x90 => 0xFFFD,
+x90 => 0x0090,
 x91 => 0x2018,
 x92 => 0x2019,
 x93 => 0x201C,
-Line 217 
 my $charref_map = {
+Line 237 
 my $charref_map = {
 x9A => 0x0161,
 x9B => 0x203A,
 x9C => 0x0153,
-x9D => 0xFFFD,
+x9D => 0x009D,
 x9E => 0x017E,
 x9F => 0x0178,
  }; # $charref_map
- $charref_map->{$_} = 0xFFFD
+ $charref_map->{$_} = $_
-     for 0x0000..0x0008, 0x000B, 0x000E..0x001F, 0x007F,
+     for 0x0001..0x0008, 0x000B, 0x000E..0x001F, 0x007F,
-xD800..0xDFFF, 0xFDD0..0xFDDF, ## ISSUE: 0xFDEF
+xD800..0xDFFF, 0xFDD0..0xFDEF,
 xFFFE, 0xFFFF, 0x1FFFE, 0x1FFFF, 0x2FFFE, 0x2FFFF, 0x3FFFE, 0x3FFFF,
 x4FFFE, 0x4FFFF, 0x5FFFE, 0x5FFFF, 0x6FFFE, 0x6FFFF, 0x7FFFE,
 x7FFFF, 0x8FFFE, 0x8FFFF, 0x9FFFE, 0x9FFFF, 0xAFFFE, 0xAFFFF,
-Line 1083 
 sub _get_next_token ($) {
+Line 1103 
 sub _get_next_token ($) {
          $self->{s_kwd} = '';
          # reconsume
-         return  ($self->{ct}); # start tag or end tag
+         ## Discard the token.
+         #return  ($self->{ct}); # start tag or end tag
          redo A;
        } elsif ($self->{nc} == 0x002F) { # /
-Line 1224 
 sub _get_next_token ($) {
+Line 1245 
 sub _get_next_token ($) {
          $self->{s_kwd} = '';
          # reconsume
-         return  ($self->{ct}); # start tag or end tag
+         ## Discard the token.
+         #return  ($self->{ct}); # start tag or end tag
          redo A;
        } else {
          if ({
 x0022 => 1, # "
 x0027 => 1, # '
+x003C => 1, # <
 x003D => 1, # =
              }->{$self->{nc}}) {
-Line 1409 
 sub _get_next_token ($) {
+Line 1432 
 sub _get_next_token ($) {
          $self->{s_kwd} = '';
          # reconsume
-         return  ($self->{ct}); # start tag or end tag
+         ## Discard the token.
+         #return  ($self->{ct}); # start tag or end tag
          redo A;
        } else {
-         if ($self->{nc} == 0x0022 or # "
+         if ({
-             $self->{nc} == 0x0027) { # '
+x0022 => 1, # "
+x0027 => 1, # '
+x003C => 1, # <
+             }->{$self->{nc}}) {
            ## XML5: Not a parse error.
            $self->{parse_error}->(level => $self->{level}->{must}, type => 'bad attribute name');
-Line 1573 
 sub _get_next_token ($) {
+Line 1600 
 sub _get_next_token ($) {
          $self->{state} = DATA_STATE;
          # reconsume
-         return  ($self->{ct}); # start tag or end tag
+         ## Discard the token.
+         #return  ($self->{ct}); # start tag or end tag
          redo A;
        } else {
-Line 1585 
 sub _get_next_token ($) {
+Line 1613 
 sub _get_next_token ($) {
          }
-         if ($self->{nc} == 0x0022 or # "
+         if ({
-             $self->{nc} == 0x0027) { # '
+x0022 => 1, # "
+x0027 => 1, # '
+x003C => 1, # <
+             }->{$self->{nc}}) {
            ## XML5: Not a parse error.
            $self->{parse_error}->(level => $self->{level}->{must}, type => 'bad attribute name');
-Line 1719 
 sub _get_next_token ($) {
+Line 1750 
 sub _get_next_token ($) {
          $self->{s_kwd} = '';
          ## reconsume
-         return  ($self->{ct}); # start tag or end tag
+         ## Discard the token.
+         #return  ($self->{ct}); # start tag or end tag
          redo A;
        } else {
-         if ($self->{nc} == 0x003D) { # =
+         if ($self->{nc} == 0x003D or $self->{nc} == 0x003C) { # =, <
            ## XML5: Not a parse error.
            $self->{parse_error}->(level => $self->{level}->{must}, type => 'bad attribute value');
-Line 1799 
 sub _get_next_token ($) {
+Line 1831 
 sub _get_next_token ($) {
      }
          redo A;
+       } elsif ($self->{is_xml} and
+                $is_space->{$self->{nc}}) {
+         $self->{ca}->{value} .= ' ';
+         ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
        } elsif ($self->{nc} == -1) {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed attribute value');
          if ($self->{ct}->{type} == START_TAG_TOKEN) {
-Line 1823 
 sub _get_next_token ($) {
+Line 1872 
 sub _get_next_token ($) {
            $self->{state} = DATA_STATE;
            $self->{s_kwd} = '';
            ## reconsume
-           return  ($self->{ct}); # end tag
+           ## Discard the token.
+           #return  ($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.
-           return  ($self->{ct}); # ATTLIST
+           ## Discard the token.
+           #return  ($self->{ct}); # ATTLIST
            redo A;
          } else {
            die "$0: $self->{ct}->{type}: Unknown token type";
-Line 1846 
 sub _get_next_token ($) {
+Line 1901 
 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 1913 
 sub _get_next_token ($) {
+Line 1968 
 sub _get_next_token ($) {
      }
          redo A;
+       } elsif ($self->{is_xml} and
+                $is_space->{$self->{nc}}) {
+         $self->{ca}->{value} .= ' ';
+         ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
        } elsif ($self->{nc} == -1) {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed attribute value');
          if ($self->{ct}->{type} == START_TAG_TOKEN) {
-Line 1922 
 sub _get_next_token ($) {
+Line 1994 
 sub _get_next_token ($) {
            $self->{state} = DATA_STATE;
            $self->{s_kwd} = '';
            ## reconsume
-           return  ($self->{ct}); # start tag
+           ## Discard the token.
+           #return  ($self->{ct}); # start tag
            redo A;
          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {
            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
-Line 1937 
 sub _get_next_token ($) {
+Line 2012 
 sub _get_next_token ($) {
            $self->{state} = DATA_STATE;
            $self->{s_kwd} = '';
            ## reconsume
-           return  ($self->{ct}); # end tag
+           ## Discard the token.
+           #return  ($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.
-           return  ($self->{ct}); # ATTLIST
+           ## Discard the token.
+           #return  ($self->{ct}); # ATTLIST
            redo A;
          } else {
            die "$0: $self->{ct}->{type}: Unknown token type";
-Line 1960 
 sub _get_next_token ($) {
+Line 2041 
 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 2099 
 sub _get_next_token ($) {
+Line 2180 
 sub _get_next_token ($) {
            $self->{state} = DATA_STATE;
            $self->{s_kwd} = '';
            ## reconsume
-           return  ($self->{ct}); # start tag
+           ## Discard the token.
+           #return  ($self->{ct}); # start tag
            redo A;
          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {
            $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed tag');
-Line 2115 
 sub _get_next_token ($) {
+Line 2199 
 sub _get_next_token ($) {
            $self->{state} = DATA_STATE;
            $self->{s_kwd} = '';
            ## reconsume
-           return  ($self->{ct}); # end tag
+           ## Discard the token.
+           #return  ($self->{ct}); # end tag
            redo A;
          } elsif ($self->{ct}->{type} == ATTLIST_TOKEN) {
            $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
            push @{$self->{ct}->{attrdefs}}, $self->{ca};
            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
            ## Reconsume.
-           return  ($self->{ct}); # ATTLIST
+           ## Discard the token.
+           #return  ($self->{ct}); # ATTLIST
            redo A;
          } else {
            die "$0: $self->{ct}->{type}: Unknown token type";
-Line 2132 
 sub _get_next_token ($) {
+Line 2222 
 sub _get_next_token ($) {
 x0022 => 1, # "
 x0027 => 1, # '
 x003D => 1, # =
+x003C => 1, # <
              }->{$self->{nc}}) {
            ## XML5: Not a parse error.
-Line 2141 
 sub _get_next_token ($) {
+Line 2232 
 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 2241 
 sub _get_next_token ($) {
+Line 2332 
 sub _get_next_token ($) {
          $self->{state} = DATA_STATE;
          $self->{s_kwd} = '';
          ## Reconsume.
-         return  ($self->{ct}); # start tag or end tag
+         ## Discard the token.
+         #return  ($self->{ct}); # start tag or end tag
          redo A;
        } else {
-Line 2308 
 sub _get_next_token ($) {
+Line 2402 
 sub _get_next_token ($) {
          $self->{state} = DATA_STATE;
          $self->{s_kwd} = '';
          ## Reconsume.
-         return  ($self->{ct}); # start tag or end tag
+         ## Discard the token.
+         #return  ($self->{ct}); # start tag or end tag
          redo A;
        } else {
-Line 2883 
 sub _get_next_token ($) {
+Line 2980 
 sub _get_next_token ($) {
          redo A;
        }
-     } elsif ($self->{state} == COMMENT_END_STATE) {
+     } elsif ($self->{state} == COMMENT_END_STATE or
+              $self->{state} == COMMENT_END_BANG_STATE) {
        ## XML5: "Comment end state" and "DOCTYPE comment end state".
+       ## (No comment end bang state.)
        if ($self->{nc} == 0x003E) { # >
          if ($self->{in_subset}) {
-Line 2911 
 sub _get_next_token ($) {
+Line 3010 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == 0x002D) { # -
+         if ($self->{state} == COMMENT_END_BANG_STATE) {
+           $self->{ct}->{data} .= '--!'; # comment
+           $self->{state} = COMMENT_END_DASH_STATE;
+         } else {
+           ## XML5: Not a parse error.
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'dash in comment',
+                           line => $self->{line_prev},
+                           column => $self->{column_prev});
+           $self->{ct}->{data} .= '-'; # comment
+           ## Stay in the state
+         }
-         ## XML5: Not a parse error.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
-         $self->{parse_error}->(level => $self->{level}->{must}, type => 'dash in comment',
+       $self->{line_prev} = $self->{line};
-                         line => $self->{line_prev},
+       $self->{column_prev} = $self->{column};
-                         column => $self->{column_prev});
+       $self->{column}++;
-         $self->{ct}->{data} .= '-'; # comment
+       $self->{nc}
-         ## Stay in the state
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{state} != COMMENT_END_BANG_STATE and
+                $is_space->{$self->{nc}}) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'comment end space'); # XXX error type
+         $self->{ct}->{data} .= '--' . chr ($self->{nc}); # comment
+         $self->{state} = COMMENT_END_SPACE_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{state} != COMMENT_END_BANG_STATE and
+                $self->{nc} == 0x0021) { # !
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'comment end bang'); # XXX error type
+         $self->{state} = COMMENT_END_BANG_STATE;
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 2940 
 sub _get_next_token ($) {
+Line 3080 
 sub _get_next_token ($) {
            $self->{state} = DATA_STATE;
            $self->{s_kwd} = '';
          }
-         ## reconsume
+         ## Reconsume.
          return  ($self->{ct}); # comment
          redo A;
        } else {
-         ## XML5: Not a parse error.
+         if ($self->{state} == COMMENT_END_BANG_STATE) {
-         $self->{parse_error}->(level => $self->{level}->{must}, type => 'dash in comment',
+           $self->{ct}->{data} .= '--!' . chr ($self->{nc}); # comment
-                         line => $self->{line_prev},
+         } else {
-                         column => $self->{column_prev});
+           $self->{ct}->{data} .= '--' . chr ($self->{nc}); # comment
-         $self->{ct}->{data} .= '--' . chr ($self->{nc}); # comment
+         }
          $self->{state} = COMMENT_STATE;
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
-Line 2966 
 sub _get_next_token ($) {
+Line 3106 
 sub _get_next_token ($) {
          redo A;
        }
+     } elsif ($self->{state} == COMMENT_END_SPACE_STATE) {
+       ## XML5: Not exist.
+       if ($self->{nc} == 0x003E) { # >
+         if ($self->{in_subset}) {
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # comment
+         redo A;
+       } elsif ($is_space->{$self->{nc}}) {
+         $self->{ct}->{data} .= chr ($self->{nc}); # comment
+         ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed comment');
+         if ($self->{in_subset}) {
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         } else {
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         }
+         ## Reconsume.
+         return  ($self->{ct}); # comment
+         redo A;
+       } else {
+         $self->{ct}->{data} .= chr ($self->{nc}); # comment
+         $self->{state} = COMMENT_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       }
      } elsif ($self->{state} == DOCTYPE_STATE) {
        if ($is_space->{$self->{nc}}) {
-Line 2982 
 sub _get_next_token ($) {
+Line 3197 
 sub _get_next_token ($) {
      }
          redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed DOCTYPE');
+         $self->{ct}->{quirks} = 1;
+         $self->{state} = DATA_STATE;
+         ## Reconsume.
+         return  ($self->{ct}); # DOCTYPE (quirks)
+         redo A;
        } else {
-         ## XML5: Unless EOF, swith to the bogus comment state.
+         ## XML5: Swith to the bogus comment state.
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'no space before DOCTYPE name');
          $self->{state} = BEFORE_DOCTYPE_NAME_STATE;
          ## reconsume
-Line 3029 
 sub _get_next_token ($) {
+Line 3254 
 sub _get_next_token ($) {
          return  ($self->{ct}); # DOCTYPE (quirks)
          redo A;
+       } elsif (0x0041 <= $self->{nc} and $self->{nc} <= 0x005A) { # A..Z
+         $self->{ct}->{name} # DOCTYPE
+             = chr ($self->{nc} + ($self->{is_xml} ? 0 : 0x0020));
+         delete $self->{ct}->{quirks};
+         $self->{state} = DOCTYPE_NAME_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
        } elsif ($self->{nc} == -1) {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'no DOCTYPE name');
-Line 3115 
 sub _get_next_token ($) {
+Line 3358 
 sub _get_next_token ($) {
          return  ($self->{ct}); # DOCTYPE
          redo A;
+       } elsif (0x0041 <= $self->{nc} and $self->{nc} <= 0x005A) { # A..Z
+         $self->{ct}->{name} # DOCTYPE
+             .= chr ($self->{nc} + ($self->{is_xml} ? 0 : 0x0020));
+         delete $self->{ct}->{quirks};
+         ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
        } elsif ($self->{nc} == -1) {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed DOCTYPE');
-Line 3146 
 sub _get_next_token ($) {
+Line 3407 
 sub _get_next_token ($) {
          redo A;
        } else {
-         $self->{ct}->{name}
+         $self->{ct}->{name} .= chr ($self->{nc}); # DOCTYPE
-           .= chr ($self->{nc}); # DOCTYPE
+         ## Stay in the state.
-         ## Stay in the state
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 3182 
 sub _get_next_token ($) {
+Line 3442 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         } else {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'no md def'); ## TODO: type
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
-         $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 3196 
 sub _get_next_token ($) {
+Line 3463 
 sub _get_next_token ($) {
        $self->{set_nc}->($self);
      }
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         return  ($self->{ct}); # DOCTYPE
          redo A;
        } elsif ($self->{nc} == -1) {
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed DOCTYPE');
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
-         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed DOCTYPE');
+         ## Reconsume.
-         $self->{state} = DATA_STATE;
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{s_kwd} = '';
-         ## reconsume
-         $self->{ct}->{quirks} = 1;
-         return  ($self->{ct}); # DOCTYPE
          redo A;
        } elsif ($self->{nc} == 0x0050 or # P
                 $self->{nc} == 0x0070) { # p
-Line 3245 
 sub _get_next_token ($) {
+Line 3515 
 sub _get_next_token ($) {
      }
          redo A;
-       } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [
+       } elsif ($self->{nc} == 0x0022 and # "
+                ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN or
+                 $self->{ct}->{type} == PARAMETER_ENTITY_TOKEN)) {
+         $self->{state} = DOCTYPE_ENTITY_VALUE_DOUBLE_QUOTED_STATE;
+         $self->{ct}->{value} = ''; # ENTITY
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x0027 and # '
+                ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN or
+                 $self->{ct}->{type} == PARAMETER_ENTITY_TOKEN)) {
+         $self->{state} = DOCTYPE_ENTITY_VALUE_SINGLE_QUOTED_STATE;
+         $self->{ct}->{value} = ''; # ENTITY
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{is_xml} and
+                $self->{ct}->{type} == DOCTYPE_TOKEN and
+                $self->{nc} == 0x005B) { # [
          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
          $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
-Line 3264 
 sub _get_next_token ($) {
+Line 3572 
 sub _get_next_token ($) {
          return  ($self->{ct}); # DOCTYPE
          redo A;
        } else {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after DOCTYPE name'); ## TODO: type
-         $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after DOCTYPE name');
-         $self->{ct}->{quirks} = 1;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           $self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           $self->{state} = BOGUS_MD_STATE;
+         }
-         $self->{state} = BOGUS_DOCTYPE_STATE;
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 3340 
 sub _get_next_token ($) {
+Line 3654 
 sub _get_next_token ($) {
          redo A;
        } else {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after DOCTYPE name', ## TODO: type
-         $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after DOCTYPE name',
                          line => $self->{line_prev},
                          column => $self->{column_prev} + 1 - length $self->{kwd});
-         $self->{ct}->{quirks} = 1;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{state} = BOGUS_DOCTYPE_STATE;
+           $self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           $self->{state} = BOGUS_MD_STATE;
+         }
          ## Reconsume.
          redo A;
        }
-Line 3408 
 sub _get_next_token ($) {
+Line 3726 
 sub _get_next_token ($) {
          redo A;
        } else {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after DOCTYPE name', ## TODO: type
-         $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after DOCTYPE name',
                          line => $self->{line_prev},
                          column => $self->{column_prev} + 1 - length $self->{kwd});
-         $self->{ct}->{quirks} = 1;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{state} = BOGUS_DOCTYPE_STATE;
+           $self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           $self->{state} = BOGUS_MD_STATE;
+         }
          ## Reconsume.
          redo A;
        }
-Line 3467 
 sub _get_next_token ($) {
+Line 3789 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} eq 0x003E) { # >
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'no PUBLIC literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 3483 
 sub _get_next_token ($) {
+Line 3812 
 sub _get_next_token ($) {
        $self->{set_nc}->($self);
      }
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{ct}->{quirks} = 1;
-         return  ($self->{ct}); # DOCTYPE
          redo A;
        } elsif ($self->{nc} == -1) {
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed DOCTYPE');
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
-         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed DOCTYPE');
-         $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
          ## reconsume
-         $self->{ct}->{quirks} = 1;
          return  ($self->{ct}); # DOCTYPE
          redo A;
-       } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [
+       } elsif ($self->{is_xml} and
+                $self->{ct}->{type} == DOCTYPE_TOKEN and
+                $self->{nc} == 0x005B) { # [
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'no PUBLIC literal');
          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
-Line 3520 
 sub _get_next_token ($) {
+Line 3852 
 sub _get_next_token ($) {
          return  ($self->{ct}); # DOCTYPE
          redo A;
        } else {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after PUBLIC');
-         $self->{ct}->{quirks} = 1;
-         $self->{state} = BOGUS_DOCTYPE_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           $self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           $self->{state} = BOGUS_MD_STATE;
+         }
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 3555 
 sub _get_next_token ($) {
+Line 3893 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed PUBLIC literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 3571 
 sub _get_next_token ($) {
+Line 3916 
 sub _get_next_token ($) {
        $self->{set_nc}->($self);
      }
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{ct}->{quirks} = 1;
-         return  ($self->{ct}); # DOCTYPE
          redo A;
        } elsif ($self->{nc} == -1) {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed PUBLIC literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
-         ## reconsume
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
-         $self->{ct}->{quirks} = 1;
+           $self->{ct}->{quirks} = 1;
+         } else {
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
+         ## Reconsume.
          return  ($self->{ct}); # DOCTYPE
          redo A;
        } else {
-         $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 3626 
 sub _get_next_token ($) {
+Line 3971 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed PUBLIC literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 3642 
 sub _get_next_token ($) {
+Line 3994 
 sub _get_next_token ($) {
        $self->{set_nc}->($self);
      }
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{ct}->{quirks} = 1;
-         return  ($self->{ct}); # DOCTYPE
          redo A;
        } elsif ($self->{nc} == -1) {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed PUBLIC literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
          ## reconsume
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{ct}->{quirks} = 1;
-         return  ($self->{ct}); # DOCTYPE
          redo A;
        } else {
-         $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 3698 
 sub _get_next_token ($) {
+Line 4050 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == 0x0022) { # "
-         $self->{ct}->{sysid} = ''; # DOCTYPE
+         $self->{ct}->{sysid} = ''; # DOCTYPE/ENTITY/NOTATION
          $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
-Line 3714 
 sub _get_next_token ($) {
+Line 4066 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == 0x0027) { # '
-         $self->{ct}->{sysid} = ''; # DOCTYPE
+         $self->{ct}->{sysid} = ''; # DOCTYPE/ENTITY/NOTATION
          $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
-Line 3729 
 sub _get_next_token ($) {
+Line 4081 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
-         if ($self->{is_xml}) {
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           if ($self->{is_xml}) {
-           $self->{parse_error}->(level => $self->{level}->{must}, type => 'no SYSTEM literal');
+             $self->{parse_error}->(level => $self->{level}->{must}, type => 'no SYSTEM literal');
+           } else {
+           }
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
          } else {
+           if ($self->{ct}->{type} == NOTATION_TOKEN) {
+           } else {
+             $self->{parse_error}->(level => $self->{level}->{must}, type => 'no SYSTEM literal');
+           }
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
          }
-         $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 3748 
 sub _get_next_token ($) {
+Line 4111 
 sub _get_next_token ($) {
        $self->{set_nc}->($self);
      }
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         return  ($self->{ct}); # DOCTYPE
          redo A;
        } elsif ($self->{nc} == -1) {
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed DOCTYPE');
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
-         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed DOCTYPE');
-         $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
          ## reconsume
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{ct}->{quirks} = 1;
-         return  ($self->{ct}); # DOCTYPE
          redo A;
-       } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [
+       } elsif ($self->{is_xml} and
+                $self->{ct}->{type} == DOCTYPE_TOKEN and
+                $self->{nc} == 0x005B) { # [
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'no SYSTEM literal');
          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
-Line 3784 
 sub _get_next_token ($) {
+Line 4151 
 sub _get_next_token ($) {
          return  ($self->{ct}); # DOCTYPE
          redo A;
        } else {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after PUBLIC literal');
-         $self->{ct}->{quirks} = 1;
-         $self->{state} = BOGUS_DOCTYPE_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           $self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           $self->{state} = BOGUS_MD_STATE;
+         }
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 3851 
 sub _get_next_token ($) {
+Line 4224 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'no SYSTEM literal');
-         $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 3867 
 sub _get_next_token ($) {
+Line 4237 
 sub _get_next_token ($) {
      }
-         $self->{ct}->{quirks} = 1;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         return  ($self->{ct}); # DOCTYPE
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
          redo A;
        } elsif ($self->{nc} == -1) {
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed DOCTYPE');
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
-         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed DOCTYPE');
-         $self->{state} = DATA_STATE;
-         $self->{s_kwd} = '';
          ## reconsume
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{ct}->{quirks} = 1;
-         return  ($self->{ct}); # DOCTYPE
          redo A;
-       } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [
+       } elsif ($self->{is_xml} and
+                $self->{ct}->{type} == DOCTYPE_TOKEN and
+                $self->{nc} == 0x005B) { # [
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'no SYSTEM literal');
-Line 3904 
 sub _get_next_token ($) {
+Line 4288 
 sub _get_next_token ($) {
          return  ($self->{ct}); # DOCTYPE
          redo A;
        } else {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after SYSTEM');
-         $self->{ct}->{quirks} = 1;
-         $self->{state} = BOGUS_DOCTYPE_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           $self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           $self->{state} = BOGUS_MD_STATE;
+         }
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 3939 
 sub _get_next_token ($) {
+Line 4329 
 sub _get_next_token ($) {
          redo A;
        } elsif (not $self->{is_xml} and $self->{nc} == 0x003E) { # >
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed SYSTEM literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 3955 
 sub _get_next_token ($) {
+Line 4352 
 sub _get_next_token ($) {
        $self->{set_nc}->($self);
      }
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{ct}->{quirks} = 1;
-         return  ($self->{ct}); # DOCTYPE
          redo A;
        } elsif ($self->{nc} == -1) {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed SYSTEM literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
+         } else {
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
          ## reconsume
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
-         $self->{ct}->{quirks} = 1;
-         return  ($self->{ct}); # DOCTYPE
          redo A;
        } else {
-         $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 4032 
 sub _get_next_token ($) {
+Line 4429 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == -1) {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed SYSTEM literal');
-         $self->{state} = DATA_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{s_kwd} = '';
-         ## reconsume
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
-         $self->{ct}->{quirks} = 1;
+           $self->{ct}->{quirks} = 1;
-         return  ($self->{ct}); # DOCTYPE
+         } else {
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
+         ## reconsume
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
          redo A;
        } else {
-         $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 4066 
 sub _get_next_token ($) {
+Line 4466 
 sub _get_next_token ($) {
        }
      } elsif ($self->{state} == AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {
        if ($is_space->{$self->{nc}}) {
+         if ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN) {
-         ## Stay in the state
+           $self->{state} = BEFORE_NDATA_STATE;
+         } else {
+           ## Stay in the state
+         }
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 4081 
 sub _get_next_token ($) {
+Line 4486 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{nc} == 0x003E) { # >
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           $self->{state} = DATA_STATE;
+           $self->{s_kwd} = '';
+         } else {
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
-         $self->{state} = DATA_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
-         $self->{s_kwd} = '';
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
+         redo A;
+       } elsif ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN and
+                ($self->{nc} == 0x004E or # N
+                 $self->{nc} == 0x006E)) { # n
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'no space before NDATA'); ## TODO: type
+         $self->{state} = NDATA_STATE;
+         $self->{kwd} = chr $self->{nc};
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 4095 
 sub _get_next_token ($) {
+Line 4526 
 sub _get_next_token ($) {
        $self->{set_nc}->($self);
      }
-         return  ($self->{ct}); # DOCTYPE
          redo A;
        } elsif ($self->{nc} == -1) {
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
-         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed DOCTYPE');
-         $self->{state} = DATA_STATE;
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed DOCTYPE');
-         $self->{s_kwd} = '';
+           $self->{state} = DATA_STATE;
-         ## reconsume
+           $self->{s_kwd} = '';
+           $self->{ct}->{quirks} = 1;
-         $self->{ct}->{quirks} = 1;
+         } else {
-         return  ($self->{ct}); # DOCTYPE
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+           $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         }
+         ## reconsume
+         return  ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
          redo A;
-       } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [
+       } elsif ($self->{is_xml} and
+                $self->{ct}->{type} == DOCTYPE_TOKEN and
+                $self->{nc} == 0x005B) { # [
          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
          $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
-Line 4129 
 sub _get_next_token ($) {
+Line 4564 
 sub _get_next_token ($) {
          return  ($self->{ct}); # DOCTYPE
          redo A;
        } else {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after SYSTEM literal');
-         #$self->{ct}->{quirks} = 1;
-         $self->{state} = BOGUS_DOCTYPE_STATE;
+         if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
+           #$self->{ct}->{quirks} = 1;
+           $self->{state} = BOGUS_DOCTYPE_STATE;
+         } else {
+           $self->{state} = BOGUS_MD_STATE;
+         }
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       }
+     } elsif ($self->{state} == BEFORE_NDATA_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ENTITY
+         redo A;
+       } elsif ($self->{nc} == 0x004E or # N
+                $self->{nc} == 0x006E) { # n
+         $self->{state} = NDATA_STATE;
+         $self->{kwd} = chr $self->{nc};
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         ## reconsume
+         return  ($self->{ct}); # ENTITY
+         redo A;
+       } else {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after SYSTEM literal');
+         $self->{state} = BOGUS_MD_STATE;
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 4357 
 sub _get_next_token ($) {
+Line 4871 
 sub _get_next_token ($) {
 x003C => 1, 0x0026 => 1, -1 => 1, # <, &
              $self->{entity_add} => 1,
            }->{$self->{nc}}) {
+         if ($self->{is_xml}) {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'bare ero',
+                           line => $self->{line_prev},
+                           column => $self->{column_prev}
+                               + ($self->{nc} == -1 ? 1 : 0));
+         } else {
+           ## No error
+         }
          ## Don't consume
-         ## No error
          ## Return nothing.
          #
        } elsif ($self->{nc} == 0x0023) { # #
-Line 4378 
 sub _get_next_token ($) {
+Line 4900 
 sub _get_next_token ($) {
      }
          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
-Line 4432 
 sub _get_next_token ($) {
+Line 4955 
 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
+         $self->{state} = HEXREF_X_STATE;
+         $self->{kwd} .= chr $self->{nc};
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x0058) { # X
+         if ($self->{is_xml}) {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'uppercase hcro'); ## TODO: type
+         }
          $self->{state} = HEXREF_X_STATE;
          $self->{kwd} .= chr $self->{nc};
-Line 4539 
 sub _get_next_token ($) {
+Line 5080 
 sub _get_next_token ($) {
        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)) {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'invalid character reference',
                          text => (sprintf 'U+%04X', $code),
-Line 4692 
 sub _get_next_token ($) {
+Line 5235 
 sub _get_next_token ($) {
        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)) {
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'invalid character reference',
                          text => (sprintf 'U+%04X', $code),
-Line 4726 
 sub _get_next_token ($) {
+Line 5271 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == ENTITY_NAME_STATE) {
-       if (length $self->{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->{kwd} .= chr $self->{nc};
-         if (defined $EntityChar->{$self->{kwd}}) {
+         if (defined $EntityChar->{$self->{kwd}} or
+             $self->{ge}->{$self->{kwd}}) {
            if ($self->{nc} == 0x003B) { # ;
+             if (defined $self->{ge}->{$self->{kwd}}) {
-             $self->{entity__value} = $EntityChar->{$self->{kwd}};
+               if ($self->{ge}->{$self->{kwd}}->{only_text}) {
+                 $self->{entity__value} = $self->{ge}->{$self->{kwd}}->{value};
+               } else {
+                 if (defined $self->{ge}->{$self->{kwd}}->{notation}) {
+                   $self->{parse_error}->(level => $self->{level}->{must}, type => 'unparsed entity', ## TODO: type
+                                   value => $self->{kwd});
+                 } else {
+                 }
+                 $self->{entity__value} = '&' . $self->{kwd}; ## TODO: expand
+               }
+             } else {
+               if ($self->{is_xml}) {
+                 $self->{parse_error}->(level => $self->{level}->{must}, 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 {
+               }
+               $self->{entity__value} = $EntityChar->{$self->{kwd}};
+             }
              $self->{entity__match} = 1;
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
-Line 5136 
 sub _get_next_token ($) {
+Line 5716 
 sub _get_next_token ($) {
          ## XML5: Not defined yet.
          ## TODO:
+         if (not $self->{stop_processing} and
+             not $self->{document}->xml_standalone) {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'stop processing', ## TODO: type
+                           level => $self->{level}->{info});
+           $self->{stop_processing} = 1;
+         }
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 5358 
 sub _get_next_token ($) {
+Line 5946 
 sub _get_next_token ($) {
      }
          redo A;
-       } elsif ($self->{nc} == 0x0045) { # E
+       } elsif ($self->{nc} == 0x0045 or # E
+                $self->{nc} == 0x0065) { # e
          $self->{state} = MD_E_STATE;
          $self->{kwd} = chr $self->{nc};
-Line 5373 
 sub _get_next_token ($) {
+Line 5962 
 sub _get_next_token ($) {
      }
          redo A;
-       } elsif ($self->{nc} == 0x0041) { # A
+       } elsif ($self->{nc} == 0x0041 or # A
+                $self->{nc} == 0x0061) { # a
          $self->{state} = MD_ATTLIST_STATE;
          $self->{kwd} = chr $self->{nc};
-Line 5388 
 sub _get_next_token ($) {
+Line 5978 
 sub _get_next_token ($) {
      }
          redo A;
-       } elsif ($self->{nc} == 0x004E) { # N
+       } elsif ($self->{nc} == 0x004E or # N
+                $self->{nc} == 0x006E) { # n
          $self->{state} = MD_NOTATION_STATE;
          $self->{kwd} = chr $self->{nc};
-Line 5416 
 sub _get_next_token ($) {
+Line 6007 
 sub _get_next_token ($) {
        $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded.
        redo A;
      } elsif ($self->{state} == MD_E_STATE) {
-       if ($self->{nc} == 0x004E) { # N
+       if ($self->{nc} == 0x004E or # N
+           $self->{nc} == 0x006E) { # n
          $self->{state} = MD_ENTITY_STATE;
          $self->{kwd} .= chr $self->{nc};
-Line 5431 
 sub _get_next_token ($) {
+Line 6023 
 sub _get_next_token ($) {
      }
          redo A;
-       } elsif ($self->{nc} == 0x004C) { # L
+       } elsif ($self->{nc} == 0x004C or # L
+                $self->{nc} == 0x006C) { # l
          ## XML5: <!ELEMENT> not supported.
          $self->{state} = MD_ELEMENT_STATE;
          $self->{kwd} .= chr $self->{nc};
-Line 5459 
 sub _get_next_token ($) {
+Line 6052 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == MD_ENTITY_STATE) {
-       if ($self->{nc} == {
+       if ($self->{nc} == [
-             'EN' => 0x0054, # T
+             undef,
-             'ENT' => 0x0049, # I
+             undef,
-             'ENTI' => 0x0054, # T
+x0054, # T
-           }->{$self->{kwd}}) {
+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};
-Line 5478 
 sub _get_next_token ($) {
+Line 6080 
 sub _get_next_token ($) {
      }
          redo A;
-       } elsif ($self->{kwd} eq 'ENTIT' and
+       } elsif ((length $self->{kwd}) == 5 and
-                $self->{nc} == 0x0059) { # Y
+                ($self->{nc} == 0x0059 or # Y
-         $self->{ct} = {type => GENERAL_ENTITY_TOKEN, name => '', text => '',
+                 $self->{nc} == 0x0079)) { # y
+         if ($self->{kwd} ne 'ENTIT' or $self->{nc} == 0x0079) {
+           $self->{parse_error}->(level => $self->{level}->{must}, 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;
-Line 5508 
 sub _get_next_token ($) {
+Line 6117 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == MD_ELEMENT_STATE) {
-       if ($self->{nc} == {
+       if ($self->{nc} == [
-             'EL' => 0x0045, # E
+            undef,
-             'ELE' => 0x004D, # M
+            undef,
-             'ELEM' => 0x0045, # E
+x0045, # E
-             'ELEME' => 0x004E, # N
+x004D, # M
-           }->{$self->{kwd}}) {
+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};
-Line 5528 
 sub _get_next_token ($) {
+Line 6147 
 sub _get_next_token ($) {
      }
          redo A;
-       } elsif ($self->{kwd} eq 'ELEMEN' and
+       } elsif ((length $self->{kwd}) == 6 and
-                $self->{nc} == 0x0054) { # T
+                ($self->{nc} == 0x0054 or # T
+                 $self->{nc} == 0x0074)) { # t
+         if ($self->{kwd} ne 'ELEMEN' or $self->{nc} == 0x0074) {
+           $self->{parse_error}->(level => $self->{level}->{must}, 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} - 6};
+                        column => $self->{column_prev} - 7};
          $self->{state} = DOCTYPE_MD_STATE;
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
-Line 5558 
 sub _get_next_token ($) {
+Line 6184 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == MD_ATTLIST_STATE) {
-       if ($self->{nc} == {
+       if ($self->{nc} == [
-             'A' => 0x0054, # T
+            undef,
-             'AT' => 0x0054, # T
+x0054, # T
-             'ATT' => 0x004C, # L
+x0054, # T
-             'ATTL' => 0x0049, # I
+x004C, # L
-             'ATTLI' => 0x0053, # S
+x0049, # I
-           }->{$self->{kwd}}) {
+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};
-Line 5579 
 sub _get_next_token ($) {
+Line 6214 
 sub _get_next_token ($) {
      }
          redo A;
-       } elsif ($self->{kwd} eq 'ATTLIS' and
+       } elsif ((length $self->{kwd}) == 6 and
-                $self->{nc} == 0x0054) { # T
+                ($self->{nc} == 0x0054 or # T
+                 $self->{nc} == 0x0074)) { # t
+         if ($self->{kwd} ne 'ATTLIS' or $self->{nc} == 0x0074) {
+           $self->{parse_error}->(level => $self->{level}->{must}, 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} - 6};
+                        column => $self->{column_prev} - 7};
          $self->{state} = DOCTYPE_MD_STATE;
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
-Line 5610 
 sub _get_next_token ($) {
+Line 6252 
 sub _get_next_token ($) {
          redo A;
        }
      } elsif ($self->{state} == MD_NOTATION_STATE) {
-       if ($self->{nc} == {
+       if ($self->{nc} == [
-             'N' => 0x004F, # O
+            undef,
-             'NO' => 0x0054, # T
+x004F, # O
-             'NOT' => 0x0041, # A
+x0054, # T
-             'NOTA' => 0x0054, # T
+x0041, # A
-             'NOTAT' => 0x0049, # I
+x0054, # T
-             'NOTATI' => 0x004F, # O
+x0049, # I
-           }->{$self->{kwd}}) {
+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};
-Line 5632 
 sub _get_next_token ($) {
+Line 6284 
 sub _get_next_token ($) {
      }
          redo A;
-       } elsif ($self->{kwd} eq 'NOTATIO' and
+       } elsif ((length $self->{kwd}) == 7 and
-                $self->{nc} == 0x004E) { # N
+                ($self->{nc} == 0x004E or # N
+                 $self->{nc} == 0x006E)) { # n
+         if ($self->{kwd} ne 'NOTATIO' or $self->{nc} == 0x006E) {
+           $self->{parse_error}->(level => $self->{level}->{must}, 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} - 6};
+                        column => $self->{column_prev} - 8};
          $self->{state} = DOCTYPE_MD_STATE;
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
-Line 5845 
 sub _get_next_token ($) {
+Line 6504 
 sub _get_next_token ($) {
        ## XML5: "DOCTYPE ENTITY name state" and "DOCTYPE ATTLIST name state".
        if ($is_space->{$self->{nc}}) {
-         ## TODO:
+         if ($self->{ct}->{type} == ATTLIST_TOKEN) {
-         $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;
+           $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;
+         }
      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
        $self->{line_prev} = $self->{line};
-Line 5863 
 sub _get_next_token ($) {
+Line 6527 
 sub _get_next_token ($) {
          if ($self->{ct}->{type} == ATTLIST_TOKEN) {
            #
          } else {
-           $self->{parse_error}->(level => $self->{level}->{must}, type => 'no md body'); ## TODO: type
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'no md def'); ## TODO: type
          }
          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
-Line 6853 
 sub _get_next_token ($) {
+Line 7517 
 sub _get_next_token ($) {
        if ($is_space->{$self->{nc}}) {
          ## XML5: No parse error.
          $self->{parse_error}->(level => $self->{level}->{must}, type => 'no default type'); ## TODO: type
-         $self->{state} = BOGUS_COMMENT_STATE;
+         $self->{state} = BOGUS_MD_STATE;
-         $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded
          ## Reconsume.
          redo A;
        } elsif ($self->{nc} == 0x0022) { # "
-Line 7141 
 sub _get_next_token ($) {
+Line 7804 
 sub _get_next_token ($) {
          $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}]) {
+         ## Stay in the state.
+         $self->{kwd} .= chr $self->{nc};
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         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
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'lowercase keyword', ## TODO: type
+                           text => 'NDATA',
+                           line => $self->{line_prev},
+                           column => $self->{column_prev} - 4);
+         } else {
+         }
+         $self->{state} = AFTER_NDATA_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } else {
+         $self->{parse_error}->(level => $self->{level}->{must}, 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} == AFTER_NDATA_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = BEFORE_NOTATION_NAME_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'no notation name'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ENTITY
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ENTITY
+         redo A;
+       } else {
+         $self->{parse_error}->(level => $self->{level}->{must}, 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.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'no notation name'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ENTITY
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ENTITY
+         redo A;
+       } else {
+         $self->{ct}->{notation} = chr $self->{nc}; # ENTITY
+         $self->{state} = NOTATION_NAME_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       }
+     } elsif ($self->{state} == NOTATION_NAME_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = AFTER_MD_DEF_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ENTITY
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ENTITY
+         redo A;
+       } else {
+         $self->{ct}->{notation} .= chr $self->{nc}; # ENTITY
+         ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_ENTITY_VALUE_DOUBLE_QUOTED_STATE) {
+       if ($self->{nc} == 0x0022) { # "
+         $self->{state} = AFTER_MD_DEF_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x0026) { # &
+         $self->{prev_state} = $self->{state};
+         $self->{state} = ENTITY_VALUE_ENTITY_STATE;
+         $self->{entity_add} = 0x0022; # "
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+ ## TODO: %
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed entity value'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         ## Reconsume.
+         return  ($self->{ct}); # ENTITY
+         redo A;
+       } else {
+         $self->{ct}->{value} .= chr $self->{nc}; # ENTITY
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       }
+     } elsif ($self->{state} == DOCTYPE_ENTITY_VALUE_SINGLE_QUOTED_STATE) {
+       if ($self->{nc} == 0x0027) { # '
+         $self->{state} = AFTER_MD_DEF_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x0026) { # &
+         $self->{prev_state} = $self->{state};
+         $self->{state} = ENTITY_VALUE_ENTITY_STATE;
+         $self->{entity_add} = 0x0027; # '
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+ ## TODO: %
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed entity value'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         ## Reconsume.
+         return  ($self->{ct}); # ENTITY
+         redo A;
+       } else {
+         $self->{ct}->{value} .= chr $self->{nc}; # ENTITY
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         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}}) {
+         $self->{parse_error}->(level => $self->{level}->{must}, 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} = '#';
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         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;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x0028) { # (
+         $self->{state} = AFTER_CM_GROUP_OPEN_STATE;
+         $self->{ct}->{content} = ['('];
+         $self->{group_depth} = 1;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'no md def'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ELEMENT
+         redo A;
+       } else {
+         $self->{ct}->{content} = [chr $self->{nc}];
+         $self->{state} = CONTENT_KEYWORD_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       }
+     } elsif ($self->{state} == CONTENT_KEYWORD_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = AFTER_MD_DEF_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ELEMENT
+         redo A;
+       } else {
+         $self->{ct}->{content}->[-1] .= chr $self->{nc}; # ELEMENT
+         ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       }
+     } elsif ($self->{state} == AFTER_CM_GROUP_OPEN_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x0028) { # (
+         $self->{group_depth}++;
+         push @{$self->{ct}->{content}}, chr $self->{nc};
+         ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x007C or # |
+                $self->{nc} == 0x002C) { # ,
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'empty element name'); ## TODO: type
+         ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x0029) { # )
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'empty element name'); ## TODO: type
+         push @{$self->{ct}->{content}}, chr $self->{nc};
+         $self->{group_depth}--;
+         $self->{state} = AFTER_CM_GROUP_CLOSE_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed cm group'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ELEMENT
+         redo A;
+       } else {
+         push @{$self->{ct}->{content}}, chr $self->{nc};
+         $self->{state} = CM_ELEMENT_NAME_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       }
+     } elsif ($self->{state} == CM_ELEMENT_NAME_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         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;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x007C or # |
+                $self->{nc} == 0x002C) { # ,
+         push @{$self->{ct}->{content}}, $self->{nc} == 0x007C ? ' | ' : ', ';
+         $self->{state} = AFTER_CM_GROUP_OPEN_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x0029) { # )
+         $self->{group_depth}--;
+         push @{$self->{ct}->{content}}, chr $self->{nc};
+         $self->{state} = AFTER_CM_GROUP_CLOSE_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed cm group'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ELEMENT
+         redo A;
+       } else {
+         $self->{ct}->{content}->[-1] .= chr $self->{nc};
+         ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       }
+     } elsif ($self->{state} == AFTER_CM_ELEMENT_NAME_STATE) {
+       if ($is_space->{$self->{nc}}) {
+         ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x007C or # |
+                $self->{nc} == 0x002C) { # ,
+         push @{$self->{ct}->{content}}, $self->{nc} == 0x007C ? ' | ' : ', ';
+         $self->{state} = AFTER_CM_GROUP_OPEN_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x0029) { # )
+         $self->{group_depth}--;
+         push @{$self->{ct}->{content}}, chr $self->{nc};
+         $self->{state} = AFTER_CM_GROUP_CLOSE_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed cm group'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ELEMENT
+         redo A;
+       } else {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'after element name'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = BOGUS_MD_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         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;
+         }
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         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;
+         }
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x0029) { # )
+         if ($self->{group_depth}) {
+           $self->{group_depth}--;
+           push @{$self->{ct}->{content}}, chr $self->{nc};
+           ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+           redo A;
+         } else {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'string after md def'); ## TODO: type
+           $self->{state} = BOGUS_MD_STATE;
+           ## Reconsume.
+           redo A;
+         }
+       } elsif ($self->{nc} == 0x003E) { # >
+         if ($self->{group_depth}) {
+           $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed cm group'); ## TODO: type
+           push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         }
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+         push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ELEMENT
+         redo A;
+       } else {
+         if ($self->{group_depth}) {
+           $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
+         } else {
+           $self->{parse_error}->(level => $self->{level}->{must}, 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.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       } elsif ($self->{nc} == 0x003E) { # >
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ENTITY/ELEMENT
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{parse_error}->(level => $self->{level}->{must}, type => 'unclosed md'); ## TODO: type
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ENTITY/ELEMENT
+         redo A;
+       } else {
+         $self->{parse_error}->(level => $self->{level}->{must}, 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;
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         return  ($self->{ct}); # ATTLIST/ENTITY/NOTATION
+         redo A;
+       } elsif ($self->{nc} == -1) {
+         $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
+         ## Reconsume.
+         return  ($self->{ct}); # ATTLIST/ENTITY/NOTATION
+         redo A;
+       } else {
+         ## Stay in the state.
+     if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
+       $self->{line_prev} = $self->{line};
+       $self->{column_prev} = $self->{column};
+       $self->{column}++;
+       $self->{nc}
+           = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
+     } else {
+       $self->{set_nc}->($self);
+     }
+         redo A;
+       }
      } else {
        die "$0: $self->{state}: Unknown state";
      }

 Legend:



Removed from v.1.15
 


changed lines


 
Added in v.1.34
 Legend:



Removed from v.1.15
 


changed lines


 
Added in v.1.34
-Removed from v.1.15
+Added in v.1.34

admin@suikawiki.org	ViewVC Help
Powered by ViewVC 1.1.24