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

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

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

revision 1.11 by wakaba, Wed Oct 15 10:50:38 2008 UTC revision 1.30 by wakaba, Sun Aug 16 05:24:47 2009 UTC
# Line 15  BEGIN { Line 15  BEGIN {
15      CHARACTER_TOKEN      CHARACTER_TOKEN
16      PI_TOKEN      PI_TOKEN
17      ABORT_TOKEN      ABORT_TOKEN
18        END_OF_DOCTYPE_TOKEN
19        ATTLIST_TOKEN
20        ELEMENT_TOKEN
21        GENERAL_ENTITY_TOKEN
22        PARAMETER_ENTITY_TOKEN
23        NOTATION_TOKEN
24    );    );
25        
26    our %EXPORT_TAGS = (    our %EXPORT_TAGS = (
# Line 27  BEGIN { Line 33  BEGIN {
33        CHARACTER_TOKEN        CHARACTER_TOKEN
34        PI_TOKEN        PI_TOKEN
35        ABORT_TOKEN        ABORT_TOKEN
36          END_OF_DOCTYPE_TOKEN
37          ATTLIST_TOKEN
38          ELEMENT_TOKEN
39          GENERAL_ENTITY_TOKEN
40          PARAMETER_ENTITY_TOKEN
41          NOTATION_TOKEN
42      )],      )],
43    );    );
44  }  }
45    
46    ## NOTE: Differences from the XML5 draft are marked as "XML5:".
47    
48  ## Token types  ## Token types
49    
50  sub DOCTYPE_TOKEN () { 1 }  sub DOCTYPE_TOKEN () { 1 } ## XML5: No DOCTYPE token.
51  sub COMMENT_TOKEN () { 2 }  sub COMMENT_TOKEN () { 2 }
52  sub START_TAG_TOKEN () { 3 }  sub START_TAG_TOKEN () { 3 }
53  sub END_TAG_TOKEN () { 4 }  sub END_TAG_TOKEN () { 4 }
54  sub END_OF_FILE_TOKEN () { 5 }  sub END_OF_FILE_TOKEN () { 5 }
55  sub CHARACTER_TOKEN () { 6 }  sub CHARACTER_TOKEN () { 6 }
56  sub PI_TOKEN () { 7 } # XML5  sub PI_TOKEN () { 7 } ## NOTE: XML only.
57  sub ABORT_TOKEN () { 8 } # Not a token actually  sub ABORT_TOKEN () { 8 } ## NOTE: For internal processing.
58    sub END_OF_DOCTYPE_TOKEN () { 9 } ## NOTE: XML only.
59    sub ATTLIST_TOKEN () { 10 } ## NOTE: XML only.
60    sub ELEMENT_TOKEN () { 11 } ## NOTE: XML only.
61    sub GENERAL_ENTITY_TOKEN () { 12 } ## NOTE: XML only.
62    sub PARAMETER_ENTITY_TOKEN () { 13 } ## NOTE: XML only.
63    sub NOTATION_TOKEN () { 14 } ## NOTE: XML only.
64    
65    ## XML5: XML5 has "empty tag token".  In this implementation, it is
66    ## represented as a start tag token with $self->{self_closing} flag
67    ## set to true.
68    
69    ## XML5: XML5 has "short end tag token".  In this implementation, it
70    ## is represented as an end tag token with $token->{tag_name} flag set
71    ## to an empty string.
72    
73  package Whatpm::HTML;  package Whatpm::HTML;
74    
# Line 114  sub HEXREF_HEX_STATE () { 48 } Line 142  sub HEXREF_HEX_STATE () { 48 }
142  sub ENTITY_NAME_STATE () { 49 }  sub ENTITY_NAME_STATE () { 49 }
143  sub PCDATA_STATE () { 50 } # "data state" in the spec  sub PCDATA_STATE () { 50 } # "data state" in the spec
144    
145  ## XML states  ## XML-only states
146  sub PI_STATE () { 51 }  sub PI_STATE () { 51 }
147  sub PI_TARGET_STATE () { 52 }  sub PI_TARGET_STATE () { 52 }
148  sub PI_TARGET_AFTER_STATE () { 53 }  sub PI_TARGET_AFTER_STATE () { 53 }
149  sub PI_DATA_STATE () { 54 }  sub PI_DATA_STATE () { 54 }
150  sub PI_AFTER_STATE () { 55 }  sub PI_AFTER_STATE () { 55 }
151  sub PI_DATA_AFTER_STATE () { 56 }  sub PI_DATA_AFTER_STATE () { 56 }
152    sub DOCTYPE_INTERNAL_SUBSET_STATE () { 57 }
153    sub DOCTYPE_INTERNAL_SUBSET_AFTER_STATE () { 58 }
154    sub BOGUS_DOCTYPE_INTERNAL_SUBSET_AFTER_STATE () { 59 }
155    sub DOCTYPE_TAG_STATE () { 60 }
156    sub DOCTYPE_MARKUP_DECLARATION_OPEN_STATE () { 61 }
157    sub MD_ATTLIST_STATE () { 62 }
158    sub MD_E_STATE () { 63 }
159    sub MD_ELEMENT_STATE () { 64 }
160    sub MD_ENTITY_STATE () { 65 }
161    sub MD_NOTATION_STATE () { 66 }
162    sub DOCTYPE_MD_STATE () { 67 }
163    sub BEFORE_MD_NAME_STATE () { 68 }
164    sub MD_NAME_STATE () { 69 }
165    sub DOCTYPE_ENTITY_PARAMETER_BEFORE_STATE () { 70 }
166    sub DOCTYPE_ATTLIST_NAME_AFTER_STATE () { 71 }
167    sub DOCTYPE_ATTLIST_ATTRIBUTE_NAME_STATE () { 72 }
168    sub DOCTYPE_ATTLIST_ATTRIBUTE_NAME_AFTER_STATE () { 73 }
169    sub DOCTYPE_ATTLIST_ATTRIBUTE_TYPE_STATE () { 74 }
170    sub DOCTYPE_ATTLIST_ATTRIBUTE_TYPE_AFTER_STATE () { 75 }
171    sub BEFORE_ALLOWED_TOKEN_STATE () { 76 }
172    sub ALLOWED_TOKEN_STATE () { 77 }
173    sub AFTER_ALLOWED_TOKEN_STATE () { 78 }
174    sub AFTER_ALLOWED_TOKENS_STATE () { 79 }
175    sub BEFORE_ATTR_DEFAULT_STATE () { 80 }
176    sub DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_BEFORE_STATE () { 81 }
177    sub DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_STATE () { 82 }
178    sub DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_AFTER_STATE () { 83 }
179    sub AFTER_ATTLIST_ATTR_VALUE_QUOTED_STATE () { 84 }
180    sub BEFORE_NDATA_STATE () { 85 }
181    sub NDATA_STATE () { 86 }
182    sub AFTER_NDATA_STATE () { 87 }
183    sub BEFORE_NOTATION_NAME_STATE () { 88 }
184    sub NOTATION_NAME_STATE () { 89 }
185    sub DOCTYPE_ENTITY_VALUE_DOUBLE_QUOTED_STATE () { 90 }
186    sub DOCTYPE_ENTITY_VALUE_SINGLE_QUOTED_STATE () { 91 }
187    sub ENTITY_VALUE_ENTITY_STATE () { 92 }
188    sub AFTER_ELEMENT_NAME_STATE () { 93 }
189    sub BEFORE_ELEMENT_CONTENT_STATE () { 94 }
190    sub CONTENT_KEYWORD_STATE () { 95 }
191    sub AFTER_CM_GROUP_OPEN_STATE () { 96 }
192    sub CM_ELEMENT_NAME_STATE () { 97 }
193    sub AFTER_CM_ELEMENT_NAME_STATE () { 98 }
194    sub AFTER_CM_GROUP_CLOSE_STATE () { 99 }
195    sub AFTER_MD_DEF_STATE () { 100 }
196    sub BOGUS_MD_STATE () { 101 }
197    
198  ## Tree constructor state constants (see Whatpm::HTML for the full  ## Tree constructor state constants (see Whatpm::HTML for the full
199  ## list and descriptions)  ## list and descriptions)
# Line 186  sub _initialize_tokenizer ($) { Line 259  sub _initialize_tokenizer ($) {
259    #$self->{is_xml} (if XML)    #$self->{is_xml} (if XML)
260    
261    $self->{state} = DATA_STATE; # MUST    $self->{state} = DATA_STATE; # MUST
262    $self->{s_kwd} = ''; # state keyword    $self->{s_kwd} = ''; # Data state keyword
263      #$self->{kwd} = ''; # State-dependent keyword; initialized when used
264    #$self->{entity__value}; # initialized when used    #$self->{entity__value}; # initialized when used
265    #$self->{entity__match}; # initialized when used    #$self->{entity__match}; # initialized when used
266    $self->{content_model} = PCDATA_CONTENT_MODEL; # be    $self->{content_model} = PCDATA_CONTENT_MODEL; # be
# Line 221  sub _initialize_tokenizer ($) { Line 295  sub _initialize_tokenizer ($) {
295  ##   ->{data} (COMMENT_TOKEN, CHARACTER_TOKEN, PI_TOKEN)  ##   ->{data} (COMMENT_TOKEN, CHARACTER_TOKEN, PI_TOKEN)
296  ##   ->{has_reference} == 1 or 0 (CHARACTER_TOKEN)  ##   ->{has_reference} == 1 or 0 (CHARACTER_TOKEN)
297  ##   ->{last_index} (ELEMENT_TOKEN): Next attribute's index - 1.  ##   ->{last_index} (ELEMENT_TOKEN): Next attribute's index - 1.
298    ##   ->{has_internal_subset} = 1 or 0 (DOCTYPE_TOKEN)
299    
300  ## NOTE: The "self-closing flag" is hold as |$self->{self_closing}|.  ## NOTE: The "self-closing flag" is hold as |$self->{self_closing}|.
301  ##     |->{self_closing}| is used to save the value of |$self->{self_closing}|  ##     |->{self_closing}| is used to save the value of |$self->{self_closing}|
302  ##     while the token is pushed back to the stack.  ##     while the token is pushed back to the stack.
# Line 240  my $is_space = { Line 316  my $is_space = {
316    0x0009 => 1, # CHARACTER TABULATION (HT)    0x0009 => 1, # CHARACTER TABULATION (HT)
317    0x000A => 1, # LINE FEED (LF)    0x000A => 1, # LINE FEED (LF)
318    #0x000B => 0, # LINE TABULATION (VT)    #0x000B => 0, # LINE TABULATION (VT)
319    0x000C => 1, # FORM FEED (FF)    0x000C => 1, # FORM FEED (FF) ## XML5: Not a space character.
320    #0x000D => 1, # CARRIAGE RETURN (CR)    #0x000D => 1, # CARRIAGE RETURN (CR)
321    0x0020 => 1, # SPACE (SP)    0x0020 => 1, # SPACE (SP)
322  };  };
# Line 450  sub _get_next_token ($) { Line 526  sub _get_next_token ($) {
526            redo A;            redo A;
527          } elsif ($self->{nc} == 0x0021) { # !          } elsif ($self->{nc} == 0x0021) { # !
528            !!!cp (15.1);            !!!cp (15.1);
529            $self->{s_kwd} = '<' unless $self->{escape};            $self->{s_kwd} = $self->{escaped} ? '' : '<';
530            #            #
531          } else {          } else {
532            !!!cp (16);            !!!cp (16);
533              $self->{s_kwd} = '';
534            #            #
535          }          }
536    
537          ## reconsume          ## reconsume
538          $self->{state} = DATA_STATE;          $self->{state} = DATA_STATE;
         $self->{s_kwd} = '';  
539          !!!emit ({type => CHARACTER_TOKEN, data => '<',          !!!emit ({type => CHARACTER_TOKEN, data => '<',
540                    line => $self->{line_prev},                    line => $self->{line_prev},
541                    column => $self->{column_prev},                    column => $self->{column_prev},
# Line 570  sub _get_next_token ($) { Line 646  sub _get_next_token ($) {
646        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
647          if (defined $self->{last_stag_name}) {          if (defined $self->{last_stag_name}) {
648            $self->{state} = CDATA_RCDATA_CLOSE_TAG_STATE;            $self->{state} = CDATA_RCDATA_CLOSE_TAG_STATE;
649            $self->{s_kwd} = '';            $self->{kwd} = '';
650            ## Reconsume.            ## Reconsume.
651            redo A;            redo A;
652          } else {          } else {
# Line 673  sub _get_next_token ($) { Line 749  sub _get_next_token ($) {
749          redo A;          redo A;
750        }        }
751      } elsif ($self->{state} == CDATA_RCDATA_CLOSE_TAG_STATE) {      } elsif ($self->{state} == CDATA_RCDATA_CLOSE_TAG_STATE) {
752        my $ch = substr $self->{last_stag_name}, length $self->{s_kwd}, 1;        my $ch = substr $self->{last_stag_name}, length $self->{kwd}, 1;
753        if (length $ch) {        if (length $ch) {
754          my $CH = $ch;          my $CH = $ch;
755          $ch =~ tr/a-z/A-Z/;          $ch =~ tr/a-z/A-Z/;
# Line 681  sub _get_next_token ($) { Line 757  sub _get_next_token ($) {
757          if ($nch eq $ch or $nch eq $CH) {          if ($nch eq $ch or $nch eq $CH) {
758            !!!cp (24);            !!!cp (24);
759            ## Stay in the state.            ## Stay in the state.
760            $self->{s_kwd} .= $nch;            $self->{kwd} .= $nch;
761            !!!next-input-character;            !!!next-input-character;
762            redo A;            redo A;
763          } else {          } else {
# Line 690  sub _get_next_token ($) { Line 766  sub _get_next_token ($) {
766            $self->{s_kwd} = '';            $self->{s_kwd} = '';
767            ## Reconsume.            ## Reconsume.
768            !!!emit ({type => CHARACTER_TOKEN,            !!!emit ({type => CHARACTER_TOKEN,
769                      data => '</' . $self->{s_kwd},                      data => '</' . $self->{kwd},
770                      line => $self->{line_prev},                      line => $self->{line_prev},
771                      column => $self->{column_prev} - 1 - length $self->{s_kwd},                      column => $self->{column_prev} - 1 - length $self->{kwd},
772                     });                     });
773            redo A;            redo A;
774          }          }
# Line 708  sub _get_next_token ($) { Line 784  sub _get_next_token ($) {
784            $self->{state} = DATA_STATE;            $self->{state} = DATA_STATE;
785            $self->{s_kwd} = '';            $self->{s_kwd} = '';
786            !!!emit ({type => CHARACTER_TOKEN,            !!!emit ({type => CHARACTER_TOKEN,
787                      data => '</' . $self->{s_kwd},                      data => '</' . $self->{kwd},
788                      line => $self->{line_prev},                      line => $self->{line_prev},
789                      column => $self->{column_prev} - 1 - length $self->{s_kwd},                      column => $self->{column_prev} - 1 - length $self->{kwd},
790                     });                     });
791            redo A;            redo A;
792          } else {          } else {
# Line 719  sub _get_next_token ($) { Line 795  sub _get_next_token ($) {
795                = {type => END_TAG_TOKEN,                = {type => END_TAG_TOKEN,
796                   tag_name => $self->{last_stag_name},                   tag_name => $self->{last_stag_name},
797                   line => $self->{line_prev},                   line => $self->{line_prev},
798                   column => $self->{column_prev} - 1 - length $self->{s_kwd}};                   column => $self->{column_prev} - 1 - length $self->{kwd}};
799            $self->{state} = TAG_NAME_STATE;            $self->{state} = TAG_NAME_STATE;
800            ## Reconsume.            ## Reconsume.
801            redo A;            redo A;
# Line 872  sub _get_next_token ($) { Line 948  sub _get_next_token ($) {
948          if ({          if ({
949               0x0022 => 1, # "               0x0022 => 1, # "
950               0x0027 => 1, # '               0x0027 => 1, # '
951                 0x003C => 1, # <
952               0x003D => 1, # =               0x003D => 1, # =
953              }->{$self->{nc}}) {              }->{$self->{nc}}) {
954            !!!cp (55);            !!!cp (55);
# Line 994  sub _get_next_token ($) { Line 1071  sub _get_next_token ($) {
1071    
1072          redo A;          redo A;
1073        } else {        } else {
1074          if ($self->{nc} == 0x0022 or # "          if ({
1075              $self->{nc} == 0x0027) { # '               0x0022 => 1, # "
1076                 0x0027 => 1, # '
1077                 0x003C => 1, # <
1078                }->{$self->{nc}}) {
1079            !!!cp (69);            !!!cp (69);
1080            ## XML5: Not a parse error.            ## XML5: Not a parse error.
1081            !!!parse-error (type => 'bad attribute name');            !!!parse-error (type => 'bad attribute name');
# Line 1106  sub _get_next_token ($) { Line 1186  sub _get_next_token ($) {
1186            !!!cp (78.2);            !!!cp (78.2);
1187          }          }
1188    
1189          if ($self->{nc} == 0x0022 or # "          if ({
1190              $self->{nc} == 0x0027) { # '               0x0022 => 1, # "
1191                 0x0027 => 1, # '
1192                 0x003C => 1, # <
1193                }->{$self->{nc}}) {
1194            !!!cp (78);            !!!cp (78);
1195            ## XML5: Not a parse error.            ## XML5: Not a parse error.
1196            !!!parse-error (type => 'bad attribute name');            !!!parse-error (type => 'bad attribute name');
# Line 1194  sub _get_next_token ($) { Line 1277  sub _get_next_token ($) {
1277    
1278          redo A;          redo A;
1279        } else {        } else {
1280          if ($self->{nc} == 0x003D) { # =          if ($self->{nc} == 0x003D or $self->{nc} == 0x003C) { # =, <
1281            !!!cp (93);            !!!cp (93);
1282            ## XML5: Not a parse error.            ## XML5: Not a parse error.
1283            !!!parse-error (type => 'bad attribute value');            !!!parse-error (type => 'bad attribute value');
# Line 1211  sub _get_next_token ($) { Line 1294  sub _get_next_token ($) {
1294          redo A;          redo A;
1295        }        }
1296      } elsif ($self->{state} == ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE) {      } elsif ($self->{state} == ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE) {
1297        ## XML5: "Tag attribute value double quoted state".        ## XML5: "Tag attribute value double quoted state" and "DOCTYPE
1298          ## ATTLIST attribute value double quoted state".
1299                
1300        if ($self->{nc} == 0x0022) { # "        if ($self->{nc} == 0x0022) { # "
1301          !!!cp (95);          if ($self->{ct}->{type} == ATTLIST_TOKEN) {
1302          ## XML5: "Tag attribute name before state".            !!!cp (95.1);
1303          $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;            ## XML5: "DOCTYPE ATTLIST name after state".
1304              push @{$self->{ct}->{attrdefs}}, $self->{ca};
1305              $self->{state} = AFTER_ATTLIST_ATTR_VALUE_QUOTED_STATE;
1306            } else {
1307              !!!cp (95);
1308              ## XML5: "Tag attribute name before state".
1309              $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
1310            }
1311          !!!next-input-character;          !!!next-input-character;
1312          redo A;          redo A;
1313        } elsif ($self->{nc} == 0x0026) { # &        } elsif ($self->{nc} == 0x0026) { # &
# Line 1232  sub _get_next_token ($) { Line 1323  sub _get_next_token ($) {
1323          $self->{state} = ENTITY_STATE;          $self->{state} = ENTITY_STATE;
1324          !!!next-input-character;          !!!next-input-character;
1325          redo A;          redo A;
1326          } elsif ($self->{is_xml} and
1327                   $is_space->{$self->{nc}}) {
1328            !!!cp (97.1);
1329            $self->{ca}->{value} .= ' ';
1330            ## Stay in the state.
1331            !!!next-input-character;
1332            redo A;
1333        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
1334          !!!parse-error (type => 'unclosed attribute value');          !!!parse-error (type => 'unclosed attribute value');
1335          if ($self->{ct}->{type} == START_TAG_TOKEN) {          if ($self->{ct}->{type} == START_TAG_TOKEN) {
1336            !!!cp (97);            !!!cp (97);
1337            $self->{last_stag_name} = $self->{ct}->{tag_name};            $self->{last_stag_name} = $self->{ct}->{tag_name};
1338    
1339              $self->{state} = DATA_STATE;
1340              $self->{s_kwd} = '';
1341              ## reconsume
1342              !!!emit ($self->{ct}); # start tag
1343              redo A;
1344          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {
1345            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1346            if ($self->{ct}->{attributes}) {            if ($self->{ct}->{attributes}) {
# Line 1246  sub _get_next_token ($) { Line 1350  sub _get_next_token ($) {
1350              ## NOTE: This state should never be reached.              ## NOTE: This state should never be reached.
1351              !!!cp (99);              !!!cp (99);
1352            }            }
1353    
1354              $self->{state} = DATA_STATE;
1355              $self->{s_kwd} = '';
1356              ## reconsume
1357              !!!emit ($self->{ct}); # end tag
1358              redo A;
1359            } elsif ($self->{ct}->{type} == ATTLIST_TOKEN) {
1360              ## XML5: No parse error above; not defined yet.
1361              push @{$self->{ct}->{attrdefs}}, $self->{ca};
1362              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
1363              ## Reconsume.
1364              !!!emit ($self->{ct}); # ATTLIST
1365              redo A;
1366          } else {          } else {
1367            die "$0: $self->{ct}->{type}: Unknown token type";            die "$0: $self->{ct}->{type}: Unknown token type";
1368          }          }
         $self->{state} = DATA_STATE;  
         $self->{s_kwd} = '';  
         ## reconsume  
   
         !!!emit ($self->{ct}); # start tag or end tag  
   
         redo A;  
1369        } else {        } else {
1370            ## XML5 [ATTLIST]: Not defined yet.
1371          if ($self->{is_xml} and $self->{nc} == 0x003C) { # <          if ($self->{is_xml} and $self->{nc} == 0x003C) { # <
1372            !!!cp (100);            !!!cp (100);
1373            ## XML5: Not a parse error.            ## XML5: Not a parse error.
# Line 1266  sub _get_next_token ($) { Line 1377  sub _get_next_token ($) {
1377          }          }
1378          $self->{ca}->{value} .= chr ($self->{nc});          $self->{ca}->{value} .= chr ($self->{nc});
1379          $self->{read_until}->($self->{ca}->{value},          $self->{read_until}->($self->{ca}->{value},
1380                                q["&<],                                qq["&<\x09\x0C\x20],
1381                                length $self->{ca}->{value});                                length $self->{ca}->{value});
1382    
1383          ## Stay in the state          ## Stay in the state
# Line 1274  sub _get_next_token ($) { Line 1385  sub _get_next_token ($) {
1385          redo A;          redo A;
1386        }        }
1387      } elsif ($self->{state} == ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE) {      } elsif ($self->{state} == ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE) {
1388        ## XML5: "Tag attribute value single quoted state".        ## XML5: "Tag attribute value single quoted state" and "DOCTYPE
1389          ## ATTLIST attribute value single quoted state".
1390    
1391        if ($self->{nc} == 0x0027) { # '        if ($self->{nc} == 0x0027) { # '
1392          !!!cp (101);          if ($self->{ct}->{type} == ATTLIST_TOKEN) {
1393          ## XML5: "Before attribute name state" (sic).            !!!cp (101.1);
1394          $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;            ## XML5: "DOCTYPE ATTLIST name after state".
1395              push @{$self->{ct}->{attrdefs}}, $self->{ca};
1396              $self->{state} = AFTER_ATTLIST_ATTR_VALUE_QUOTED_STATE;
1397            } else {
1398              !!!cp (101);
1399              ## XML5: "Before attribute name state" (sic).
1400              $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;
1401            }
1402          !!!next-input-character;          !!!next-input-character;
1403          redo A;          redo A;
1404        } elsif ($self->{nc} == 0x0026) { # &        } elsif ($self->{nc} == 0x0026) { # &
# Line 1295  sub _get_next_token ($) { Line 1414  sub _get_next_token ($) {
1414          $self->{state} = ENTITY_STATE;          $self->{state} = ENTITY_STATE;
1415          !!!next-input-character;          !!!next-input-character;
1416          redo A;          redo A;
1417          } elsif ($self->{is_xml} and
1418                   $is_space->{$self->{nc}}) {
1419            !!!cp (103.1);
1420            $self->{ca}->{value} .= ' ';
1421            ## Stay in the state.
1422            !!!next-input-character;
1423            redo A;
1424        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
1425          !!!parse-error (type => 'unclosed attribute value');          !!!parse-error (type => 'unclosed attribute value');
1426          if ($self->{ct}->{type} == START_TAG_TOKEN) {          if ($self->{ct}->{type} == START_TAG_TOKEN) {
1427            !!!cp (103);            !!!cp (103);
1428            $self->{last_stag_name} = $self->{ct}->{tag_name};            $self->{last_stag_name} = $self->{ct}->{tag_name};
1429    
1430              $self->{state} = DATA_STATE;
1431              $self->{s_kwd} = '';
1432              ## reconsume
1433              !!!emit ($self->{ct}); # start tag
1434              redo A;
1435          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {
1436            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1437            if ($self->{ct}->{attributes}) {            if ($self->{ct}->{attributes}) {
# Line 1309  sub _get_next_token ($) { Line 1441  sub _get_next_token ($) {
1441              ## NOTE: This state should never be reached.              ## NOTE: This state should never be reached.
1442              !!!cp (105);              !!!cp (105);
1443            }            }
1444    
1445              $self->{state} = DATA_STATE;
1446              $self->{s_kwd} = '';
1447              ## reconsume
1448              !!!emit ($self->{ct}); # end tag
1449              redo A;
1450            } elsif ($self->{ct}->{type} == ATTLIST_TOKEN) {
1451              ## XML5: No parse error above; not defined yet.
1452              push @{$self->{ct}->{attrdefs}}, $self->{ca};
1453              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
1454              ## Reconsume.
1455              !!!emit ($self->{ct}); # ATTLIST
1456              redo A;
1457          } else {          } else {
1458            die "$0: $self->{ct}->{type}: Unknown token type";            die "$0: $self->{ct}->{type}: Unknown token type";
1459          }          }
         $self->{state} = DATA_STATE;  
         $self->{s_kwd} = '';  
         ## reconsume  
   
         !!!emit ($self->{ct}); # start tag or end tag  
   
         redo A;  
1460        } else {        } else {
1461            ## XML5 [ATTLIST]: Not defined yet.
1462          if ($self->{is_xml} and $self->{nc} == 0x003C) { # <          if ($self->{is_xml} and $self->{nc} == 0x003C) { # <
1463            !!!cp (106);            !!!cp (106);
1464            ## XML5: Not a parse error.            ## XML5: Not a parse error.
# Line 1329  sub _get_next_token ($) { Line 1468  sub _get_next_token ($) {
1468          }          }
1469          $self->{ca}->{value} .= chr ($self->{nc});          $self->{ca}->{value} .= chr ($self->{nc});
1470          $self->{read_until}->($self->{ca}->{value},          $self->{read_until}->($self->{ca}->{value},
1471                                q['&<],                                qq['&<\x09\x0C\x20],
1472                                length $self->{ca}->{value});                                length $self->{ca}->{value});
1473    
1474          ## Stay in the state          ## Stay in the state
# Line 1340  sub _get_next_token ($) { Line 1479  sub _get_next_token ($) {
1479        ## XML5: "Tag attribute value unquoted state".        ## XML5: "Tag attribute value unquoted state".
1480    
1481        if ($is_space->{$self->{nc}}) {        if ($is_space->{$self->{nc}}) {
1482          !!!cp (107);          if ($self->{ct}->{type} == ATTLIST_TOKEN) {
1483          ## XML5: "Tag attribute name before state".            !!!cp (107.1);
1484          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;            push @{$self->{ct}->{attrdefs}}, $self->{ca};
1485              $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;
1486            } else {
1487              !!!cp (107);
1488              ## XML5: "Tag attribute name before state".
1489              $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
1490            }
1491          !!!next-input-character;          !!!next-input-character;
1492          redo A;          redo A;
1493        } elsif ($self->{nc} == 0x0026) { # &        } elsif ($self->{nc} == 0x0026) { # &
# Line 1363  sub _get_next_token ($) { Line 1508  sub _get_next_token ($) {
1508          if ($self->{ct}->{type} == START_TAG_TOKEN) {          if ($self->{ct}->{type} == START_TAG_TOKEN) {
1509            !!!cp (109);            !!!cp (109);
1510            $self->{last_stag_name} = $self->{ct}->{tag_name};            $self->{last_stag_name} = $self->{ct}->{tag_name};
1511    
1512              $self->{state} = DATA_STATE;
1513              $self->{s_kwd} = '';
1514              !!!next-input-character;
1515              !!!emit ($self->{ct}); # start tag
1516              redo A;
1517          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {
1518            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1519            if ($self->{ct}->{attributes}) {            if ($self->{ct}->{attributes}) {
# Line 1372  sub _get_next_token ($) { Line 1523  sub _get_next_token ($) {
1523              ## NOTE: This state should never be reached.              ## NOTE: This state should never be reached.
1524              !!!cp (111);              !!!cp (111);
1525            }            }
1526    
1527              $self->{state} = DATA_STATE;
1528              $self->{s_kwd} = '';
1529              !!!next-input-character;
1530              !!!emit ($self->{ct}); # end tag
1531              redo A;
1532            } elsif ($self->{ct}->{type} == ATTLIST_TOKEN) {
1533              push @{$self->{ct}->{attrdefs}}, $self->{ca};
1534              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
1535              !!!next-input-character;
1536              !!!emit ($self->{ct}); # ATTLIST
1537              redo A;
1538          } else {          } else {
1539            die "$0: $self->{ct}->{type}: Unknown token type";            die "$0: $self->{ct}->{type}: Unknown token type";
1540          }          }
         $self->{state} = DATA_STATE;  
         $self->{s_kwd} = '';  
         !!!next-input-character;  
   
         !!!emit ($self->{ct}); # start tag or end tag  
   
         redo A;  
1541        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
         !!!parse-error (type => 'unclosed tag');  
1542          if ($self->{ct}->{type} == START_TAG_TOKEN) {          if ($self->{ct}->{type} == START_TAG_TOKEN) {
1543            !!!cp (112);            !!!cp (112);
1544              !!!parse-error (type => 'unclosed tag');
1545            $self->{last_stag_name} = $self->{ct}->{tag_name};            $self->{last_stag_name} = $self->{ct}->{tag_name};
1546    
1547              $self->{state} = DATA_STATE;
1548              $self->{s_kwd} = '';
1549              ## reconsume
1550              !!!emit ($self->{ct}); # start tag
1551              redo A;
1552          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {          } elsif ($self->{ct}->{type} == END_TAG_TOKEN) {
1553              !!!parse-error (type => 'unclosed tag');
1554            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST            $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST
1555            if ($self->{ct}->{attributes}) {            if ($self->{ct}->{attributes}) {
1556              !!!cp (113);              !!!cp (113);
# Line 1396  sub _get_next_token ($) { Line 1559  sub _get_next_token ($) {
1559              ## NOTE: This state should never be reached.              ## NOTE: This state should never be reached.
1560              !!!cp (114);              !!!cp (114);
1561            }            }
1562    
1563              $self->{state} = DATA_STATE;
1564              $self->{s_kwd} = '';
1565              ## reconsume
1566              !!!emit ($self->{ct}); # end tag
1567              redo A;
1568            } elsif ($self->{ct}->{type} == ATTLIST_TOKEN) {
1569              !!!parse-error (type => 'unclosed md'); ## TODO: type
1570              push @{$self->{ct}->{attrdefs}}, $self->{ca};
1571              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
1572              ## Reconsume.
1573              !!!emit ($self->{ct}); # ATTLIST
1574              redo A;
1575          } else {          } else {
1576            die "$0: $self->{ct}->{type}: Unknown token type";            die "$0: $self->{ct}->{type}: Unknown token type";
1577          }          }
         $self->{state} = DATA_STATE;  
         $self->{s_kwd} = '';  
         ## reconsume  
   
         !!!emit ($self->{ct}); # start tag or end tag  
   
         redo A;  
1578        } else {        } else {
1579          if ({          if ({
1580               0x0022 => 1, # "               0x0022 => 1, # "
1581               0x0027 => 1, # '               0x0027 => 1, # '
1582               0x003D => 1, # =               0x003D => 1, # =
1583                 0x003C => 1, # <
1584              }->{$self->{nc}}) {              }->{$self->{nc}}) {
1585            !!!cp (115);            !!!cp (115);
1586            ## XML5: Not a parse error.            ## XML5: Not a parse error.
# Line 1420  sub _get_next_token ($) { Line 1590  sub _get_next_token ($) {
1590          }          }
1591          $self->{ca}->{value} .= chr ($self->{nc});          $self->{ca}->{value} .= chr ($self->{nc});
1592          $self->{read_until}->($self->{ca}->{value},          $self->{read_until}->($self->{ca}->{value},
1593                                q["'=& >],                                qq["'=& \x09\x0C>],
1594                                length $self->{ca}->{value});                                length $self->{ca}->{value});
1595    
1596          ## Stay in the state          ## Stay in the state
# Line 1548  sub _get_next_token ($) { Line 1718  sub _get_next_token ($) {
1718          redo A;          redo A;
1719        }        }
1720      } elsif ($self->{state} == BOGUS_COMMENT_STATE) {      } elsif ($self->{state} == BOGUS_COMMENT_STATE) {
1721        ## (only happen if PCDATA state)        ## XML5: "Bogus comment state" and "DOCTYPE bogus comment state".
1722    
1723        ## NOTE: Unlike spec's "bogus comment state", this implementation        ## NOTE: Unlike spec's "bogus comment state", this implementation
1724        ## consumes characters one-by-one basis.        ## consumes characters one-by-one basis.
1725                
1726        if ($self->{nc} == 0x003E) { # >        if ($self->{nc} == 0x003E) { # >
1727          !!!cp (124);          if ($self->{in_subset}) {
1728          $self->{state} = DATA_STATE;            !!!cp (123);
1729          $self->{s_kwd} = '';            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
1730            } else {
1731              !!!cp (124);
1732              $self->{state} = DATA_STATE;
1733              $self->{s_kwd} = '';
1734            }
1735          !!!next-input-character;          !!!next-input-character;
1736    
1737          !!!emit ($self->{ct}); # comment          !!!emit ($self->{ct}); # comment
1738          redo A;          redo A;
1739        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
1740          !!!cp (125);          if ($self->{in_subset}) {
1741          $self->{state} = DATA_STATE;            !!!cp (125.1);
1742          $self->{s_kwd} = '';            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
1743            } else {
1744              !!!cp (125);
1745              $self->{state} = DATA_STATE;
1746              $self->{s_kwd} = '';
1747            }
1748          ## reconsume          ## reconsume
1749    
1750          !!!emit ($self->{ct}); # comment          !!!emit ($self->{ct}); # comment
# Line 1581  sub _get_next_token ($) { Line 1761  sub _get_next_token ($) {
1761          redo A;          redo A;
1762        }        }
1763      } elsif ($self->{state} == MARKUP_DECLARATION_OPEN_STATE) {      } elsif ($self->{state} == MARKUP_DECLARATION_OPEN_STATE) {
1764        ## (only happen if PCDATA state)        ## XML5: "Markup declaration state".
1765                
1766        if ($self->{nc} == 0x002D) { # -        if ($self->{nc} == 0x002D) { # -
1767          !!!cp (133);          !!!cp (133);
# Line 1593  sub _get_next_token ($) { Line 1773  sub _get_next_token ($) {
1773          ## ASCII case-insensitive.          ## ASCII case-insensitive.
1774          !!!cp (130);          !!!cp (130);
1775          $self->{state} = MD_DOCTYPE_STATE;          $self->{state} = MD_DOCTYPE_STATE;
1776          $self->{s_kwd} = chr $self->{nc};          $self->{kwd} = chr $self->{nc};
1777          !!!next-input-character;          !!!next-input-character;
1778          redo A;          redo A;
1779        } elsif ((($self->{insertion_mode} & IN_FOREIGN_CONTENT_IM and        } elsif ((($self->{insertion_mode} & IN_FOREIGN_CONTENT_IM and
# Line 1602  sub _get_next_token ($) { Line 1782  sub _get_next_token ($) {
1782                 $self->{nc} == 0x005B) { # [                 $self->{nc} == 0x005B) { # [
1783          !!!cp (135.4);                          !!!cp (135.4);                
1784          $self->{state} = MD_CDATA_STATE;          $self->{state} = MD_CDATA_STATE;
1785          $self->{s_kwd} = '[';          $self->{kwd} = '[';
1786          !!!next-input-character;          !!!next-input-character;
1787          redo A;          redo A;
1788        } else {        } else {
# Line 1652  sub _get_next_token ($) { Line 1832  sub _get_next_token ($) {
1832              0x0054, # T              0x0054, # T
1833              0x0059, # Y              0x0059, # Y
1834              0x0050, # P              0x0050, # P
1835            ]->[length $self->{s_kwd}] or            ]->[length $self->{kwd}] or
1836            $self->{nc} == [            $self->{nc} == [
1837              undef,              undef,
1838              0x006F, # o              0x006F, # o
# Line 1660  sub _get_next_token ($) { Line 1840  sub _get_next_token ($) {
1840              0x0074, # t              0x0074, # t
1841              0x0079, # y              0x0079, # y
1842              0x0070, # p              0x0070, # p
1843            ]->[length $self->{s_kwd}]) {            ]->[length $self->{kwd}]) {
1844          !!!cp (131);          !!!cp (131);
1845          ## Stay in the state.          ## Stay in the state.
1846          $self->{s_kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
1847          !!!next-input-character;          !!!next-input-character;
1848          redo A;          redo A;
1849        } elsif ((length $self->{s_kwd}) == 6 and        } elsif ((length $self->{kwd}) == 6 and
1850                 ($self->{nc} == 0x0045 or # E                 ($self->{nc} == 0x0045 or # E
1851                  $self->{nc} == 0x0065)) { # e                  $self->{nc} == 0x0065)) { # e
1852          if ($self->{s_kwd} ne 'DOCTYP') {          if ($self->{is_xml} and
1853                ($self->{kwd} ne 'DOCTYP' or $self->{nc} == 0x0065)) {
1854            !!!cp (129);            !!!cp (129);
1855            ## XML5: case-sensitive.            ## XML5: case-sensitive.
1856            !!!parse-error (type => 'lowercase keyword', ## TODO            !!!parse-error (type => 'lowercase keyword', ## TODO
# Line 1691  sub _get_next_token ($) { Line 1872  sub _get_next_token ($) {
1872          !!!cp (132);                  !!!cp (132);        
1873          !!!parse-error (type => 'bogus comment',          !!!parse-error (type => 'bogus comment',
1874                          line => $self->{line_prev},                          line => $self->{line_prev},
1875                          column => $self->{column_prev} - 1 - length $self->{s_kwd});                          column => $self->{column_prev} - 1 - length $self->{kwd});
1876          $self->{state} = BOGUS_COMMENT_STATE;          $self->{state} = BOGUS_COMMENT_STATE;
1877          ## Reconsume.          ## Reconsume.
1878          $self->{ct} = {type => COMMENT_TOKEN,          $self->{ct} = {type => COMMENT_TOKEN,
1879                                    data => $self->{s_kwd},                                    data => $self->{kwd},
1880                                    line => $self->{line_prev},                                    line => $self->{line_prev},
1881                                    column => $self->{column_prev} - 1 - length $self->{s_kwd},                                    column => $self->{column_prev} - 1 - length $self->{kwd},
1882                                   };                                   };
1883          redo A;          redo A;
1884        }        }
# Line 1708  sub _get_next_token ($) { Line 1889  sub _get_next_token ($) {
1889              '[CD' => 0x0041, # A              '[CD' => 0x0041, # A
1890              '[CDA' => 0x0054, # T              '[CDA' => 0x0054, # T
1891              '[CDAT' => 0x0041, # A              '[CDAT' => 0x0041, # A
1892            }->{$self->{s_kwd}}) {            }->{$self->{kwd}}) {
1893          !!!cp (135.1);          !!!cp (135.1);
1894          ## Stay in the state.          ## Stay in the state.
1895          $self->{s_kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
1896          !!!next-input-character;          !!!next-input-character;
1897          redo A;          redo A;
1898        } elsif ($self->{s_kwd} eq '[CDATA' and        } elsif ($self->{kwd} eq '[CDATA' and
1899                 $self->{nc} == 0x005B) { # [                 $self->{nc} == 0x005B) { # [
1900          if ($self->{is_xml} and          if ($self->{is_xml} and
1901              not $self->{tainted} and              not $self->{tainted} and
# Line 1739  sub _get_next_token ($) { Line 1920  sub _get_next_token ($) {
1920          !!!cp (135.3);          !!!cp (135.3);
1921          !!!parse-error (type => 'bogus comment',          !!!parse-error (type => 'bogus comment',
1922                          line => $self->{line_prev},                          line => $self->{line_prev},
1923                          column => $self->{column_prev} - 1 - length $self->{s_kwd});                          column => $self->{column_prev} - 1 - length $self->{kwd});
1924          $self->{state} = BOGUS_COMMENT_STATE;          $self->{state} = BOGUS_COMMENT_STATE;
1925          ## Reconsume.          ## Reconsume.
1926          $self->{ct} = {type => COMMENT_TOKEN,          $self->{ct} = {type => COMMENT_TOKEN,
1927                                    data => $self->{s_kwd},                                    data => $self->{kwd},
1928                                    line => $self->{line_prev},                                    line => $self->{line_prev},
1929                                    column => $self->{column_prev} - 1 - length $self->{s_kwd},                                    column => $self->{column_prev} - 1 - length $self->{kwd},
1930                                   };                                   };
1931          redo A;          redo A;
1932        }        }
# Line 1756  sub _get_next_token ($) { Line 1937  sub _get_next_token ($) {
1937          !!!next-input-character;          !!!next-input-character;
1938          redo A;          redo A;
1939        } elsif ($self->{nc} == 0x003E) { # >        } elsif ($self->{nc} == 0x003E) { # >
         !!!cp (138);  
1940          !!!parse-error (type => 'bogus comment');          !!!parse-error (type => 'bogus comment');
1941          $self->{state} = DATA_STATE;          if ($self->{in_subset}) {
1942          $self->{s_kwd} = '';            !!!cp (138.1);
1943              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
1944            } else {
1945              !!!cp (138);
1946              $self->{state} = DATA_STATE;
1947              $self->{s_kwd} = '';
1948            }
1949          !!!next-input-character;          !!!next-input-character;
1950    
1951          !!!emit ($self->{ct}); # comment          !!!emit ($self->{ct}); # comment
1952    
1953          redo A;          redo A;
1954        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
         !!!cp (139);  
1955          !!!parse-error (type => 'unclosed comment');          !!!parse-error (type => 'unclosed comment');
1956          $self->{state} = DATA_STATE;          if ($self->{in_subset}) {
1957          $self->{s_kwd} = '';            !!!cp (139.1);
1958              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
1959            } else {
1960              !!!cp (139);
1961              $self->{state} = DATA_STATE;
1962              $self->{s_kwd} = '';
1963            }
1964          ## reconsume          ## reconsume
1965    
1966          !!!emit ($self->{ct}); # comment          !!!emit ($self->{ct}); # comment
# Line 1790  sub _get_next_token ($) { Line 1981  sub _get_next_token ($) {
1981          !!!next-input-character;          !!!next-input-character;
1982          redo A;          redo A;
1983        } elsif ($self->{nc} == 0x003E) { # >        } elsif ($self->{nc} == 0x003E) { # >
         !!!cp (142);  
1984          !!!parse-error (type => 'bogus comment');          !!!parse-error (type => 'bogus comment');
1985          $self->{state} = DATA_STATE;          if ($self->{in_subset}) {
1986          $self->{s_kwd} = '';            !!!cp (142.1);
1987              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
1988            } else {
1989              !!!cp (142);
1990              $self->{state} = DATA_STATE;
1991              $self->{s_kwd} = '';
1992            }
1993          !!!next-input-character;          !!!next-input-character;
1994    
1995          !!!emit ($self->{ct}); # comment          !!!emit ($self->{ct}); # comment
1996    
1997          redo A;          redo A;
1998        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
         !!!cp (143);  
1999          !!!parse-error (type => 'unclosed comment');          !!!parse-error (type => 'unclosed comment');
2000          $self->{state} = DATA_STATE;          if ($self->{in_subset}) {
2001          $self->{s_kwd} = '';            !!!cp (143.1);
2002              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2003            } else {
2004              !!!cp (143);
2005              $self->{state} = DATA_STATE;
2006              $self->{s_kwd} = '';
2007            }
2008          ## reconsume          ## reconsume
2009    
2010          !!!emit ($self->{ct}); # comment          !!!emit ($self->{ct}); # comment
# Line 1818  sub _get_next_token ($) { Line 2019  sub _get_next_token ($) {
2019          redo A;          redo A;
2020        }        }
2021      } elsif ($self->{state} == COMMENT_STATE) {      } elsif ($self->{state} == COMMENT_STATE) {
2022          ## XML5: "Comment state" and "DOCTYPE comment state".
2023    
2024        if ($self->{nc} == 0x002D) { # -        if ($self->{nc} == 0x002D) { # -
2025          !!!cp (145);          !!!cp (145);
2026          $self->{state} = COMMENT_END_DASH_STATE;          $self->{state} = COMMENT_END_DASH_STATE;
2027          !!!next-input-character;          !!!next-input-character;
2028          redo A;          redo A;
2029        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
         !!!cp (146);  
2030          !!!parse-error (type => 'unclosed comment');          !!!parse-error (type => 'unclosed comment');
2031          $self->{state} = DATA_STATE;          if ($self->{in_subset}) {
2032          $self->{s_kwd} = '';            !!!cp (146.1);
2033              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2034            } else {
2035              !!!cp (146);
2036              $self->{state} = DATA_STATE;
2037              $self->{s_kwd} = '';
2038            }
2039          ## reconsume          ## reconsume
2040    
2041          !!!emit ($self->{ct}); # comment          !!!emit ($self->{ct}); # comment
# Line 1845  sub _get_next_token ($) { Line 2053  sub _get_next_token ($) {
2053          redo A;          redo A;
2054        }        }
2055      } elsif ($self->{state} == COMMENT_END_DASH_STATE) {      } elsif ($self->{state} == COMMENT_END_DASH_STATE) {
2056        ## XML5: "comment dash state".        ## XML5: "Comment dash state" and "DOCTYPE comment dash state".
2057    
2058        if ($self->{nc} == 0x002D) { # -        if ($self->{nc} == 0x002D) { # -
2059          !!!cp (148);          !!!cp (148);
# Line 1853  sub _get_next_token ($) { Line 2061  sub _get_next_token ($) {
2061          !!!next-input-character;          !!!next-input-character;
2062          redo A;          redo A;
2063        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
         !!!cp (149);  
2064          !!!parse-error (type => 'unclosed comment');          !!!parse-error (type => 'unclosed comment');
2065          $self->{s_kwd} = '';          if ($self->{in_subset}) {
2066          $self->{state} = DATA_STATE;            !!!cp (149.1);
2067          $self->{s_kwd} = '';            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2068            } else {
2069              !!!cp (149);
2070              $self->{state} = DATA_STATE;
2071              $self->{s_kwd} = '';
2072            }
2073          ## reconsume          ## reconsume
2074    
2075          !!!emit ($self->{ct}); # comment          !!!emit ($self->{ct}); # comment
# Line 1871  sub _get_next_token ($) { Line 2083  sub _get_next_token ($) {
2083          redo A;          redo A;
2084        }        }
2085      } elsif ($self->{state} == COMMENT_END_STATE) {      } elsif ($self->{state} == COMMENT_END_STATE) {
2086          ## XML5: "Comment end state" and "DOCTYPE comment end state".
2087    
2088        if ($self->{nc} == 0x003E) { # >        if ($self->{nc} == 0x003E) { # >
2089          !!!cp (151);          if ($self->{in_subset}) {
2090          $self->{state} = DATA_STATE;            !!!cp (151.1);
2091          $self->{s_kwd} = '';            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2092            } else {
2093              !!!cp (151);
2094              $self->{state} = DATA_STATE;
2095              $self->{s_kwd} = '';
2096            }
2097          !!!next-input-character;          !!!next-input-character;
2098    
2099          !!!emit ($self->{ct}); # comment          !!!emit ($self->{ct}); # comment
# Line 1891  sub _get_next_token ($) { Line 2110  sub _get_next_token ($) {
2110          !!!next-input-character;          !!!next-input-character;
2111          redo A;          redo A;
2112        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
         !!!cp (153);  
2113          !!!parse-error (type => 'unclosed comment');          !!!parse-error (type => 'unclosed comment');
2114          $self->{state} = DATA_STATE;          if ($self->{in_subset}) {
2115          $self->{s_kwd} = '';            !!!cp (153.1);
2116              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2117            } else {
2118              !!!cp (153);
2119              $self->{state} = DATA_STATE;
2120              $self->{s_kwd} = '';
2121            }
2122          ## reconsume          ## reconsume
2123    
2124          !!!emit ($self->{ct}); # comment          !!!emit ($self->{ct}); # comment
# Line 1902  sub _get_next_token ($) { Line 2126  sub _get_next_token ($) {
2126          redo A;          redo A;
2127        } else {        } else {
2128          !!!cp (154);          !!!cp (154);
         ## XML5: Not a parse error.  
         !!!parse-error (type => 'dash in comment',  
                         line => $self->{line_prev},  
                         column => $self->{column_prev});  
2129          $self->{ct}->{data} .= '--' . chr ($self->{nc}); # comment          $self->{ct}->{data} .= '--' . chr ($self->{nc}); # comment
2130          $self->{state} = COMMENT_STATE;          $self->{state} = COMMENT_STATE;
2131          !!!next-input-character;          !!!next-input-character;
# Line 1917  sub _get_next_token ($) { Line 2137  sub _get_next_token ($) {
2137          $self->{state} = BEFORE_DOCTYPE_NAME_STATE;          $self->{state} = BEFORE_DOCTYPE_NAME_STATE;
2138          !!!next-input-character;          !!!next-input-character;
2139          redo A;          redo A;
2140          } elsif ($self->{nc} == -1) {
2141            !!!cp (155.1);
2142            !!!parse-error (type => 'unclosed DOCTYPE');
2143            $self->{ct}->{quirks} = 1;
2144    
2145            $self->{state} = DATA_STATE;
2146            ## Reconsume.
2147            !!!emit ($self->{ct}); # DOCTYPE (quirks)
2148    
2149            redo A;
2150        } else {        } else {
2151          !!!cp (156);          !!!cp (156);
2152            ## XML5: Swith to the bogus comment state.
2153          !!!parse-error (type => 'no space before DOCTYPE name');          !!!parse-error (type => 'no space before DOCTYPE name');
2154          $self->{state} = BEFORE_DOCTYPE_NAME_STATE;          $self->{state} = BEFORE_DOCTYPE_NAME_STATE;
2155          ## reconsume          ## reconsume
2156          redo A;          redo A;
2157        }        }
2158      } elsif ($self->{state} == BEFORE_DOCTYPE_NAME_STATE) {      } elsif ($self->{state} == BEFORE_DOCTYPE_NAME_STATE) {
2159          ## XML5: "DOCTYPE root name before state".
2160    
2161        if ($is_space->{$self->{nc}}) {        if ($is_space->{$self->{nc}}) {
2162          !!!cp (157);          !!!cp (157);
2163          ## Stay in the state          ## Stay in the state
# Line 1932  sub _get_next_token ($) { Line 2165  sub _get_next_token ($) {
2165          redo A;          redo A;
2166        } elsif ($self->{nc} == 0x003E) { # >        } elsif ($self->{nc} == 0x003E) { # >
2167          !!!cp (158);          !!!cp (158);
2168            ## XML5: No parse error.
2169          !!!parse-error (type => 'no DOCTYPE name');          !!!parse-error (type => 'no DOCTYPE name');
2170          $self->{state} = DATA_STATE;          $self->{state} = DATA_STATE;
2171          $self->{s_kwd} = '';          $self->{s_kwd} = '';
# Line 1940  sub _get_next_token ($) { Line 2174  sub _get_next_token ($) {
2174          !!!emit ($self->{ct}); # DOCTYPE (quirks)          !!!emit ($self->{ct}); # DOCTYPE (quirks)
2175    
2176          redo A;          redo A;
2177          } elsif (0x0041 <= $self->{nc} and $self->{nc} <= 0x005A) { # A..Z
2178            !!!cp (158.1);
2179            $self->{ct}->{name} # DOCTYPE
2180                = chr ($self->{nc} + ($self->{is_xml} ? 0 : 0x0020));
2181            delete $self->{ct}->{quirks};
2182            $self->{state} = DOCTYPE_NAME_STATE;
2183            !!!next-input-character;
2184            redo A;
2185        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
2186          !!!cp (159);          !!!cp (159);
2187          !!!parse-error (type => 'no DOCTYPE name');          !!!parse-error (type => 'no DOCTYPE name');
# Line 1950  sub _get_next_token ($) { Line 2192  sub _get_next_token ($) {
2192          !!!emit ($self->{ct}); # DOCTYPE (quirks)          !!!emit ($self->{ct}); # DOCTYPE (quirks)
2193    
2194          redo A;          redo A;
2195          } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [
2196            !!!cp (159.1);
2197            !!!parse-error (type => 'no DOCTYPE name');
2198            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2199            $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
2200            $self->{in_subset} = 1;
2201            !!!next-input-character;
2202            !!!emit ($self->{ct}); # DOCTYPE
2203            redo A;
2204        } else {        } else {
2205          !!!cp (160);          !!!cp (160);
2206          $self->{ct}->{name} = chr $self->{nc};          $self->{ct}->{name} = chr $self->{nc};
# Line 1959  sub _get_next_token ($) { Line 2210  sub _get_next_token ($) {
2210          redo A;          redo A;
2211        }        }
2212      } elsif ($self->{state} == DOCTYPE_NAME_STATE) {      } elsif ($self->{state} == DOCTYPE_NAME_STATE) {
2213  ## ISSUE: Redundant "First," in the spec.        ## XML5: "DOCTYPE root name state".
2214    
2215          ## ISSUE: Redundant "First," in the spec.
2216    
2217        if ($is_space->{$self->{nc}}) {        if ($is_space->{$self->{nc}}) {
2218          !!!cp (161);          !!!cp (161);
2219          $self->{state} = AFTER_DOCTYPE_NAME_STATE;          $self->{state} = AFTER_DOCTYPE_NAME_STATE;
# Line 1974  sub _get_next_token ($) { Line 2228  sub _get_next_token ($) {
2228          !!!emit ($self->{ct}); # DOCTYPE          !!!emit ($self->{ct}); # DOCTYPE
2229    
2230          redo A;          redo A;
2231          } elsif (0x0041 <= $self->{nc} and $self->{nc} <= 0x005A) { # A..Z
2232            !!!cp (162.1);
2233            $self->{ct}->{name} # DOCTYPE
2234                .= chr ($self->{nc} + ($self->{is_xml} ? 0 : 0x0020));
2235            delete $self->{ct}->{quirks};
2236            ## Stay in the state.
2237            !!!next-input-character;
2238            redo A;
2239        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
2240          !!!cp (163);          !!!cp (163);
2241          !!!parse-error (type => 'unclosed DOCTYPE');          !!!parse-error (type => 'unclosed DOCTYPE');
# Line 1985  sub _get_next_token ($) { Line 2247  sub _get_next_token ($) {
2247          !!!emit ($self->{ct}); # DOCTYPE          !!!emit ($self->{ct}); # DOCTYPE
2248    
2249          redo A;          redo A;
2250          } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [
2251            !!!cp (163.1);
2252            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2253            $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
2254            $self->{in_subset} = 1;
2255            !!!next-input-character;
2256            !!!emit ($self->{ct}); # DOCTYPE
2257            redo A;
2258        } else {        } else {
2259          !!!cp (164);          !!!cp (164);
2260          $self->{ct}->{name}          $self->{ct}->{name} .= chr ($self->{nc}); # DOCTYPE
2261            .= chr ($self->{nc}); # DOCTYPE          ## Stay in the state.
         ## Stay in the state  
2262          !!!next-input-character;          !!!next-input-character;
2263          redo A;          redo A;
2264        }        }
2265      } elsif ($self->{state} == AFTER_DOCTYPE_NAME_STATE) {      } elsif ($self->{state} == AFTER_DOCTYPE_NAME_STATE) {
2266          ## XML5: Corresponding to XML5's "DOCTYPE root name after
2267          ## state", but implemented differently.
2268    
2269        if ($is_space->{$self->{nc}}) {        if ($is_space->{$self->{nc}}) {
2270          !!!cp (165);          !!!cp (165);
2271          ## Stay in the state          ## Stay in the state
2272          !!!next-input-character;          !!!next-input-character;
2273          redo A;          redo A;
2274        } elsif ($self->{nc} == 0x003E) { # >        } elsif ($self->{nc} == 0x003E) { # >
2275          !!!cp (166);          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2276          $self->{state} = DATA_STATE;            !!!cp (166);
2277          $self->{s_kwd} = '';            $self->{state} = DATA_STATE;
2278              $self->{s_kwd} = '';
2279            } else {
2280              !!!cp (166.1);
2281              !!!parse-error (type => 'no md def'); ## TODO: type
2282              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2283            }
2284            
2285          !!!next-input-character;          !!!next-input-character;
2286            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
         !!!emit ($self->{ct}); # DOCTYPE  
   
2287          redo A;          redo A;
2288        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
2289          !!!cp (167);          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2290          !!!parse-error (type => 'unclosed DOCTYPE');            !!!cp (167);
2291          $self->{state} = DATA_STATE;            !!!parse-error (type => 'unclosed DOCTYPE');
2292          $self->{s_kwd} = '';            $self->{state} = DATA_STATE;
2293          ## reconsume            $self->{s_kwd} = '';
2294              $self->{ct}->{quirks} = 1;
2295          $self->{ct}->{quirks} = 1;          } else {
2296          !!!emit ($self->{ct}); # DOCTYPE            !!!cp (167.12);
2297              !!!parse-error (type => 'unclosed md'); ## TODO: type
2298              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2299            }
2300            
2301            ## Reconsume.
2302            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
2303          redo A;          redo A;
2304        } elsif ($self->{nc} == 0x0050 or # P        } elsif ($self->{nc} == 0x0050 or # P
2305                 $self->{nc} == 0x0070) { # p                 $self->{nc} == 0x0070) { # p
2306            !!!cp (167.1);
2307          $self->{state} = PUBLIC_STATE;          $self->{state} = PUBLIC_STATE;
2308          $self->{s_kwd} = chr $self->{nc};          $self->{kwd} = chr $self->{nc};
2309          !!!next-input-character;          !!!next-input-character;
2310          redo A;          redo A;
2311        } elsif ($self->{nc} == 0x0053 or # S        } elsif ($self->{nc} == 0x0053 or # S
2312                 $self->{nc} == 0x0073) { # s                 $self->{nc} == 0x0073) { # s
2313            !!!cp (167.2);
2314          $self->{state} = SYSTEM_STATE;          $self->{state} = SYSTEM_STATE;
2315          $self->{s_kwd} = chr $self->{nc};          $self->{kwd} = chr $self->{nc};
2316          !!!next-input-character;          !!!next-input-character;
2317          redo A;          redo A;
2318          } elsif ($self->{nc} == 0x0022 and # "
2319                   ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN or
2320                    $self->{ct}->{type} == PARAMETER_ENTITY_TOKEN)) {
2321            !!!cp (167.21);
2322            $self->{state} = DOCTYPE_ENTITY_VALUE_DOUBLE_QUOTED_STATE;
2323            $self->{ct}->{value} = ''; # ENTITY
2324            !!!next-input-character;
2325            redo A;
2326          } elsif ($self->{nc} == 0x0027 and # '
2327                   ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN or
2328                    $self->{ct}->{type} == PARAMETER_ENTITY_TOKEN)) {
2329            !!!cp (167.22);
2330            $self->{state} = DOCTYPE_ENTITY_VALUE_SINGLE_QUOTED_STATE;
2331            $self->{ct}->{value} = ''; # ENTITY
2332            !!!next-input-character;
2333            redo A;
2334          } elsif ($self->{is_xml} and
2335                   $self->{ct}->{type} == DOCTYPE_TOKEN and
2336                   $self->{nc} == 0x005B) { # [
2337            !!!cp (167.3);
2338            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2339            $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
2340            $self->{in_subset} = 1;
2341            !!!next-input-character;
2342            !!!emit ($self->{ct}); # DOCTYPE
2343            redo A;
2344        } else {        } else {
2345          !!!cp (180);          !!!parse-error (type => 'string after DOCTYPE name'); ## TODO: type
2346          !!!parse-error (type => 'string after DOCTYPE name');  
2347          $self->{ct}->{quirks} = 1;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2348              !!!cp (180);
2349              $self->{ct}->{quirks} = 1;
2350              $self->{state} = BOGUS_DOCTYPE_STATE;
2351            } else {
2352              !!!cp (180.1);
2353              $self->{state} = BOGUS_MD_STATE;
2354            }
2355    
         $self->{state} = BOGUS_DOCTYPE_STATE;  
2356          !!!next-input-character;          !!!next-input-character;
2357          redo A;          redo A;
2358        }        }
# Line 2048  sub _get_next_token ($) { Line 2364  sub _get_next_token ($) {
2364              0x0042, # B              0x0042, # B
2365              0x004C, # L              0x004C, # L
2366              0x0049, # I              0x0049, # I
2367            ]->[length $self->{s_kwd}] or            ]->[length $self->{kwd}] or
2368            $self->{nc} == [            $self->{nc} == [
2369              undef,              undef,
2370              0x0075, # u              0x0075, # u
2371              0x0062, # b              0x0062, # b
2372              0x006C, # l              0x006C, # l
2373              0x0069, # i              0x0069, # i
2374            ]->[length $self->{s_kwd}]) {            ]->[length $self->{kwd}]) {
2375          !!!cp (175);          !!!cp (175);
2376          ## Stay in the state.          ## Stay in the state.
2377          $self->{s_kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
2378          !!!next-input-character;          !!!next-input-character;
2379          redo A;          redo A;
2380        } elsif ((length $self->{s_kwd}) == 5 and        } elsif ((length $self->{kwd}) == 5 and
2381                 ($self->{nc} == 0x0043 or # C                 ($self->{nc} == 0x0043 or # C
2382                  $self->{nc} == 0x0063)) { # c                  $self->{nc} == 0x0063)) { # c
2383          !!!cp (168);          if ($self->{is_xml} and
2384                ($self->{kwd} ne 'PUBLI' or $self->{nc} == 0x0063)) { # c
2385              !!!cp (168.1);
2386              !!!parse-error (type => 'lowercase keyword', ## TODO: type
2387                              text => 'PUBLIC',
2388                              line => $self->{line_prev},
2389                              column => $self->{column_prev} - 4);
2390            } else {
2391              !!!cp (168);
2392            }
2393          $self->{state} = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;          $self->{state} = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
2394          !!!next-input-character;          !!!next-input-character;
2395          redo A;          redo A;
2396        } else {        } else {
2397          !!!cp (169);          !!!parse-error (type => 'string after DOCTYPE name', ## TODO: type
         !!!parse-error (type => 'string after DOCTYPE name',  
2398                          line => $self->{line_prev},                          line => $self->{line_prev},
2399                          column => $self->{column_prev} + 1 - length $self->{s_kwd});                          column => $self->{column_prev} + 1 - length $self->{kwd});
2400          $self->{ct}->{quirks} = 1;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2401              !!!cp (169);
2402          $self->{state} = BOGUS_DOCTYPE_STATE;            $self->{ct}->{quirks} = 1;
2403              $self->{state} = BOGUS_DOCTYPE_STATE;
2404            } else {
2405              !!!cp (169.1);
2406              $self->{state} = BOGUS_MD_STATE;
2407            }
2408          ## Reconsume.          ## Reconsume.
2409          redo A;          redo A;
2410        }        }
# Line 2087  sub _get_next_token ($) { Line 2416  sub _get_next_token ($) {
2416              0x0053, # S              0x0053, # S
2417              0x0054, # T              0x0054, # T
2418              0x0045, # E              0x0045, # E
2419            ]->[length $self->{s_kwd}] or            ]->[length $self->{kwd}] or
2420            $self->{nc} == [            $self->{nc} == [
2421              undef,              undef,
2422              0x0079, # y              0x0079, # y
2423              0x0073, # s              0x0073, # s
2424              0x0074, # t              0x0074, # t
2425              0x0065, # e              0x0065, # e
2426            ]->[length $self->{s_kwd}]) {            ]->[length $self->{kwd}]) {
2427          !!!cp (170);          !!!cp (170);
2428          ## Stay in the state.          ## Stay in the state.
2429          $self->{s_kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
2430          !!!next-input-character;          !!!next-input-character;
2431          redo A;          redo A;
2432        } elsif ((length $self->{s_kwd}) == 5 and        } elsif ((length $self->{kwd}) == 5 and
2433                 ($self->{nc} == 0x004D or # M                 ($self->{nc} == 0x004D or # M
2434                  $self->{nc} == 0x006D)) { # m                  $self->{nc} == 0x006D)) { # m
2435          !!!cp (171);          if ($self->{is_xml} and
2436                ($self->{kwd} ne 'SYSTE' or $self->{nc} == 0x006D)) { # m
2437              !!!cp (171.1);
2438              !!!parse-error (type => 'lowercase keyword', ## TODO: type
2439                              text => 'SYSTEM',
2440                              line => $self->{line_prev},
2441                              column => $self->{column_prev} - 4);
2442            } else {
2443              !!!cp (171);
2444            }
2445          $self->{state} = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;          $self->{state} = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
2446          !!!next-input-character;          !!!next-input-character;
2447          redo A;          redo A;
2448        } else {        } else {
2449          !!!cp (172);          !!!parse-error (type => 'string after DOCTYPE name', ## TODO: type
         !!!parse-error (type => 'string after DOCTYPE name',  
2450                          line => $self->{line_prev},                          line => $self->{line_prev},
2451                          column => $self->{column_prev} + 1 - length $self->{s_kwd});                          column => $self->{column_prev} + 1 - length $self->{kwd});
2452          $self->{ct}->{quirks} = 1;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2453              !!!cp (172);
2454          $self->{state} = BOGUS_DOCTYPE_STATE;            $self->{ct}->{quirks} = 1;
2455              $self->{state} = BOGUS_DOCTYPE_STATE;
2456            } else {
2457              !!!cp (172.1);
2458              $self->{state} = BOGUS_MD_STATE;
2459            }
2460          ## Reconsume.          ## Reconsume.
2461          redo A;          redo A;
2462        }        }
# Line 2137  sub _get_next_token ($) { Line 2479  sub _get_next_token ($) {
2479          !!!next-input-character;          !!!next-input-character;
2480          redo A;          redo A;
2481        } elsif ($self->{nc} eq 0x003E) { # >        } elsif ($self->{nc} eq 0x003E) { # >
         !!!cp (184);  
2482          !!!parse-error (type => 'no PUBLIC literal');          !!!parse-error (type => 'no PUBLIC literal');
2483            
2484          $self->{state} = DATA_STATE;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2485          $self->{s_kwd} = '';            !!!cp (184);
2486              $self->{state} = DATA_STATE;
2487              $self->{s_kwd} = '';
2488              $self->{ct}->{quirks} = 1;
2489            } else {
2490              !!!cp (184.1);
2491              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2492            }
2493            
2494          !!!next-input-character;          !!!next-input-character;
2495            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
         $self->{ct}->{quirks} = 1;  
         !!!emit ($self->{ct}); # DOCTYPE  
   
2496          redo A;          redo A;
2497        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
2498          !!!cp (185);          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2499          !!!parse-error (type => 'unclosed DOCTYPE');            !!!cp (185);
2500              !!!parse-error (type => 'unclosed DOCTYPE');
2501          $self->{state} = DATA_STATE;            $self->{state} = DATA_STATE;
2502          $self->{s_kwd} = '';            $self->{s_kwd} = '';
2503              $self->{ct}->{quirks} = 1;
2504            } else {
2505              !!!cp (185.1);
2506              !!!parse-error (type => 'unclosed md'); ## TODO: type
2507              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2508            }
2509            
2510          ## reconsume          ## reconsume
   
         $self->{ct}->{quirks} = 1;  
2511          !!!emit ($self->{ct}); # DOCTYPE          !!!emit ($self->{ct}); # DOCTYPE
2512            redo A;
2513          } elsif ($self->{is_xml} and
2514                   $self->{ct}->{type} == DOCTYPE_TOKEN and
2515                   $self->{nc} == 0x005B) { # [
2516            !!!cp (186.1);
2517            !!!parse-error (type => 'no PUBLIC literal');
2518            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2519            $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
2520            $self->{in_subset} = 1;
2521            !!!next-input-character;
2522            !!!emit ($self->{ct}); # DOCTYPE
2523          redo A;          redo A;
2524        } else {        } else {
         !!!cp (186);  
2525          !!!parse-error (type => 'string after PUBLIC');          !!!parse-error (type => 'string after PUBLIC');
         $self->{ct}->{quirks} = 1;  
2526    
2527          $self->{state} = BOGUS_DOCTYPE_STATE;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2528              !!!cp (186);
2529              $self->{ct}->{quirks} = 1;
2530              $self->{state} = BOGUS_DOCTYPE_STATE;
2531            } else {
2532              !!!cp (186.2);
2533              $self->{state} = BOGUS_MD_STATE;
2534            }
2535    
2536          !!!next-input-character;          !!!next-input-character;
2537          redo A;          redo A;
2538        }        }
# Line 2176  sub _get_next_token ($) { Line 2543  sub _get_next_token ($) {
2543          !!!next-input-character;          !!!next-input-character;
2544          redo A;          redo A;
2545        } elsif ($self->{nc} == 0x003E) { # >        } elsif ($self->{nc} == 0x003E) { # >
         !!!cp (188);  
2546          !!!parse-error (type => 'unclosed PUBLIC literal');          !!!parse-error (type => 'unclosed PUBLIC literal');
2547    
2548          $self->{state} = DATA_STATE;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2549          $self->{s_kwd} = '';            !!!cp (188);
2550          !!!next-input-character;            $self->{state} = DATA_STATE;
2551              $self->{s_kwd} = '';
2552          $self->{ct}->{quirks} = 1;            $self->{ct}->{quirks} = 1;
2553          !!!emit ($self->{ct}); # DOCTYPE          } else {
2554              !!!cp (188.1);
2555              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2556            }
2557    
2558            !!!next-input-character;
2559            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
2560          redo A;          redo A;
2561        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
         !!!cp (189);  
2562          !!!parse-error (type => 'unclosed PUBLIC literal');          !!!parse-error (type => 'unclosed PUBLIC literal');
2563    
2564          $self->{state} = DATA_STATE;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2565          $self->{s_kwd} = '';            !!!cp (189);
2566          ## reconsume            $self->{state} = DATA_STATE;
2567              $self->{s_kwd} = '';
2568          $self->{ct}->{quirks} = 1;            $self->{ct}->{quirks} = 1;
2569            } else {
2570              !!!cp (189.1);
2571              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2572            }
2573            
2574            ## Reconsume.
2575          !!!emit ($self->{ct}); # DOCTYPE          !!!emit ($self->{ct}); # DOCTYPE
   
2576          redo A;          redo A;
2577        } else {        } else {
2578          !!!cp (190);          !!!cp (190);
2579          $self->{ct}->{pubid} # DOCTYPE          $self->{ct}->{pubid} .= chr $self->{nc}; # DOCTYPE/ENTITY/NOTATION
             .= chr $self->{nc};  
2580          $self->{read_until}->($self->{ct}->{pubid}, q[">],          $self->{read_until}->($self->{ct}->{pubid}, q[">],
2581                                length $self->{ct}->{pubid});                                length $self->{ct}->{pubid});
2582    
# Line 2217  sub _get_next_token ($) { Line 2591  sub _get_next_token ($) {
2591          !!!next-input-character;          !!!next-input-character;
2592          redo A;          redo A;
2593        } elsif ($self->{nc} == 0x003E) { # >        } elsif ($self->{nc} == 0x003E) { # >
         !!!cp (192);  
2594          !!!parse-error (type => 'unclosed PUBLIC literal');          !!!parse-error (type => 'unclosed PUBLIC literal');
2595    
2596          $self->{state} = DATA_STATE;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2597          $self->{s_kwd} = '';            !!!cp (192);
2598          !!!next-input-character;            $self->{state} = DATA_STATE;
2599              $self->{s_kwd} = '';
2600          $self->{ct}->{quirks} = 1;            $self->{ct}->{quirks} = 1;
2601          !!!emit ($self->{ct}); # DOCTYPE          } else {
2602              !!!cp (192.1);
2603              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2604            }
2605    
2606            !!!next-input-character;
2607            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
2608          redo A;          redo A;
2609        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
         !!!cp (193);  
2610          !!!parse-error (type => 'unclosed PUBLIC literal');          !!!parse-error (type => 'unclosed PUBLIC literal');
2611    
2612          $self->{state} = DATA_STATE;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2613          $self->{s_kwd} = '';            !!!cp (193);
2614              $self->{state} = DATA_STATE;
2615              $self->{s_kwd} = '';
2616              $self->{ct}->{quirks} = 1;
2617            } else {
2618              !!!cp (193.1);
2619              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2620            }
2621          
2622          ## reconsume          ## reconsume
2623            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
         $self->{ct}->{quirks} = 1;  
         !!!emit ($self->{ct}); # DOCTYPE  
   
2624          redo A;          redo A;
2625        } else {        } else {
2626          !!!cp (194);          !!!cp (194);
2627          $self->{ct}->{pubid} # DOCTYPE          $self->{ct}->{pubid} .= chr $self->{nc}; # DOCTYPE/ENTITY/NOTATION
             .= chr $self->{nc};  
2628          $self->{read_until}->($self->{ct}->{pubid}, q['>],          $self->{read_until}->($self->{ct}->{pubid}, q['>],
2629                                length $self->{ct}->{pubid});                                length $self->{ct}->{pubid});
2630    
# Line 2259  sub _get_next_token ($) { Line 2640  sub _get_next_token ($) {
2640          redo A;          redo A;
2641        } elsif ($self->{nc} == 0x0022) { # "        } elsif ($self->{nc} == 0x0022) { # "
2642          !!!cp (196);          !!!cp (196);
2643          $self->{ct}->{sysid} = ''; # DOCTYPE          $self->{ct}->{sysid} = ''; # DOCTYPE/ENTITY/NOTATION
2644          $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;          $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;
2645          !!!next-input-character;          !!!next-input-character;
2646          redo A;          redo A;
2647        } elsif ($self->{nc} == 0x0027) { # '        } elsif ($self->{nc} == 0x0027) { # '
2648          !!!cp (197);          !!!cp (197);
2649          $self->{ct}->{sysid} = ''; # DOCTYPE          $self->{ct}->{sysid} = ''; # DOCTYPE/ENTITY/NOTATION
2650          $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;          $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;
2651          !!!next-input-character;          !!!next-input-character;
2652          redo A;          redo A;
2653        } elsif ($self->{nc} == 0x003E) { # >        } elsif ($self->{nc} == 0x003E) { # >
2654          !!!cp (198);          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2655          $self->{state} = DATA_STATE;            if ($self->{is_xml}) {
2656          $self->{s_kwd} = '';              !!!cp (198.1);
2657                !!!parse-error (type => 'no SYSTEM literal');
2658              } else {
2659                !!!cp (198);
2660              }
2661              $self->{state} = DATA_STATE;
2662              $self->{s_kwd} = '';
2663            } else {
2664              if ($self->{ct}->{type} == NOTATION_TOKEN) {
2665                !!!cp (198.2);
2666              } else {
2667                !!!cp (198.3);
2668                !!!parse-error (type => 'no SYSTEM literal');            
2669              }
2670              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2671            }
2672            
2673          !!!next-input-character;          !!!next-input-character;
2674            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
         !!!emit ($self->{ct}); # DOCTYPE  
   
2675          redo A;          redo A;
2676        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
2677          !!!cp (199);          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2678          !!!parse-error (type => 'unclosed DOCTYPE');            !!!cp (199);
2679              !!!parse-error (type => 'unclosed DOCTYPE');
2680          $self->{state} = DATA_STATE;            
2681          $self->{s_kwd} = '';            $self->{state} = DATA_STATE;
2682              $self->{s_kwd} = '';
2683              $self->{ct}->{quirks} = 1;
2684            } else {
2685              !!!parse-error (type => 'unclosed md'); ## TODO: type
2686              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2687            }
2688            
2689          ## reconsume          ## reconsume
2690            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
2691          $self->{ct}->{quirks} = 1;          redo A;
2692          } elsif ($self->{is_xml} and
2693                   $self->{ct}->{type} == DOCTYPE_TOKEN and
2694                   $self->{nc} == 0x005B) { # [
2695            !!!cp (200.1);
2696            !!!parse-error (type => 'no SYSTEM literal');
2697            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2698            $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
2699            $self->{in_subset} = 1;
2700            !!!next-input-character;
2701          !!!emit ($self->{ct}); # DOCTYPE          !!!emit ($self->{ct}); # DOCTYPE
   
2702          redo A;          redo A;
2703        } else {        } else {
         !!!cp (200);  
2704          !!!parse-error (type => 'string after PUBLIC literal');          !!!parse-error (type => 'string after PUBLIC literal');
         $self->{ct}->{quirks} = 1;  
2705    
2706          $self->{state} = BOGUS_DOCTYPE_STATE;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2707              !!!cp (200);
2708              $self->{ct}->{quirks} = 1;
2709              $self->{state} = BOGUS_DOCTYPE_STATE;
2710            } else {
2711              !!!cp (200.2);
2712              $self->{state} = BOGUS_MD_STATE;
2713            }
2714    
2715          !!!next-input-character;          !!!next-input-character;
2716          redo A;          redo A;
2717        }        }
# Line 2318  sub _get_next_token ($) { Line 2734  sub _get_next_token ($) {
2734          !!!next-input-character;          !!!next-input-character;
2735          redo A;          redo A;
2736        } elsif ($self->{nc} == 0x003E) { # >        } elsif ($self->{nc} == 0x003E) { # >
         !!!cp (204);  
2737          !!!parse-error (type => 'no SYSTEM literal');          !!!parse-error (type => 'no SYSTEM literal');
         $self->{state} = DATA_STATE;  
         $self->{s_kwd} = '';  
2738          !!!next-input-character;          !!!next-input-character;
2739    
2740          $self->{ct}->{quirks} = 1;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2741          !!!emit ($self->{ct}); # DOCTYPE            !!!cp (204);
2742              $self->{state} = DATA_STATE;
2743              $self->{s_kwd} = '';
2744              $self->{ct}->{quirks} = 1;
2745            } else {
2746              !!!cp (204.1);
2747              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2748            }
2749    
2750            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
2751          redo A;          redo A;
2752        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
2753          !!!cp (205);          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2754          !!!parse-error (type => 'unclosed DOCTYPE');            !!!cp (205);
2755              !!!parse-error (type => 'unclosed DOCTYPE');
2756          $self->{state} = DATA_STATE;            $self->{state} = DATA_STATE;
2757          $self->{s_kwd} = '';            $self->{s_kwd} = '';
2758              $self->{ct}->{quirks} = 1;
2759            } else {
2760              !!!cp (205.1);
2761              !!!parse-error (type => 'unclosed md'); ## TODO: type
2762              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2763            }
2764            
2765          ## reconsume          ## reconsume
2766            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
2767            redo A;
2768          } elsif ($self->{is_xml} and
2769                   $self->{ct}->{type} == DOCTYPE_TOKEN and
2770                   $self->{nc} == 0x005B) { # [
2771            !!!cp (206.1);
2772            !!!parse-error (type => 'no SYSTEM literal');
2773    
2774          $self->{ct}->{quirks} = 1;          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2775            $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
2776            $self->{in_subset} = 1;
2777            !!!next-input-character;
2778          !!!emit ($self->{ct}); # DOCTYPE          !!!emit ($self->{ct}); # DOCTYPE
   
2779          redo A;          redo A;
2780        } else {        } else {
         !!!cp (206);  
2781          !!!parse-error (type => 'string after SYSTEM');          !!!parse-error (type => 'string after SYSTEM');
         $self->{ct}->{quirks} = 1;  
2782    
2783          $self->{state} = BOGUS_DOCTYPE_STATE;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2784              !!!cp (206);          
2785              $self->{ct}->{quirks} = 1;
2786              $self->{state} = BOGUS_DOCTYPE_STATE;
2787            } else {
2788              !!!cp (206.2);
2789              $self->{state} = BOGUS_MD_STATE;
2790            }
2791    
2792          !!!next-input-character;          !!!next-input-character;
2793          redo A;          redo A;
2794        }        }
# Line 2355  sub _get_next_token ($) { Line 2798  sub _get_next_token ($) {
2798          $self->{state} = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;          $self->{state} = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
2799          !!!next-input-character;          !!!next-input-character;
2800          redo A;          redo A;
2801        } elsif ($self->{nc} == 0x003E) { # >        } elsif (not $self->{is_xml} and $self->{nc} == 0x003E) { # >
         !!!cp (208);  
2802          !!!parse-error (type => 'unclosed SYSTEM literal');          !!!parse-error (type => 'unclosed SYSTEM literal');
2803    
2804          $self->{state} = DATA_STATE;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2805          $self->{s_kwd} = '';            !!!cp (208);
2806              $self->{state} = DATA_STATE;
2807              $self->{s_kwd} = '';
2808              $self->{ct}->{quirks} = 1;
2809            } else {
2810              !!!cp (208.1);
2811              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2812            }
2813            
2814          !!!next-input-character;          !!!next-input-character;
2815            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
         $self->{ct}->{quirks} = 1;  
         !!!emit ($self->{ct}); # DOCTYPE  
   
2816          redo A;          redo A;
2817        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
         !!!cp (209);  
2818          !!!parse-error (type => 'unclosed SYSTEM literal');          !!!parse-error (type => 'unclosed SYSTEM literal');
2819    
2820          $self->{state} = DATA_STATE;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2821          $self->{s_kwd} = '';            !!!cp (209);
2822              $self->{state} = DATA_STATE;
2823              $self->{s_kwd} = '';
2824              $self->{ct}->{quirks} = 1;
2825            } else {
2826              !!!cp (209.1);
2827              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2828            }
2829            
2830          ## reconsume          ## reconsume
2831            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
         $self->{ct}->{quirks} = 1;  
         !!!emit ($self->{ct}); # DOCTYPE  
   
2832          redo A;          redo A;
2833        } else {        } else {
2834          !!!cp (210);          !!!cp (210);
2835          $self->{ct}->{sysid} # DOCTYPE          $self->{ct}->{sysid} .= chr $self->{nc}; # DOCTYPE/ENTITY/NOTATION
             .= chr $self->{nc};  
2836          $self->{read_until}->($self->{ct}->{sysid}, q[">],          $self->{read_until}->($self->{ct}->{sysid}, q[">],
2837                                length $self->{ct}->{sysid});                                length $self->{ct}->{sysid});
2838    
# Line 2396  sub _get_next_token ($) { Line 2846  sub _get_next_token ($) {
2846          $self->{state} = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;          $self->{state} = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
2847          !!!next-input-character;          !!!next-input-character;
2848          redo A;          redo A;
2849        } elsif ($self->{nc} == 0x003E) { # >        } elsif (not $self->{is_xml} and $self->{nc} == 0x003E) { # >
2850          !!!cp (212);          !!!cp (212);
2851          !!!parse-error (type => 'unclosed SYSTEM literal');          !!!parse-error (type => 'unclosed SYSTEM literal');
2852    
# Line 2409  sub _get_next_token ($) { Line 2859  sub _get_next_token ($) {
2859    
2860          redo A;          redo A;
2861        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
         !!!cp (213);  
2862          !!!parse-error (type => 'unclosed SYSTEM literal');          !!!parse-error (type => 'unclosed SYSTEM literal');
2863    
2864          $self->{state} = DATA_STATE;          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2865          $self->{s_kwd} = '';            !!!cp (213);
2866          ## reconsume            $self->{state} = DATA_STATE;
2867              $self->{s_kwd} = '';
2868          $self->{ct}->{quirks} = 1;            $self->{ct}->{quirks} = 1;
2869          !!!emit ($self->{ct}); # DOCTYPE          } else {
2870              !!!cp (213.1);
2871              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2872            }
2873    
2874            ## reconsume
2875            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
2876          redo A;          redo A;
2877        } else {        } else {
2878          !!!cp (214);          !!!cp (214);
2879          $self->{ct}->{sysid} # DOCTYPE          $self->{ct}->{sysid} .= chr $self->{nc}; # DOCTYPE/ENTITY/NOTATION
             .= chr $self->{nc};  
2880          $self->{read_until}->($self->{ct}->{sysid}, q['>],          $self->{read_until}->($self->{ct}->{sysid}, q['>],
2881                                length $self->{ct}->{sysid});                                length $self->{ct}->{sysid});
2882    
# Line 2433  sub _get_next_token ($) { Line 2886  sub _get_next_token ($) {
2886        }        }
2887      } elsif ($self->{state} == AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {      } elsif ($self->{state} == AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {
2888        if ($is_space->{$self->{nc}}) {        if ($is_space->{$self->{nc}}) {
2889          !!!cp (215);          if ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN) {
2890          ## Stay in the state            !!!cp (215.1);
2891              $self->{state} = BEFORE_NDATA_STATE;
2892            } else {
2893              !!!cp (215);
2894              ## Stay in the state
2895            }
2896          !!!next-input-character;          !!!next-input-character;
2897          redo A;          redo A;
2898        } elsif ($self->{nc} == 0x003E) { # >        } elsif ($self->{nc} == 0x003E) { # >
2899          !!!cp (216);          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2900          $self->{state} = DATA_STATE;            !!!cp (216);
2901          $self->{s_kwd} = '';            $self->{state} = DATA_STATE;
2902              $self->{s_kwd} = '';
2903            } else {
2904              !!!cp (216.1);
2905              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2906            }
2907    
2908            !!!next-input-character;
2909            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
2910            redo A;
2911          } elsif ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN and
2912                   ($self->{nc} == 0x004E or # N
2913                    $self->{nc} == 0x006E)) { # n
2914            !!!cp (216.2);
2915            !!!parse-error (type => 'no space before NDATA'); ## TODO: type
2916            $self->{state} = NDATA_STATE;
2917            $self->{kwd} = chr $self->{nc};
2918          !!!next-input-character;          !!!next-input-character;
2919            redo A;
2920          } elsif ($self->{nc} == -1) {
2921            if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2922              !!!cp (217);
2923              !!!parse-error (type => 'unclosed DOCTYPE');
2924              $self->{state} = DATA_STATE;
2925              $self->{s_kwd} = '';
2926              $self->{ct}->{quirks} = 1;
2927            } else {
2928              !!!cp (217.1);
2929              !!!parse-error (type => 'unclosed md'); ## TODO: type
2930              $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2931            }
2932    
2933            ## reconsume
2934            !!!emit ($self->{ct}); # DOCTYPE/ENTITY/NOTATION
2935            redo A;
2936          } elsif ($self->{is_xml} and
2937                   $self->{ct}->{type} == DOCTYPE_TOKEN and
2938                   $self->{nc} == 0x005B) { # [
2939            !!!cp (218.1);
2940            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2941            $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
2942            $self->{in_subset} = 1;
2943            !!!next-input-character;
2944          !!!emit ($self->{ct}); # DOCTYPE          !!!emit ($self->{ct}); # DOCTYPE
2945            redo A;
2946          } else {
2947            !!!parse-error (type => 'string after SYSTEM literal');
2948    
2949            if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2950              !!!cp (218);
2951              #$self->{ct}->{quirks} = 1;
2952              $self->{state} = BOGUS_DOCTYPE_STATE;
2953            } else {
2954              !!!cp (218.2);
2955              $self->{state} = BOGUS_MD_STATE;
2956            }
2957    
2958            !!!next-input-character;
2959            redo A;
2960          }
2961        } elsif ($self->{state} == BEFORE_NDATA_STATE) {
2962          if ($is_space->{$self->{nc}}) {
2963            !!!cp (218.3);
2964            ## Stay in the state.
2965            !!!next-input-character;
2966            redo A;
2967          } elsif ($self->{nc} == 0x003E) { # >
2968            !!!cp (218.4);
2969            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2970            !!!next-input-character;
2971            !!!emit ($self->{ct}); # ENTITY
2972            redo A;
2973          } elsif ($self->{nc} == 0x004E or # N
2974                   $self->{nc} == 0x006E) { # n
2975            !!!cp (218.5);
2976            $self->{state} = NDATA_STATE;
2977            $self->{kwd} = chr $self->{nc};
2978            !!!next-input-character;
2979          redo A;          redo A;
2980        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
2981          !!!cp (217);          !!!cp (218.6);
2982          !!!parse-error (type => 'unclosed DOCTYPE');          !!!parse-error (type => 'unclosed md'); ## TODO: type
2983          $self->{state} = DATA_STATE;          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
         $self->{s_kwd} = '';  
2984          ## reconsume          ## reconsume
2985            !!!emit ($self->{ct}); # ENTITY
         $self->{ct}->{quirks} = 1;  
         !!!emit ($self->{ct}); # DOCTYPE  
   
2986          redo A;          redo A;
2987        } else {        } else {
2988          !!!cp (218);          !!!cp (218.7);
2989          !!!parse-error (type => 'string after SYSTEM literal');          !!!parse-error (type => 'string after SYSTEM literal');
2990          #$self->{ct}->{quirks} = 1;          $self->{state} = BOGUS_MD_STATE;
   
         $self->{state} = BOGUS_DOCTYPE_STATE;  
2991          !!!next-input-character;          !!!next-input-character;
2992          redo A;          redo A;
2993        }        }
# Line 2476  sub _get_next_token ($) { Line 3001  sub _get_next_token ($) {
3001          !!!emit ($self->{ct}); # DOCTYPE          !!!emit ($self->{ct}); # DOCTYPE
3002    
3003          redo A;          redo A;
3004          } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [
3005            !!!cp (220.1);
3006            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
3007            $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
3008            $self->{in_subset} = 1;
3009            !!!next-input-character;
3010            !!!emit ($self->{ct}); # DOCTYPE
3011            redo A;
3012        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
3013          !!!cp (220);          !!!cp (220);
3014          $self->{state} = DATA_STATE;          $self->{state} = DATA_STATE;
# Line 2488  sub _get_next_token ($) { Line 3021  sub _get_next_token ($) {
3021        } else {        } else {
3022          !!!cp (221);          !!!cp (221);
3023          my $s = '';          my $s = '';
3024          $self->{read_until}->($s, q[>], 0);          $self->{read_until}->($s, q{>[}, 0);
3025    
3026          ## Stay in the state          ## Stay in the state
3027          !!!next-input-character;          !!!next-input-character;
# Line 2588  sub _get_next_token ($) { Line 3121  sub _get_next_token ($) {
3121              0x003C => 1, 0x0026 => 1, -1 => 1, # <, &              0x003C => 1, 0x0026 => 1, -1 => 1, # <, &
3122              $self->{entity_add} => 1,              $self->{entity_add} => 1,
3123            }->{$self->{nc}}) {            }->{$self->{nc}}) {
3124          !!!cp (1001);          if ($self->{is_xml}) {
3125              !!!cp (1001.1);
3126              !!!parse-error (type => 'bare ero',
3127                              line => $self->{line_prev},
3128                              column => $self->{column_prev}
3129                                  + ($self->{nc} == -1 ? 1 : 0));
3130            } else {
3131              !!!cp (1001);
3132              ## No error
3133            }
3134          ## Don't consume          ## Don't consume
         ## No error  
3135          ## Return nothing.          ## Return nothing.
3136          #          #
3137        } elsif ($self->{nc} == 0x0023) { # #        } elsif ($self->{nc} == 0x0023) { # #
3138          !!!cp (999);          !!!cp (999);
3139          $self->{state} = ENTITY_HASH_STATE;          $self->{state} = ENTITY_HASH_STATE;
3140          $self->{s_kwd} = '#';          $self->{kwd} = '#';
3141          !!!next-input-character;          !!!next-input-character;
3142          redo A;          redo A;
3143        } elsif ((0x0041 <= $self->{nc} and        } elsif ($self->{is_xml} or
3144                   (0x0041 <= $self->{nc} and
3145                  $self->{nc} <= 0x005A) or # A..Z                  $self->{nc} <= 0x005A) or # A..Z
3146                 (0x0061 <= $self->{nc} and                 (0x0061 <= $self->{nc} and
3147                  $self->{nc} <= 0x007A)) { # a..z                  $self->{nc} <= 0x007A)) { # a..z
3148          !!!cp (998);          !!!cp (998);
3149          require Whatpm::_NamedEntityList;          require Whatpm::_NamedEntityList;
3150          $self->{state} = ENTITY_NAME_STATE;          $self->{state} = ENTITY_NAME_STATE;
3151          $self->{s_kwd} = chr $self->{nc};          $self->{kwd} = chr $self->{nc};
3152          $self->{entity__value} = $self->{s_kwd};          $self->{entity__value} = $self->{kwd};
3153          $self->{entity__match} = 0;          $self->{entity__match} = 0;
3154          !!!next-input-character;          !!!next-input-character;
3155          redo A;          redo A;
# Line 2643  sub _get_next_token ($) { Line 3185  sub _get_next_token ($) {
3185          redo A;          redo A;
3186        }        }
3187      } elsif ($self->{state} == ENTITY_HASH_STATE) {      } elsif ($self->{state} == ENTITY_HASH_STATE) {
3188        if ($self->{nc} == 0x0078 or # x        if ($self->{nc} == 0x0078) { # x
           $self->{nc} == 0x0058) { # X  
3189          !!!cp (995);          !!!cp (995);
3190          $self->{state} = HEXREF_X_STATE;          $self->{state} = HEXREF_X_STATE;
3191          $self->{s_kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
3192            !!!next-input-character;
3193            redo A;
3194          } elsif ($self->{nc} == 0x0058) { # X
3195            !!!cp (995.1);
3196            if ($self->{is_xml}) {
3197              !!!parse-error (type => 'uppercase hcro'); ## TODO: type
3198            }
3199            $self->{state} = HEXREF_X_STATE;
3200            $self->{kwd} .= chr $self->{nc};
3201          !!!next-input-character;          !!!next-input-character;
3202          redo A;          redo A;
3203        } elsif (0x0030 <= $self->{nc} and        } elsif (0x0030 <= $self->{nc} and
3204                 $self->{nc} <= 0x0039) { # 0..9                 $self->{nc} <= 0x0039) { # 0..9
3205          !!!cp (994);          !!!cp (994);
3206          $self->{state} = NCR_NUM_STATE;          $self->{state} = NCR_NUM_STATE;
3207          $self->{s_kwd} = $self->{nc} - 0x0030;          $self->{kwd} = $self->{nc} - 0x0030;
3208          !!!next-input-character;          !!!next-input-character;
3209          redo A;          redo A;
3210        } else {        } else {
# Line 2690  sub _get_next_token ($) { Line 3240  sub _get_next_token ($) {
3240        if (0x0030 <= $self->{nc} and        if (0x0030 <= $self->{nc} and
3241            $self->{nc} <= 0x0039) { # 0..9            $self->{nc} <= 0x0039) { # 0..9
3242          !!!cp (1012);          !!!cp (1012);
3243          $self->{s_kwd} *= 10;          $self->{kwd} *= 10;
3244          $self->{s_kwd} += $self->{nc} - 0x0030;          $self->{kwd} += $self->{nc} - 0x0030;
3245                    
3246          ## Stay in the state.          ## Stay in the state.
3247          !!!next-input-character;          !!!next-input-character;
# Line 2707  sub _get_next_token ($) { Line 3257  sub _get_next_token ($) {
3257          #          #
3258        }        }
3259    
3260        my $code = $self->{s_kwd};        my $code = $self->{kwd};
3261        my $l = $self->{line_prev};        my $l = $self->{line_prev};
3262        my $c = $self->{column_prev};        my $c = $self->{column_prev};
3263        if ($charref_map->{$code}) {        if ((not $self->{is_xml} and $charref_map->{$code}) or
3264              ($self->{is_xml} and 0xD800 <= $code and $code <= 0xDFFF) or
3265              ($self->{is_xml} and $code == 0x0000)) {
3266          !!!cp (1015);          !!!cp (1015);
3267          !!!parse-error (type => 'invalid character reference',          !!!parse-error (type => 'invalid character reference',
3268                          text => (sprintf 'U+%04X', $code),                          text => (sprintf 'U+%04X', $code),
# Line 2750  sub _get_next_token ($) { Line 3302  sub _get_next_token ($) {
3302          # 0..9, A..F, a..f          # 0..9, A..F, a..f
3303          !!!cp (990);          !!!cp (990);
3304          $self->{state} = HEXREF_HEX_STATE;          $self->{state} = HEXREF_HEX_STATE;
3305          $self->{s_kwd} = 0;          $self->{kwd} = 0;
3306          ## Reconsume.          ## Reconsume.
3307          redo A;          redo A;
3308        } else {        } else {
# Line 2768  sub _get_next_token ($) { Line 3320  sub _get_next_token ($) {
3320            $self->{s_kwd} = '';            $self->{s_kwd} = '';
3321            ## Reconsume.            ## Reconsume.
3322            !!!emit ({type => CHARACTER_TOKEN,            !!!emit ({type => CHARACTER_TOKEN,
3323                      data => '&' . $self->{s_kwd},                      data => '&' . $self->{kwd},
3324                      line => $self->{line_prev},                      line => $self->{line_prev},
3325                      column => $self->{column_prev} - length $self->{s_kwd},                      column => $self->{column_prev} - length $self->{kwd},
3326                     });                     });
3327            redo A;            redo A;
3328          } else {          } else {
3329            !!!cp (989);            !!!cp (989);
3330            $self->{ca}->{value} .= '&' . $self->{s_kwd};            $self->{ca}->{value} .= '&' . $self->{kwd};
3331            $self->{state} = $self->{prev_state};            $self->{state} = $self->{prev_state};
3332            $self->{s_kwd} = '';            $self->{s_kwd} = '';
3333            ## Reconsume.            ## Reconsume.
# Line 2786  sub _get_next_token ($) { Line 3338  sub _get_next_token ($) {
3338        if (0x0030 <= $self->{nc} and $self->{nc} <= 0x0039) {        if (0x0030 <= $self->{nc} and $self->{nc} <= 0x0039) {
3339          # 0..9          # 0..9
3340          !!!cp (1002);          !!!cp (1002);
3341          $self->{s_kwd} *= 0x10;          $self->{kwd} *= 0x10;
3342          $self->{s_kwd} += $self->{nc} - 0x0030;          $self->{kwd} += $self->{nc} - 0x0030;
3343          ## Stay in the state.          ## Stay in the state.
3344          !!!next-input-character;          !!!next-input-character;
3345          redo A;          redo A;
3346        } elsif (0x0061 <= $self->{nc} and        } elsif (0x0061 <= $self->{nc} and
3347                 $self->{nc} <= 0x0066) { # a..f                 $self->{nc} <= 0x0066) { # a..f
3348          !!!cp (1003);          !!!cp (1003);
3349          $self->{s_kwd} *= 0x10;          $self->{kwd} *= 0x10;
3350          $self->{s_kwd} += $self->{nc} - 0x0060 + 9;          $self->{kwd} += $self->{nc} - 0x0060 + 9;
3351          ## Stay in the state.          ## Stay in the state.
3352          !!!next-input-character;          !!!next-input-character;
3353          redo A;          redo A;
3354        } elsif (0x0041 <= $self->{nc} and        } elsif (0x0041 <= $self->{nc} and
3355                 $self->{nc} <= 0x0046) { # A..F                 $self->{nc} <= 0x0046) { # A..F
3356          !!!cp (1004);          !!!cp (1004);
3357          $self->{s_kwd} *= 0x10;          $self->{kwd} *= 0x10;
3358          $self->{s_kwd} += $self->{nc} - 0x0040 + 9;          $self->{kwd} += $self->{nc} - 0x0040 + 9;
3359          ## Stay in the state.          ## Stay in the state.
3360          !!!next-input-character;          !!!next-input-character;
3361          redo A;          redo A;
# Line 2820  sub _get_next_token ($) { Line 3372  sub _get_next_token ($) {
3372          #          #
3373        }        }
3374    
3375        my $code = $self->{s_kwd};        my $code = $self->{kwd};
3376        my $l = $self->{line_prev};        my $l = $self->{line_prev};
3377        my $c = $self->{column_prev};        my $c = $self->{column_prev};
3378        if ($charref_map->{$code}) {        if ((not $self->{is_xml} and $charref_map->{$code}) or
3379              ($self->{is_xml} and 0xD800 <= $code and $code <= 0xDFFF) or
3380              ($self->{is_xml} and $code == 0x0000)) {
3381          !!!cp (1008);          !!!cp (1008);
3382          !!!parse-error (type => 'invalid character reference',          !!!parse-error (type => 'invalid character reference',
3383                          text => (sprintf 'U+%04X', $code),                          text => (sprintf 'U+%04X', $code),
# Line 2857  sub _get_next_token ($) { Line 3411  sub _get_next_token ($) {
3411          redo A;          redo A;
3412        }        }
3413      } elsif ($self->{state} == ENTITY_NAME_STATE) {      } elsif ($self->{state} == ENTITY_NAME_STATE) {
3414        if (length $self->{s_kwd} < 30 and        if ((0x0041 <= $self->{nc} and # a
3415            ## NOTE: Some number greater than the maximum length of entity name             $self->{nc} <= 0x005A) or # x
3416            ((0x0041 <= $self->{nc} and # a            (0x0061 <= $self->{nc} and # a
3417              $self->{nc} <= 0x005A) or # x             $self->{nc} <= 0x007A) or # z
3418             (0x0061 <= $self->{nc} and # a            (0x0030 <= $self->{nc} and # 0
3419              $self->{nc} <= 0x007A) or # z             $self->{nc} <= 0x0039) or # 9
3420             (0x0030 <= $self->{nc} and # 0            $self->{nc} == 0x003B or # ;
3421              $self->{nc} <= 0x0039) or # 9            ($self->{is_xml} and
3422             $self->{nc} == 0x003B)) { # ;             not ($is_space->{$self->{nc}} or
3423                    {
3424                      0x003C => 1, 0x0026 => 1, -1 => 1, # <, &
3425                      $self->{entity_add} => 1,
3426                    }->{$self->{nc}}))) {
3427          our $EntityChar;          our $EntityChar;
3428          $self->{s_kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
3429          if (defined $EntityChar->{$self->{s_kwd}}) {          if (defined $EntityChar->{$self->{kwd}} or
3430                $self->{ge}->{$self->{kwd}}) {
3431            if ($self->{nc} == 0x003B) { # ;            if ($self->{nc} == 0x003B) { # ;
3432              !!!cp (1020);              if (defined $self->{ge}->{$self->{kwd}}) {
3433              $self->{entity__value} = $EntityChar->{$self->{s_kwd}};                if ($self->{ge}->{$self->{kwd}}->{only_text}) {
3434                    !!!cp (1020.1);
3435                    $self->{entity__value} = $self->{ge}->{$self->{kwd}}->{value};
3436                  } else {
3437                    if (defined $self->{ge}->{$self->{kwd}}->{notation}) {
3438                      !!!cp (1020.2);
3439                      !!!parse-error (type => 'unparsed entity', ## TODO: type
3440                                      value => $self->{kwd});
3441                    } else {
3442                      !!!cp (1020.3);
3443                    }
3444                    $self->{entity__value} = '&' . $self->{kwd}; ## TODO: expand
3445                  }
3446                } else {
3447                  if ($self->{is_xml}) {
3448                    !!!cp (1020.4);
3449                    !!!parse-error (type => 'entity not declared', ## TODO: type
3450                                    value => $self->{kwd},
3451                                    level => {
3452                                              'amp;' => $self->{level}->{warn},
3453                                              'quot;' => $self->{level}->{warn},
3454                                              'lt;' => $self->{level}->{warn},
3455                                              'gt;' => $self->{level}->{warn},
3456                                              'apos;' => $self->{level}->{warn},
3457                                             }->{$self->{kwd}} ||
3458                                             $self->{level}->{must});
3459                  } else {
3460                    !!!cp (1020);
3461                  }
3462                  $self->{entity__value} = $EntityChar->{$self->{kwd}};
3463                }
3464              $self->{entity__match} = 1;              $self->{entity__match} = 1;
3465              !!!next-input-character;              !!!next-input-character;
3466              #              #
3467            } else {            } else {
3468              !!!cp (1021);              !!!cp (1021);
3469              $self->{entity__value} = $EntityChar->{$self->{s_kwd}};              $self->{entity__value} = $EntityChar->{$self->{kwd}};
3470              $self->{entity__match} = -1;              $self->{entity__match} = -1;
3471              ## Stay in the state.              ## Stay in the state.
3472              !!!next-input-character;              !!!next-input-character;
# Line 2905  sub _get_next_token ($) { Line 3494  sub _get_next_token ($) {
3494          if ($self->{prev_state} != DATA_STATE and # in attribute          if ($self->{prev_state} != DATA_STATE and # in attribute
3495              $self->{entity__match} < -1) {              $self->{entity__match} < -1) {
3496            !!!cp (1024);            !!!cp (1024);
3497            $data = '&' . $self->{s_kwd};            $data = '&' . $self->{kwd};
3498            #            #
3499          } else {          } else {
3500            !!!cp (1025);            !!!cp (1025);
# Line 2917  sub _get_next_token ($) { Line 3506  sub _get_next_token ($) {
3506          !!!cp (1026);          !!!cp (1026);
3507          !!!parse-error (type => 'bare ero',          !!!parse-error (type => 'bare ero',
3508                          line => $self->{line_prev},                          line => $self->{line_prev},
3509                          column => $self->{column_prev} - length $self->{s_kwd});                          column => $self->{column_prev} - length $self->{kwd});
3510          $data = '&' . $self->{s_kwd};          $data = '&' . $self->{kwd};
3511          #          #
3512        }        }
3513        
# Line 2941  sub _get_next_token ($) { Line 3530  sub _get_next_token ($) {
3530                    data => $data,                    data => $data,
3531                    has_reference => $has_ref,                    has_reference => $has_ref,
3532                    line => $self->{line_prev},                    line => $self->{line_prev},
3533                    column => $self->{column_prev} + 1 - length $self->{s_kwd},                    column => $self->{column_prev} + 1 - length $self->{kwd},
3534                   });                   });
3535          redo A;          redo A;
3536        } else {        } else {
# Line 2957  sub _get_next_token ($) { Line 3546  sub _get_next_token ($) {
3546      ## XML-only states      ## XML-only states
3547    
3548      } elsif ($self->{state} == PI_STATE) {      } elsif ($self->{state} == PI_STATE) {
3549          ## XML5: "Pi state" and "DOCTYPE pi state".
3550    
3551        if ($is_space->{$self->{nc}} or        if ($is_space->{$self->{nc}} or
3552            $self->{nc} == 0x003F or # ? ## XML5: Same as "Anything else"            $self->{nc} == 0x003F or # ?
3553            $self->{nc} == -1) {            $self->{nc} == -1) {
3554            ## XML5: U+003F: "pi state": Same as "Anything else"; "DOCTYPE
3555            ## pi state": Switch to the "DOCTYPE pi after state".  EOF:
3556            ## "DOCTYPE pi state": Parse error, switch to the "data
3557            ## state".
3558          !!!parse-error (type => 'bare pio', ## TODO: type          !!!parse-error (type => 'bare pio', ## TODO: type
3559                          line => $self->{line_prev},                          line => $self->{line_prev},
3560                          column => $self->{column_prev}                          column => $self->{column_prev}
# Line 2974  sub _get_next_token ($) { Line 3569  sub _get_next_token ($) {
3569                        };                        };
3570          redo A;          redo A;
3571        } else {        } else {
3572            ## XML5: "DOCTYPE pi state": Stay in the state.
3573          $self->{ct} = {type => PI_TOKEN,          $self->{ct} = {type => PI_TOKEN,
3574                         target => chr $self->{nc},                         target => chr $self->{nc},
3575                         data => '',                         data => '',
# Line 2991  sub _get_next_token ($) { Line 3587  sub _get_next_token ($) {
3587          redo A;          redo A;
3588        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
3589          !!!parse-error (type => 'no pic'); ## TODO: type          !!!parse-error (type => 'no pic'); ## TODO: type
3590          $self->{state} = DATA_STATE;          if ($self->{in_subset}) {
3591          $self->{s_kwd} = '';            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
3592            } else {
3593              $self->{state} = DATA_STATE;
3594              $self->{s_kwd} = '';
3595            }
3596          ## Reconsume.          ## Reconsume.
3597          !!!emit ($self->{ct}); # pi          !!!emit ($self->{ct}); # pi
3598          redo A;          redo A;
# Line 3023  sub _get_next_token ($) { Line 3623  sub _get_next_token ($) {
3623          redo A;          redo A;
3624        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
3625          !!!parse-error (type => 'no pic'); ## TODO: type          !!!parse-error (type => 'no pic'); ## TODO: type
3626          $self->{state} = DATA_STATE;          if ($self->{in_subset}) {
3627          $self->{s_kwd} = '';            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state"
3628            } else {
3629              $self->{state} = DATA_STATE;
3630              $self->{s_kwd} = '';
3631            }
3632          ## Reprocess.          ## Reprocess.
3633          !!!emit ($self->{ct}); # pi          !!!emit ($self->{ct}); # pi
3634          redo A;          redo A;
# Line 3038  sub _get_next_token ($) { Line 3642  sub _get_next_token ($) {
3642          redo A;          redo A;
3643        }        }
3644      } elsif ($self->{state} == PI_AFTER_STATE) {      } elsif ($self->{state} == PI_AFTER_STATE) {
3645          ## XML5: Part of "Pi after state".
3646    
3647        if ($self->{nc} == 0x003E) { # >        if ($self->{nc} == 0x003E) { # >
3648          $self->{state} = DATA_STATE;          if ($self->{in_subset}) {
3649          $self->{s_kwd} = '';            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
3650            } else {
3651              $self->{state} = DATA_STATE;
3652              $self->{s_kwd} = '';
3653            }
3654          !!!next-input-character;          !!!next-input-character;
3655          !!!emit ($self->{ct}); # pi          !!!emit ($self->{ct}); # pi
3656          redo A;          redo A;
# Line 3063  sub _get_next_token ($) { Line 3673  sub _get_next_token ($) {
3673          redo A;          redo A;
3674        }        }
3675      } elsif ($self->{state} == PI_DATA_AFTER_STATE) {      } elsif ($self->{state} == PI_DATA_AFTER_STATE) {
3676        ## XML5: Same as "pi after state" in XML5        ## XML5: Same as "pi after state" and "DOCTYPE pi after state".
3677    
3678        if ($self->{nc} == 0x003E) { # >        if ($self->{nc} == 0x003E) { # >
3679          $self->{state} = DATA_STATE;          if ($self->{in_subset}) {
3680          $self->{s_kwd} = '';            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
3681            } else {
3682              $self->{state} = DATA_STATE;
3683              $self->{s_kwd} = '';
3684            }
3685          !!!next-input-character;          !!!next-input-character;
3686          !!!emit ($self->{ct}); # pi          !!!emit ($self->{ct}); # pi
3687          redo A;          redo A;
# Line 3081  sub _get_next_token ($) { Line 3696  sub _get_next_token ($) {
3696          ## Reprocess.          ## Reprocess.
3697          redo A;          redo A;
3698        }        }
3699            
3700        } elsif ($self->{state} == DOCTYPE_INTERNAL_SUBSET_STATE) {
3701          if ($self->{nc} == 0x003C) { # <
3702            $self->{state} = DOCTYPE_TAG_STATE;
3703            !!!next-input-character;
3704            redo A;
3705          } elsif ($self->{nc} == 0x0025) { # %
3706            ## XML5: Not defined yet.
3707    
3708            ## TODO:
3709    
3710            if (not $self->{stop_processing} and
3711                not $self->{document}->xml_standalone) {
3712              !!!parse-error (type => 'stop processing', ## TODO: type
3713                              level => $self->{level}->{info});
3714              $self->{stop_processing} = 1;
3715            }
3716    
3717            !!!next-input-character;
3718            redo A;
3719          } elsif ($self->{nc} == 0x005D) { # ]
3720            delete $self->{in_subset};
3721            $self->{state} = DOCTYPE_INTERNAL_SUBSET_AFTER_STATE;
3722            !!!next-input-character;
3723            redo A;
3724          } elsif ($is_space->{$self->{nc}}) {
3725            ## Stay in the state.
3726            !!!next-input-character;
3727            redo A;
3728          } elsif ($self->{nc} == -1) {
3729            !!!parse-error (type => 'unclosed internal subset'); ## TODO: type
3730            delete $self->{in_subset};
3731            $self->{state} = DATA_STATE;
3732            $self->{s_kwd} = '';
3733            ## Reconsume.
3734            !!!emit ({type => END_OF_DOCTYPE_TOKEN});
3735            redo A;
3736          } else {
3737            unless ($self->{internal_subset_tainted}) {
3738              ## XML5: No parse error.
3739              !!!parse-error (type => 'string in internal subset');
3740              $self->{internal_subset_tainted} = 1;
3741            }
3742            ## Stay in the state.
3743            !!!next-input-character;
3744            redo A;
3745          }
3746        } elsif ($self->{state} == DOCTYPE_INTERNAL_SUBSET_AFTER_STATE) {
3747          if ($self->{nc} == 0x003E) { # >
3748            $self->{state} = DATA_STATE;
3749            $self->{s_kwd} = '';
3750            !!!next-input-character;
3751            !!!emit ({type => END_OF_DOCTYPE_TOKEN});
3752            redo A;
3753          } elsif ($self->{nc} == -1) {
3754            !!!parse-error (type => 'unclosed DOCTYPE');
3755            $self->{state} = DATA_STATE;
3756            $self->{s_kwd} = '';
3757            ## Reconsume.
3758            !!!emit ({type => END_OF_DOCTYPE_TOKEN});
3759            redo A;
3760          } else {
3761            ## XML5: No parse error and stay in the state.
3762            !!!parse-error (type => 'string after internal subset'); ## TODO: type
3763    
3764            $self->{state} = BOGUS_DOCTYPE_INTERNAL_SUBSET_AFTER_STATE;
3765            !!!next-input-character;
3766            redo A;
3767          }
3768        } elsif ($self->{state} == BOGUS_DOCTYPE_INTERNAL_SUBSET_AFTER_STATE) {
3769          if ($self->{nc} == 0x003E) { # >
3770            $self->{state} = DATA_STATE;
3771            $self->{s_kwd} = '';
3772            !!!next-input-character;
3773            !!!emit ({type => END_OF_DOCTYPE_TOKEN});
3774            redo A;
3775          } elsif ($self->{nc} == -1) {
3776            $self->{state} = DATA_STATE;
3777            $self->{s_kwd} = '';
3778            ## Reconsume.
3779            !!!emit ({type => END_OF_DOCTYPE_TOKEN});
3780            redo A;
3781          } else {
3782            ## Stay in the state.
3783            !!!next-input-character;
3784            redo A;
3785          }
3786        } elsif ($self->{state} == DOCTYPE_TAG_STATE) {
3787          if ($self->{nc} == 0x0021) { # !
3788            $self->{state} = DOCTYPE_MARKUP_DECLARATION_OPEN_STATE;
3789            !!!next-input-character;
3790            redo A;
3791          } elsif ($self->{nc} == 0x003F) { # ?
3792            $self->{state} = PI_STATE;
3793            !!!next-input-character;
3794            redo A;
3795          } elsif ($self->{nc} == -1) {
3796            !!!parse-error (type => 'bare stago');
3797            $self->{state} = DATA_STATE;
3798            $self->{s_kwd} = '';
3799            ## Reconsume.
3800            redo A;
3801          } else {
3802            !!!parse-error (type => 'bare stago', ## XML5: Not a parse error.
3803                            line => $self->{line_prev},
3804                            column => $self->{column_prev});
3805            $self->{state} = BOGUS_COMMENT_STATE;
3806            $self->{ct} = {type => COMMENT_TOKEN,
3807                           data => '',
3808                          }; ## NOTE: Will be discarded.
3809            !!!next-input-character;
3810            redo A;
3811          }
3812        } elsif ($self->{state} == DOCTYPE_MARKUP_DECLARATION_OPEN_STATE) {
3813          ## XML5: "DOCTYPE markup declaration state".
3814          
3815          if ($self->{nc} == 0x002D) { # -
3816            $self->{state} = MD_HYPHEN_STATE;
3817            !!!next-input-character;
3818            redo A;
3819          } elsif ($self->{nc} == 0x0045 or # E
3820                   $self->{nc} == 0x0065) { # e
3821            $self->{state} = MD_E_STATE;
3822            $self->{kwd} = chr $self->{nc};
3823            !!!next-input-character;
3824            redo A;
3825          } elsif ($self->{nc} == 0x0041 or # A
3826                   $self->{nc} == 0x0061) { # a
3827            $self->{state} = MD_ATTLIST_STATE;
3828            $self->{kwd} = chr $self->{nc};
3829            !!!next-input-character;
3830            redo A;
3831          } elsif ($self->{nc} == 0x004E or # N
3832                   $self->{nc} == 0x006E) { # n
3833            $self->{state} = MD_NOTATION_STATE;
3834            $self->{kwd} = chr $self->{nc};
3835            !!!next-input-character;
3836            redo A;
3837          } else {
3838            #
3839          }
3840          
3841          ## XML5: No parse error.
3842          !!!parse-error (type => 'bogus comment',
3843                          line => $self->{line_prev},
3844                          column => $self->{column_prev} - 1);
3845          ## Reconsume.
3846          $self->{state} = BOGUS_COMMENT_STATE;
3847          $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded.
3848          redo A;
3849        } elsif ($self->{state} == MD_E_STATE) {
3850          if ($self->{nc} == 0x004E or # N
3851              $self->{nc} == 0x006E) { # n
3852            $self->{state} = MD_ENTITY_STATE;
3853            $self->{kwd} .= chr $self->{nc};
3854            !!!next-input-character;
3855            redo A;
3856          } elsif ($self->{nc} == 0x004C or # L
3857                   $self->{nc} == 0x006C) { # l
3858            ## XML5: <!ELEMENT> not supported.
3859            $self->{state} = MD_ELEMENT_STATE;
3860            $self->{kwd} .= chr $self->{nc};
3861            !!!next-input-character;
3862            redo A;
3863          } else {
3864            ## XML5: No parse error.
3865            !!!parse-error (type => 'bogus comment',
3866                            line => $self->{line_prev},
3867                            column => $self->{column_prev} - 2
3868                                + 1 * ($self->{nc} == -1));
3869            ## Reconsume.
3870            $self->{state} = BOGUS_COMMENT_STATE;
3871            $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded
3872            redo A;
3873          }
3874        } elsif ($self->{state} == MD_ENTITY_STATE) {
3875          if ($self->{nc} == [
3876                undef,
3877                undef,
3878                0x0054, # T
3879                0x0049, # I
3880                0x0054, # T
3881              ]->[length $self->{kwd}] or
3882              $self->{nc} == [
3883                undef,
3884                undef,
3885                0x0074, # t
3886                0x0069, # i
3887                0x0074, # t
3888              ]->[length $self->{kwd}]) {
3889            ## Stay in the state.
3890            $self->{kwd} .= chr $self->{nc};
3891            !!!next-input-character;
3892            redo A;
3893          } elsif ((length $self->{kwd}) == 5 and
3894                   ($self->{nc} == 0x0059 or # Y
3895                    $self->{nc} == 0x0079)) { # y
3896            if ($self->{kwd} ne 'ENTIT' or $self->{nc} == 0x0079) {
3897              !!!parse-error (type => 'lowercase keyword', ## TODO: type
3898                              text => 'ENTITY',
3899                              line => $self->{line_prev},
3900                              column => $self->{column_prev} - 4);
3901            }
3902            $self->{ct} = {type => GENERAL_ENTITY_TOKEN, name => '',
3903                           line => $self->{line_prev},
3904                           column => $self->{column_prev} - 6};
3905            $self->{state} = DOCTYPE_MD_STATE;
3906            !!!next-input-character;
3907            redo A;
3908          } else {
3909            !!!parse-error (type => 'bogus comment',
3910                            line => $self->{line_prev},
3911                            column => $self->{column_prev} - 1
3912                                - (length $self->{kwd})
3913                                + 1 * ($self->{nc} == -1));
3914            $self->{state} = BOGUS_COMMENT_STATE;
3915            ## Reconsume.
3916            $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded
3917            redo A;
3918          }
3919        } elsif ($self->{state} == MD_ELEMENT_STATE) {
3920          if ($self->{nc} == [
3921               undef,
3922               undef,
3923               0x0045, # E
3924               0x004D, # M
3925               0x0045, # E
3926               0x004E, # N
3927              ]->[length $self->{kwd}] or
3928              $self->{nc} == [
3929               undef,
3930               undef,
3931               0x0065, # e
3932               0x006D, # m
3933               0x0065, # e
3934               0x006E, # n
3935              ]->[length $self->{kwd}]) {
3936            ## Stay in the state.
3937            $self->{kwd} .= chr $self->{nc};
3938            !!!next-input-character;
3939            redo A;
3940          } elsif ((length $self->{kwd}) == 6 and
3941                   ($self->{nc} == 0x0054 or # T
3942                    $self->{nc} == 0x0074)) { # t
3943            if ($self->{kwd} ne 'ELEMEN' or $self->{nc} == 0x0074) {
3944              !!!parse-error (type => 'lowercase keyword', ## TODO: type
3945                              text => 'ELEMENT',
3946                              line => $self->{line_prev},
3947                              column => $self->{column_prev} - 5);
3948            }
3949            $self->{ct} = {type => ELEMENT_TOKEN, name => '',
3950                           line => $self->{line_prev},
3951                           column => $self->{column_prev} - 7};
3952            $self->{state} = DOCTYPE_MD_STATE;
3953            !!!next-input-character;
3954            redo A;
3955          } else {
3956            !!!parse-error (type => 'bogus comment',
3957                            line => $self->{line_prev},
3958                            column => $self->{column_prev} - 1
3959                                - (length $self->{kwd})
3960                                + 1 * ($self->{nc} == -1));
3961            $self->{state} = BOGUS_COMMENT_STATE;
3962            ## Reconsume.
3963            $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded
3964            redo A;
3965          }
3966        } elsif ($self->{state} == MD_ATTLIST_STATE) {
3967          if ($self->{nc} == [
3968               undef,
3969               0x0054, # T
3970               0x0054, # T
3971               0x004C, # L
3972               0x0049, # I
3973               0x0053, # S
3974              ]->[length $self->{kwd}] or
3975              $self->{nc} == [
3976               undef,
3977               0x0074, # t
3978               0x0074, # t
3979               0x006C, # l
3980               0x0069, # i
3981               0x0073, # s
3982              ]->[length $self->{kwd}]) {
3983            ## Stay in the state.
3984            $self->{kwd} .= chr $self->{nc};
3985            !!!next-input-character;
3986            redo A;
3987          } elsif ((length $self->{kwd}) == 6 and
3988                   ($self->{nc} == 0x0054 or # T
3989                    $self->{nc} == 0x0074)) { # t
3990            if ($self->{kwd} ne 'ATTLIS' or $self->{nc} == 0x0074) {
3991              !!!parse-error (type => 'lowercase keyword', ## TODO: type
3992                              text => 'ATTLIST',
3993                              line => $self->{line_prev},
3994                              column => $self->{column_prev} - 5);
3995            }
3996            $self->{ct} = {type => ATTLIST_TOKEN, name => '',
3997                           attrdefs => [],
3998                           line => $self->{line_prev},
3999                           column => $self->{column_prev} - 7};
4000            $self->{state} = DOCTYPE_MD_STATE;
4001            !!!next-input-character;
4002            redo A;
4003          } else {
4004            !!!parse-error (type => 'bogus comment',
4005                            line => $self->{line_prev},
4006                            column => $self->{column_prev} - 1
4007                                 - (length $self->{kwd})
4008                                 + 1 * ($self->{nc} == -1));
4009            $self->{state} = BOGUS_COMMENT_STATE;
4010            ## Reconsume.
4011            $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded
4012            redo A;
4013          }
4014        } elsif ($self->{state} == MD_NOTATION_STATE) {
4015          if ($self->{nc} == [
4016               undef,
4017               0x004F, # O
4018               0x0054, # T
4019               0x0041, # A
4020               0x0054, # T
4021               0x0049, # I
4022               0x004F, # O
4023              ]->[length $self->{kwd}] or
4024              $self->{nc} == [
4025               undef,
4026               0x006F, # o
4027               0x0074, # t
4028               0x0061, # a
4029               0x0074, # t
4030               0x0069, # i
4031               0x006F, # o
4032              ]->[length $self->{kwd}]) {
4033            ## Stay in the state.
4034            $self->{kwd} .= chr $self->{nc};
4035            !!!next-input-character;
4036            redo A;
4037          } elsif ((length $self->{kwd}) == 7 and
4038                   ($self->{nc} == 0x004E or # N
4039                    $self->{nc} == 0x006E)) { # n
4040            if ($self->{kwd} ne 'NOTATIO' or $self->{nc} == 0x006E) {
4041              !!!parse-error (type => 'lowercase keyword', ## TODO: type
4042                              text => 'NOTATION',
4043                              line => $self->{line_prev},
4044                              column => $self->{column_prev} - 6);
4045            }
4046            $self->{ct} = {type => NOTATION_TOKEN, name => '',
4047                           line => $self->{line_prev},
4048                           column => $self->{column_prev} - 8};
4049            $self->{state} = DOCTYPE_MD_STATE;
4050            !!!next-input-character;
4051            redo A;
4052          } else {
4053            !!!parse-error (type => 'bogus comment',
4054                            line => $self->{line_prev},
4055                            column => $self->{column_prev} - 1
4056                                - (length $self->{kwd})
4057                                + 1 * ($self->{nc} == -1));
4058            $self->{state} = BOGUS_COMMENT_STATE;
4059            ## Reconsume.
4060            $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded
4061            redo A;
4062          }
4063        } elsif ($self->{state} == DOCTYPE_MD_STATE) {
4064          ## XML5: "DOCTYPE ENTITY state", "DOCTYPE ATTLIST state", and
4065          ## "DOCTYPE NOTATION state".
4066    
4067          if ($is_space->{$self->{nc}}) {
4068            ## XML5: [NOTATION] Switch to the "DOCTYPE NOTATION identifier state".
4069            $self->{state} = BEFORE_MD_NAME_STATE;
4070            !!!next-input-character;
4071            redo A;
4072          } elsif ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN and
4073                   $self->{nc} == 0x0025) { # %
4074            ## XML5: Switch to the "DOCTYPE bogus comment state".
4075            !!!parse-error (type => 'no space before md name'); ## TODO: type
4076            $self->{state} = DOCTYPE_ENTITY_PARAMETER_BEFORE_STATE;
4077            !!!next-input-character;
4078            redo A;
4079          } elsif ($self->{nc} == -1) {
4080            !!!parse-error (type => 'unclosed md'); ## TODO: type
4081            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4082            ## Reconsume.
4083            redo A;
4084          } elsif ($self->{nc} == 0x003E) { # >
4085            ## XML5: Switch to the "DOCTYPE bogus comment state".
4086            !!!parse-error (type => 'no md name'); ## TODO: type
4087            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4088            !!!next-input-character;
4089            redo A;
4090          } else {
4091            ## XML5: Switch to the "DOCTYPE bogus comment state".
4092            !!!parse-error (type => 'no space before md name'); ## TODO: type
4093            $self->{state} = BEFORE_MD_NAME_STATE;
4094            redo A;
4095          }
4096        } elsif ($self->{state} == BEFORE_MD_NAME_STATE) {
4097          ## XML5: "DOCTYPE ENTITY parameter state", "DOCTYPE ENTITY type
4098          ## before state", "DOCTYPE ATTLIST name before state".
4099    
4100          if ($is_space->{$self->{nc}}) {
4101            ## Stay in the state.
4102            !!!next-input-character;
4103            redo A;
4104          } elsif ($self->{ct}->{type} == GENERAL_ENTITY_TOKEN and
4105                   $self->{nc} == 0x0025) { # %
4106            $self->{state} = DOCTYPE_ENTITY_PARAMETER_BEFORE_STATE;
4107            !!!next-input-character;
4108            redo A;
4109          } elsif ($self->{nc} == 0x003E) { # >
4110            ## XML5: Same as "Anything else".
4111            !!!parse-error (type => 'no md name'); ## TODO: type
4112            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4113            !!!next-input-character;
4114            redo A;
4115          } elsif ($self->{nc} == -1) {
4116            !!!parse-error (type => 'unclosed md'); ## TODO: type
4117            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4118            ## Reconsume.
4119            redo A;
4120          } else {
4121            ## XML5: [ATTLIST] Not defined yet.
4122            $self->{ct}->{name} .= chr $self->{nc};
4123            $self->{state} = MD_NAME_STATE;
4124            !!!next-input-character;
4125            redo A;
4126          }
4127        } elsif ($self->{state} == DOCTYPE_ENTITY_PARAMETER_BEFORE_STATE) {
4128          if ($is_space->{$self->{nc}}) {
4129            ## XML5: Switch to the "DOCTYPE ENTITY parameter state".
4130            $self->{ct}->{type} = PARAMETER_ENTITY_TOKEN;
4131            $self->{state} = BEFORE_MD_NAME_STATE;
4132            !!!next-input-character;
4133            redo A;
4134          } elsif ($self->{nc} == 0x003E) { # >
4135            ## XML5: Same as "Anything else".
4136            !!!parse-error (type => 'no md name'); ## TODO: type
4137            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4138            !!!next-input-character;
4139            redo A;
4140          } elsif ($self->{nc} == -1) {
4141            !!!parse-error (type => 'unclosed md');
4142            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4143            ## Reconsume.
4144            redo A;
4145          } else {
4146            ## XML5: No parse error.
4147            !!!parse-error (type => 'no space after ENTITY percent'); ## TODO: type
4148            $self->{state} = BOGUS_COMMENT_STATE;
4149            $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded
4150            ## Reconsume.
4151            redo A;
4152          }
4153        } elsif ($self->{state} == MD_NAME_STATE) {
4154          ## XML5: "DOCTYPE ENTITY name state" and "DOCTYPE ATTLIST name state".
4155          
4156          if ($is_space->{$self->{nc}}) {
4157            if ($self->{ct}->{type} == ATTLIST_TOKEN) {
4158              $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;
4159            } elsif ($self->{ct}->{type} == ELEMENT_TOKEN) {
4160              $self->{state} = AFTER_ELEMENT_NAME_STATE;
4161            } else { # ENTITY/NOTATION
4162              $self->{state} = AFTER_DOCTYPE_NAME_STATE;
4163            }
4164            !!!next-input-character;
4165            redo A;
4166          } elsif ($self->{nc} == 0x003E) { # >
4167            if ($self->{ct}->{type} == ATTLIST_TOKEN) {
4168              #
4169            } else {
4170              !!!parse-error (type => 'no md def'); ## TODO: type
4171            }
4172            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4173            !!!next-input-character;
4174            !!!emit ($self->{ct}); # ELEMENT/ENTITY/ATTLIST/NOTATION
4175            redo A;
4176          } elsif ($self->{nc} == -1) {
4177            ## XML5: [ATTLIST] No parse error.
4178            !!!parse-error (type => 'unclosed md');
4179            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4180            ## Reconsume.
4181            !!!emit ($self->{ct}); # ELEMENT/ENTITY/ATTLIST/NOTATION
4182            redo A;
4183          } else {
4184            ## XML5: [ATTLIST] Not defined yet.
4185            $self->{ct}->{name} .= chr $self->{nc};
4186            ## Stay in the state.
4187            !!!next-input-character;
4188            redo A;
4189          }
4190        } elsif ($self->{state} == DOCTYPE_ATTLIST_NAME_AFTER_STATE) {
4191          if ($is_space->{$self->{nc}}) {
4192            ## Stay in the state.
4193            !!!next-input-character;
4194            redo A;
4195          } elsif ($self->{nc} == 0x003E) { # >
4196            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4197            !!!next-input-character;
4198            !!!emit ($self->{ct}); # ATTLIST
4199            redo A;
4200          } elsif ($self->{nc} == -1) {
4201            ## XML5: No parse error.
4202            !!!parse-error (type => 'unclosed md'); ## TODO: type
4203            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4204            !!!emit ($self->{ct});
4205            redo A;
4206          } else {
4207            ## XML5: Not defined yet.
4208            $self->{ca} = {name => chr ($self->{nc}), # attrdef
4209                           tokens => [],
4210                           line => $self->{line}, column => $self->{column}};
4211            $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_NAME_STATE;
4212            !!!next-input-character;
4213            redo A;
4214          }
4215        } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_NAME_STATE) {
4216          if ($is_space->{$self->{nc}}) {
4217            $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_NAME_AFTER_STATE;
4218            !!!next-input-character;
4219            redo A;
4220          } elsif ($self->{nc} == 0x003E) { # >
4221            ## XML5: Same as "anything else".
4222            !!!parse-error (type => 'no attr type'); ## TODO: type
4223            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4224            !!!next-input-character;
4225            !!!emit ($self->{ct}); # ATTLIST
4226            redo A;
4227          } elsif ($self->{nc} == 0x0028) { # (
4228            ## XML5: Same as "anything else".
4229            !!!parse-error (type => 'no space before paren'); ## TODO: type
4230            $self->{state} = BEFORE_ALLOWED_TOKEN_STATE;
4231            !!!next-input-character;
4232            redo A;
4233          } elsif ($self->{nc} == -1) {
4234            ## XML5: No parse error.
4235            !!!parse-error (type => 'unclosed md'); ## TODO: type
4236            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4237            !!!next-input-character;
4238            !!!emit ($self->{ct}); # ATTLIST
4239            redo A;
4240          } else {
4241            ## XML5: Not defined yet.
4242            $self->{ca}->{name} .= chr $self->{nc};
4243            ## Stay in the state.
4244            !!!next-input-character;
4245            redo A;
4246          }
4247        } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_NAME_AFTER_STATE) {
4248          if ($is_space->{$self->{nc}}) {
4249            ## Stay in the state.
4250            !!!next-input-character;
4251            redo A;
4252          } elsif ($self->{nc} == 0x003E) { # >
4253            ## XML5: Same as "anything else".
4254            !!!parse-error (type => 'no attr type'); ## TODO: type
4255            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4256            !!!next-input-character;
4257            !!!emit ($self->{ct}); # ATTLIST
4258            redo A;
4259          } elsif ($self->{nc} == 0x0028) { # (
4260            ## XML5: Same as "anything else".
4261            $self->{state} = BEFORE_ALLOWED_TOKEN_STATE;
4262            !!!next-input-character;
4263            redo A;
4264          } elsif ($self->{nc} == -1) {
4265            ## XML5: No parse error.
4266            !!!parse-error (type => 'unclosed md'); ## TODO: type
4267            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4268            !!!next-input-character;
4269            !!!emit ($self->{ct});
4270            redo A;
4271          } else {
4272            ## XML5: Not defined yet.
4273            $self->{ca}->{type} = chr $self->{nc};
4274            $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_TYPE_STATE;
4275            !!!next-input-character;
4276            redo A;
4277          }
4278        } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_TYPE_STATE) {
4279          if ($is_space->{$self->{nc}}) {
4280            $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_TYPE_AFTER_STATE;
4281            !!!next-input-character;
4282            redo A;
4283          } elsif ($self->{nc} == 0x0023) { # #
4284            ## XML5: Same as "anything else".
4285            !!!parse-error (type => 'no space before default value'); ## TODO: type
4286            $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_BEFORE_STATE;
4287            !!!next-input-character;
4288            redo A;
4289          } elsif ($self->{nc} == 0x0022) { # "
4290            ## XML5: Same as "anything else".
4291            !!!parse-error (type => 'no space before default value'); ## TODO: type
4292            $self->{ca}->{value} = '';
4293            $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
4294            !!!next-input-character;
4295            redo A;
4296          } elsif ($self->{nc} == 0x0027) { # '
4297            ## XML5: Same as "anything else".
4298            !!!parse-error (type => 'no space before default value'); ## TODO: type
4299            $self->{ca}->{value} = '';
4300            $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
4301            !!!next-input-character;
4302            redo A;
4303          } elsif ($self->{nc} == 0x003E) { # >
4304            ## XML5: Same as "anything else".
4305            !!!parse-error (type => 'no attr default'); ## TODO: type
4306            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4307            !!!next-input-character;
4308            !!!emit ($self->{ct}); # ATTLIST
4309            redo A;
4310          } elsif ($self->{nc} == 0x0028) { # (
4311            ## XML5: Same as "anything else".
4312            !!!parse-error (type => 'no space before paren'); ## TODO: type
4313            $self->{state} = BEFORE_ALLOWED_TOKEN_STATE;
4314            !!!next-input-character;
4315            redo A;
4316          } elsif ($self->{nc} == -1) {
4317            ## XML5: No parse error.
4318            !!!parse-error (type => 'unclosed md'); ## TODO: type
4319            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4320            !!!next-input-character;
4321            !!!emit ($self->{ct});
4322            redo A;
4323          } else {
4324            ## XML5: Not defined yet.
4325            $self->{ca}->{type} .= chr $self->{nc};
4326            ## Stay in the state.
4327            !!!next-input-character;
4328            redo A;
4329          }
4330        } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_TYPE_AFTER_STATE) {
4331          if ($is_space->{$self->{nc}}) {
4332            ## Stay in the state.
4333            !!!next-input-character;
4334            redo A;
4335          } elsif ($self->{nc} == 0x0028) { # (
4336            ## XML5: Same as "anything else".
4337            $self->{state} = BEFORE_ALLOWED_TOKEN_STATE;
4338            !!!next-input-character;
4339            redo A;
4340          } elsif ($self->{nc} == 0x0023) { # #
4341            $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_BEFORE_STATE;
4342            !!!next-input-character;
4343            redo A;
4344          } elsif ($self->{nc} == 0x0022) { # "
4345            ## XML5: Same as "anything else".
4346            $self->{ca}->{value} = '';
4347            $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
4348            !!!next-input-character;
4349            redo A;
4350          } elsif ($self->{nc} == 0x0027) { # '
4351            ## XML5: Same as "anything else".
4352            $self->{ca}->{value} = '';
4353            $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
4354            !!!next-input-character;
4355            redo A;
4356          } elsif ($self->{nc} == 0x003E) { # >
4357            ## XML5: Same as "anything else".
4358            !!!parse-error (type => 'no attr default'); ## TODO: type
4359            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4360            !!!next-input-character;
4361            !!!emit ($self->{ct}); # ATTLIST
4362            redo A;
4363          } elsif ($self->{nc} == -1) {
4364            ## XML5: No parse error.
4365            !!!parse-error (type => 'unclosed md'); ## TODO: type
4366            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4367            !!!next-input-character;
4368            !!!emit ($self->{ct});
4369            redo A;
4370          } else {
4371            ## XML5: Switch to the "DOCTYPE bogus comment state".
4372            !!!parse-error (type => 'unquoted attr value'); ## TODO: type
4373            $self->{ca}->{value} = '';
4374            $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
4375            ## Reconsume.
4376            redo A;
4377          }
4378        } elsif ($self->{state} == BEFORE_ALLOWED_TOKEN_STATE) {
4379          if ($is_space->{$self->{nc}}) {
4380            ## Stay in the state.
4381            !!!next-input-character;
4382            redo A;
4383          } elsif ($self->{nc} == 0x007C) { # |
4384            !!!parse-error (type => 'empty allowed token'); ## TODO: type
4385            ## Stay in the state.
4386            !!!next-input-character;
4387            redo A;
4388          } elsif ($self->{nc} == 0x0029) { # )
4389            !!!parse-error (type => 'empty allowed token'); ## TODO: type
4390            $self->{state} = AFTER_ALLOWED_TOKENS_STATE;
4391            !!!next-input-character;
4392            redo A;
4393          } elsif ($self->{nc} == 0x003E) { # >
4394            !!!parse-error (type => 'unclosed allowed tokens'); ## TODO: type
4395            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4396            !!!next-input-character;
4397            !!!emit ($self->{ct}); # ATTLIST
4398            redo A;
4399          } elsif ($self->{nc} == -1) {
4400            ## XML5: No parse error.
4401            !!!parse-error (type => 'unclosed md'); ## TODO: type
4402            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4403            !!!next-input-character;
4404            !!!emit ($self->{ct});
4405            redo A;
4406          } else {
4407            push @{$self->{ca}->{tokens}}, chr $self->{nc};
4408            $self->{state} = ALLOWED_TOKEN_STATE;
4409            !!!next-input-character;
4410            redo A;
4411          }
4412        } elsif ($self->{state} == ALLOWED_TOKEN_STATE) {
4413          if ($is_space->{$self->{nc}}) {
4414            $self->{state} = AFTER_ALLOWED_TOKEN_STATE;
4415            !!!next-input-character;
4416            redo A;
4417          } elsif ($self->{nc} == 0x007C) { # |
4418            $self->{state} = BEFORE_ALLOWED_TOKEN_STATE;
4419            !!!next-input-character;
4420            redo A;
4421          } elsif ($self->{nc} == 0x0029) { # )
4422            $self->{state} = AFTER_ALLOWED_TOKENS_STATE;
4423            !!!next-input-character;
4424            redo A;
4425          } elsif ($self->{nc} == 0x003E) { # >
4426            !!!parse-error (type => 'unclosed allowed tokens'); ## TODO: type
4427            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4428            !!!next-input-character;
4429            !!!emit ($self->{ct}); # ATTLIST
4430            redo A;
4431          } elsif ($self->{nc} == -1) {
4432            ## XML5: No parse error.
4433            !!!parse-error (type => 'unclosed md'); ## TODO: type
4434            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4435            !!!next-input-character;
4436            !!!emit ($self->{ct});
4437            redo A;
4438          } else {
4439            $self->{ca}->{tokens}->[-1] .= chr $self->{nc};
4440            ## Stay in the state.
4441            !!!next-input-character;
4442            redo A;
4443          }
4444        } elsif ($self->{state} == AFTER_ALLOWED_TOKEN_STATE) {
4445          if ($is_space->{$self->{nc}}) {
4446            ## Stay in the state.
4447            !!!next-input-character;
4448            redo A;
4449          } elsif ($self->{nc} == 0x007C) { # |
4450            $self->{state} = BEFORE_ALLOWED_TOKEN_STATE;
4451            !!!next-input-character;
4452            redo A;
4453          } elsif ($self->{nc} == 0x0029) { # )
4454            $self->{state} = AFTER_ALLOWED_TOKENS_STATE;
4455            !!!next-input-character;
4456            redo A;
4457          } elsif ($self->{nc} == 0x003E) { # >
4458            !!!parse-error (type => 'unclosed allowed tokens'); ## TODO: type
4459            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4460            !!!next-input-character;
4461            !!!emit ($self->{ct}); # ATTLIST
4462            redo A;
4463          } elsif ($self->{nc} == -1) {
4464            ## XML5: No parse error.
4465            !!!parse-error (type => 'unclosed md'); ## TODO: type
4466            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4467            !!!next-input-character;
4468            !!!emit ($self->{ct});
4469            redo A;
4470          } else {
4471            !!!parse-error (type => 'space in allowed token', ## TODO: type
4472                            line => $self->{line_prev},
4473                            column => $self->{column_prev});
4474            $self->{ca}->{tokens}->[-1] .= ' ' . chr $self->{nc};
4475            $self->{state} = ALLOWED_TOKEN_STATE;
4476            !!!next-input-character;
4477            redo A;
4478          }
4479        } elsif ($self->{state} == AFTER_ALLOWED_TOKENS_STATE) {
4480          if ($is_space->{$self->{nc}}) {
4481            $self->{state} = BEFORE_ATTR_DEFAULT_STATE;
4482            !!!next-input-character;
4483            redo A;
4484          } elsif ($self->{nc} == 0x0023) { # #
4485            !!!parse-error (type => 'no space before default value'); ## TODO: type
4486            $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_BEFORE_STATE;
4487            !!!next-input-character;
4488            redo A;
4489          } elsif ($self->{nc} == 0x0022) { # "
4490            !!!parse-error (type => 'no space before default value'); ## TODO: type
4491            $self->{ca}->{value} = '';
4492            $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
4493            !!!next-input-character;
4494            redo A;
4495          } elsif ($self->{nc} == 0x0027) { # '
4496            !!!parse-error (type => 'no space before default value'); ## TODO: type
4497            $self->{ca}->{value} = '';
4498            $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
4499            !!!next-input-character;
4500            redo A;
4501          } elsif ($self->{nc} == 0x003E) { # >
4502            !!!parse-error (type => 'no attr default'); ## TODO: type
4503            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4504            !!!next-input-character;
4505            !!!emit ($self->{ct}); # ATTLIST
4506            redo A;
4507          } elsif ($self->{nc} == -1) {
4508            !!!parse-error (type => 'unclosed md'); ## TODO: type
4509            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4510            !!!next-input-character;
4511            !!!emit ($self->{ct});
4512            redo A;
4513          } else {
4514            !!!parse-error (type => 'unquoted attr value'); ## TODO: type
4515            $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
4516            ## Reconsume.
4517            redo A;
4518          }
4519        } elsif ($self->{state} == BEFORE_ATTR_DEFAULT_STATE) {
4520          if ($is_space->{$self->{nc}}) {
4521            ## Stay in the state.
4522            !!!next-input-character;
4523            redo A;
4524          } elsif ($self->{nc} == 0x0023) { # #
4525            $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_BEFORE_STATE;
4526            !!!next-input-character;
4527            redo A;
4528          } elsif ($self->{nc} == 0x0022) { # "
4529            $self->{ca}->{value} = '';
4530            $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
4531            !!!next-input-character;
4532            redo A;
4533          } elsif ($self->{nc} == 0x0027) { # '
4534            $self->{ca}->{value} = '';
4535            $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
4536            !!!next-input-character;
4537            redo A;
4538          } elsif ($self->{nc} == 0x003E) { # >
4539            !!!parse-error (type => 'no attr default'); ## TODO: type
4540            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4541            !!!next-input-character;
4542            !!!emit ($self->{ct}); # ATTLIST
4543            redo A;
4544          } elsif ($self->{nc} == -1) {
4545            !!!parse-error (type => 'unclosed md'); ## TODO: type
4546            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4547            !!!next-input-character;
4548            !!!emit ($self->{ct});
4549            redo A;
4550          } else {
4551            !!!parse-error (type => 'unquoted attr value'); ## TODO: type
4552            $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
4553            ## Reconsume.
4554            redo A;
4555          }
4556        } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_BEFORE_STATE) {
4557          if ($is_space->{$self->{nc}}) {
4558            ## XML5: No parse error.
4559            !!!parse-error (type => 'no default type'); ## TODO: type
4560            $self->{state} = BOGUS_MD_STATE;
4561            ## Reconsume.
4562            redo A;
4563          } elsif ($self->{nc} == 0x0022) { # "
4564            ## XML5: Same as "anything else".
4565            $self->{ca}->{value} = '';
4566            $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
4567            !!!next-input-character;
4568            redo A;
4569          } elsif ($self->{nc} == 0x0027) { # '
4570            ## XML5: Same as "anything else".
4571            $self->{ca}->{value} = '';
4572            $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
4573            !!!next-input-character;
4574            redo A;
4575          } elsif ($self->{nc} == 0x003E) { # >
4576            ## XML5: Same as "anything else".
4577            !!!parse-error (type => 'no attr default'); ## TODO: type
4578            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4579            !!!next-input-character;
4580            !!!emit ($self->{ct}); # ATTLIST
4581            redo A;
4582          } elsif ($self->{nc} == -1) {
4583            ## XML5: No parse error.
4584            !!!parse-error (type => 'unclosed md'); ## TODO: type
4585            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4586            !!!next-input-character;
4587            !!!emit ($self->{ct});
4588            redo A;
4589          } else {
4590            $self->{ca}->{default} = chr $self->{nc};
4591            $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_STATE;
4592            !!!next-input-character;
4593            redo A;
4594          }
4595        } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_STATE) {
4596          if ($is_space->{$self->{nc}}) {
4597            $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_AFTER_STATE;
4598            !!!next-input-character;
4599            redo A;
4600          } elsif ($self->{nc} == 0x0022) { # "
4601            ## XML5: Same as "anything else".
4602            !!!parse-error (type => 'no space before default value'); ## TODO: type
4603            $self->{ca}->{value} = '';
4604            $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
4605            !!!next-input-character;
4606            redo A;
4607          } elsif ($self->{nc} == 0x0027) { # '
4608            ## XML5: Same as "anything else".
4609            !!!parse-error (type => 'no space before default value'); ## TODO: type
4610            $self->{ca}->{value} = '';
4611            $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
4612            !!!next-input-character;
4613            redo A;
4614          } elsif ($self->{nc} == 0x003E) { # >
4615            ## XML5: Same as "anything else".
4616            push @{$self->{ct}->{attrdefs}}, $self->{ca};
4617            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4618            !!!next-input-character;
4619            !!!emit ($self->{ct}); # ATTLIST
4620            redo A;
4621          } elsif ($self->{nc} == -1) {
4622            ## XML5: No parse error.
4623            !!!parse-error (type => 'unclosed md'); ## TODO: type
4624            push @{$self->{ct}->{attrdefs}}, $self->{ca};
4625            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4626            !!!next-input-character;
4627            !!!emit ($self->{ct});
4628            redo A;
4629          } else {
4630            $self->{ca}->{default} .= chr $self->{nc};
4631            ## Stay in the state.
4632            !!!next-input-character;
4633            redo A;
4634          }
4635        } elsif ($self->{state} == DOCTYPE_ATTLIST_ATTRIBUTE_DECLARATION_AFTER_STATE) {
4636          if ($is_space->{$self->{nc}}) {
4637            ## Stay in the state.
4638            !!!next-input-character;
4639            redo A;
4640          } elsif ($self->{nc} == 0x0022) { # "
4641            $self->{ca}->{value} = '';
4642            $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;
4643            !!!next-input-character;
4644            redo A;
4645          } elsif ($self->{nc} == 0x0027) { # '
4646            $self->{ca}->{value} = '';
4647            $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;
4648            !!!next-input-character;
4649            redo A;
4650          } elsif ($self->{nc} == 0x003E) { # >
4651            push @{$self->{ct}->{attrdefs}}, $self->{ca};
4652            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4653            !!!next-input-character;
4654            !!!emit ($self->{ct}); # ATTLIST
4655            redo A;
4656          } elsif ($self->{nc} == -1) {
4657            ## XML5: No parse error.
4658            !!!parse-error (type => 'unclosed md'); ## TODO: type
4659            push @{$self->{ct}->{attrdefs}}, $self->{ca};
4660            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4661            !!!next-input-character;
4662            !!!emit ($self->{ct});
4663            redo A;
4664          } else {
4665            ## XML5: Not defined yet.
4666            if ($self->{ca}->{default} eq 'FIXED') {
4667              $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;
4668            } else {
4669              push @{$self->{ct}->{attrdefs}}, $self->{ca};
4670              $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;
4671            }
4672            ## Reconsume.
4673            redo A;
4674          }
4675        } elsif ($self->{state} == AFTER_ATTLIST_ATTR_VALUE_QUOTED_STATE) {
4676          if ($is_space->{$self->{nc}} or
4677              $self->{nc} == -1 or
4678              $self->{nc} == 0x003E) { # >
4679            $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;
4680            ## Reconsume.
4681            redo A;
4682          } else {
4683            !!!parse-error (type => 'no space before attr name'); ## TODO: type
4684            $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;
4685            ## Reconsume.
4686            redo A;
4687          }
4688        } elsif ($self->{state} == NDATA_STATE) {
4689          ## ASCII case-insensitive
4690          if ($self->{nc} == [
4691                undef,
4692                0x0044, # D
4693                0x0041, # A
4694                0x0054, # T
4695              ]->[length $self->{kwd}] or
4696              $self->{nc} == [
4697                undef,
4698                0x0064, # d
4699                0x0061, # a
4700                0x0074, # t
4701              ]->[length $self->{kwd}]) {
4702            !!!cp (172.2);
4703            ## Stay in the state.
4704            $self->{kwd} .= chr $self->{nc};
4705            !!!next-input-character;
4706            redo A;
4707          } elsif ((length $self->{kwd}) == 4 and
4708                   ($self->{nc} == 0x0041 or # A
4709                    $self->{nc} == 0x0061)) { # a
4710            if ($self->{kwd} ne 'NDAT' or $self->{nc} == 0x0061) { # a
4711              !!!cp (172.3);
4712              !!!parse-error (type => 'lowercase keyword', ## TODO: type
4713                              text => 'NDATA',
4714                              line => $self->{line_prev},
4715                              column => $self->{column_prev} - 4);
4716            } else {
4717              !!!cp (172.4);
4718            }
4719            $self->{state} = AFTER_NDATA_STATE;
4720            !!!next-input-character;
4721            redo A;
4722          } else {
4723            !!!parse-error (type => 'string after literal', ## TODO: type
4724                            line => $self->{line_prev},
4725                            column => $self->{column_prev} + 1
4726                                - length $self->{kwd});
4727            !!!cp (172.5);
4728            $self->{state} = BOGUS_MD_STATE;
4729            ## Reconsume.
4730            redo A;
4731          }
4732        } elsif ($self->{state} == AFTER_NDATA_STATE) {
4733          if ($is_space->{$self->{nc}}) {
4734            $self->{state} = BEFORE_NOTATION_NAME_STATE;
4735            !!!next-input-character;
4736            redo A;
4737          } elsif ($self->{nc} == 0x003E) { # >
4738            !!!parse-error (type => 'no notation name'); ## TODO: type
4739            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4740            !!!next-input-character;
4741            !!!emit ($self->{ct}); # ENTITY
4742            redo A;
4743          } elsif ($self->{nc} == -1) {
4744            !!!parse-error (type => 'unclosed md'); ## TODO: type
4745            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4746            !!!next-input-character;
4747            !!!emit ($self->{ct}); # ENTITY
4748            redo A;
4749          } else {
4750            !!!parse-error (type => 'string after literal', ## TODO: type
4751                            line => $self->{line_prev},
4752                            column => $self->{column_prev} + 1
4753                                - length $self->{kwd});
4754            $self->{state} = BOGUS_MD_STATE;
4755            ## Reconsume.
4756            redo A;
4757          }
4758        } elsif ($self->{state} == BEFORE_NOTATION_NAME_STATE) {
4759          if ($is_space->{$self->{nc}}) {
4760            ## Stay in the state.
4761            !!!next-input-character;
4762            redo A;
4763          } elsif ($self->{nc} == 0x003E) { # >
4764            !!!parse-error (type => 'no notation name'); ## TODO: type
4765            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4766            !!!next-input-character;
4767            !!!emit ($self->{ct}); # ENTITY
4768            redo A;
4769          } elsif ($self->{nc} == -1) {
4770            !!!parse-error (type => 'unclosed md'); ## TODO: type
4771            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4772            !!!next-input-character;
4773            !!!emit ($self->{ct}); # ENTITY
4774            redo A;
4775          } else {
4776            $self->{ct}->{notation} = chr $self->{nc}; # ENTITY
4777            $self->{state} = NOTATION_NAME_STATE;
4778            !!!next-input-character;
4779            redo A;
4780          }
4781        } elsif ($self->{state} == NOTATION_NAME_STATE) {
4782          if ($is_space->{$self->{nc}}) {
4783            $self->{state} = AFTER_MD_DEF_STATE;
4784            !!!next-input-character;
4785            redo A;
4786          } elsif ($self->{nc} == 0x003E) { # >
4787            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4788            !!!next-input-character;
4789            !!!emit ($self->{ct}); # ENTITY
4790            redo A;
4791          } elsif ($self->{nc} == -1) {
4792            !!!parse-error (type => 'unclosed md'); ## TODO: type
4793            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4794            !!!next-input-character;
4795            !!!emit ($self->{ct}); # ENTITY
4796            redo A;
4797          } else {
4798            $self->{ct}->{notation} .= chr $self->{nc}; # ENTITY
4799            ## Stay in the state.
4800            !!!next-input-character;
4801            redo A;
4802          }
4803        } elsif ($self->{state} == DOCTYPE_ENTITY_VALUE_DOUBLE_QUOTED_STATE) {
4804          if ($self->{nc} == 0x0022) { # "
4805            $self->{state} = AFTER_MD_DEF_STATE;
4806            !!!next-input-character;
4807            redo A;
4808          } elsif ($self->{nc} == 0x0026) { # &
4809            $self->{prev_state} = $self->{state};
4810            $self->{state} = ENTITY_VALUE_ENTITY_STATE;
4811            $self->{entity_add} = 0x0022; # "
4812            !!!next-input-character;
4813            redo A;
4814    ## TODO: %
4815          } elsif ($self->{nc} == -1) {
4816            !!!parse-error (type => 'unclosed entity value'); ## TODO: type
4817            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4818            ## Reconsume.
4819            !!!emit ($self->{ct}); # ENTITY
4820            redo A;
4821          } else {
4822            $self->{ct}->{value} .= chr $self->{nc}; # ENTITY
4823            !!!next-input-character;
4824            redo A;
4825          }
4826        } elsif ($self->{state} == DOCTYPE_ENTITY_VALUE_SINGLE_QUOTED_STATE) {
4827          if ($self->{nc} == 0x0027) { # '
4828            $self->{state} = AFTER_MD_DEF_STATE;
4829            !!!next-input-character;
4830            redo A;
4831          } elsif ($self->{nc} == 0x0026) { # &
4832            $self->{prev_state} = $self->{state};
4833            $self->{state} = ENTITY_VALUE_ENTITY_STATE;
4834            $self->{entity_add} = 0x0027; # '
4835            !!!next-input-character;
4836            redo A;
4837    ## TODO: %
4838          } elsif ($self->{nc} == -1) {
4839            !!!parse-error (type => 'unclosed entity value'); ## TODO: type
4840            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4841            ## Reconsume.
4842            !!!emit ($self->{ct}); # ENTITY
4843            redo A;
4844          } else {
4845            $self->{ct}->{value} .= chr $self->{nc}; # ENTITY
4846            !!!next-input-character;
4847            redo A;
4848          }
4849        } elsif ($self->{state} == ENTITY_VALUE_ENTITY_STATE) {
4850          if ($is_space->{$self->{nc}} or
4851              {
4852                0x003C => 1, 0x0026 => 1, -1 => 1, # <, &
4853                $self->{entity_add} => 1,
4854              }->{$self->{nc}}) {
4855            !!!parse-error (type => 'bare ero',
4856                            line => $self->{line_prev},
4857                            column => $self->{column_prev}
4858                                + ($self->{nc} == -1 ? 1 : 0));
4859            ## Don't consume
4860            ## Return nothing.
4861            #
4862          } elsif ($self->{nc} == 0x0023) { # #
4863            $self->{ca} = $self->{ct};
4864            $self->{state} = ENTITY_HASH_STATE;
4865            $self->{kwd} = '#';
4866            !!!next-input-character;
4867            redo A;
4868          } else {
4869            #
4870          }
4871    
4872          $self->{ct}->{value} .= '&';
4873          $self->{state} = $self->{prev_state};
4874          ## Reconsume.
4875          redo A;
4876        } elsif ($self->{state} == AFTER_ELEMENT_NAME_STATE) {
4877          if ($is_space->{$self->{nc}}) {
4878            $self->{state} = BEFORE_ELEMENT_CONTENT_STATE;
4879            !!!next-input-character;
4880            redo A;
4881          } elsif ($self->{nc} == 0x0028) { # (
4882            $self->{state} = AFTER_CM_GROUP_OPEN_STATE;
4883            $self->{ct}->{content} = ['('];
4884            $self->{group_depth} = 1;
4885            !!!next-input-character;
4886            redo A;
4887          } elsif ($self->{nc} == 0x003E) { # >
4888            !!!parse-error (type => 'no md def'); ## TODO: type
4889            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4890            !!!next-input-character;
4891            !!!emit ($self->{ct}); # ELEMENT
4892            redo A;
4893          } elsif ($self->{nc} == -1) {
4894            !!!parse-error (type => 'unclosed md'); ## TODO: type
4895            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4896            !!!next-input-character;
4897            !!!emit ($self->{ct}); # ELEMENT
4898            redo A;
4899          } else {
4900            $self->{ct}->{content} = [chr $self->{nc}];
4901            $self->{state} = CONTENT_KEYWORD_STATE;
4902            !!!next-input-character;
4903            redo A;
4904          }
4905        } elsif ($self->{state} == CONTENT_KEYWORD_STATE) {
4906          if ($is_space->{$self->{nc}}) {
4907            $self->{state} = AFTER_MD_DEF_STATE;
4908            !!!next-input-character;
4909            redo A;
4910          } elsif ($self->{nc} == 0x003E) { # >
4911            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4912            !!!next-input-character;
4913            !!!emit ($self->{ct}); # ELEMENT
4914            redo A;
4915          } elsif ($self->{nc} == -1) {
4916            !!!parse-error (type => 'unclosed md'); ## TODO: type
4917            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4918            !!!next-input-character;
4919            !!!emit ($self->{ct}); # ELEMENT
4920            redo A;
4921          } else {
4922            $self->{ct}->{content}->[-1] .= chr $self->{nc}; # ELEMENT
4923            ## Stay in the state.
4924            !!!next-input-character;
4925            redo A;
4926          }
4927        } elsif ($self->{state} == AFTER_CM_GROUP_OPEN_STATE) {
4928          if ($is_space->{$self->{nc}}) {
4929            ## Stay in the state.
4930            !!!next-input-character;
4931            redo A;
4932          } elsif ($self->{nc} == 0x0028) { # (
4933            $self->{group_depth}++;
4934            push @{$self->{ct}->{content}}, chr $self->{nc};
4935            ## Stay in the state.
4936            !!!next-input-character;
4937            redo A;
4938          } elsif ($self->{nc} == 0x007C or # |
4939                   $self->{nc} == 0x002C) { # ,
4940            !!!parse-error (type => 'empty element name'); ## TODO: type
4941            ## Stay in the state.
4942            !!!next-input-character;
4943            redo A;
4944          } elsif ($self->{nc} == 0x0029) { # )
4945            !!!parse-error (type => 'empty element name'); ## TODO: type
4946            push @{$self->{ct}->{content}}, chr $self->{nc};
4947            $self->{group_depth}--;
4948            $self->{state} = AFTER_CM_GROUP_CLOSE_STATE;
4949            !!!next-input-character;
4950            redo A;
4951          } elsif ($self->{nc} == 0x003E) { # >
4952            !!!parse-error (type => 'unclosed cm group'); ## TODO: type
4953            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
4954            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4955            !!!next-input-character;
4956            !!!emit ($self->{ct}); # ELEMENT
4957            redo A;
4958          } elsif ($self->{nc} == -1) {
4959            !!!parse-error (type => 'unclosed md'); ## TODO: type
4960            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
4961            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4962            !!!next-input-character;
4963            !!!emit ($self->{ct}); # ELEMENT
4964            redo A;
4965          } else {
4966            push @{$self->{ct}->{content}}, chr $self->{nc};
4967            $self->{state} = CM_ELEMENT_NAME_STATE;
4968            !!!next-input-character;
4969            redo A;
4970          }
4971        } elsif ($self->{state} == CM_ELEMENT_NAME_STATE) {
4972          if ($is_space->{$self->{nc}}) {
4973            $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
4974            !!!next-input-character;
4975            redo A;
4976          } elsif ($self->{nc} == 0x002A or # *
4977                   $self->{nc} == 0x002B or # +
4978                   $self->{nc} == 0x003F) { # ?
4979            push @{$self->{ct}->{content}}, chr $self->{nc};
4980            $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
4981            !!!next-input-character;
4982            redo A;
4983          } elsif ($self->{nc} == 0x007C or # |
4984                   $self->{nc} == 0x002C) { # ,
4985            push @{$self->{ct}->{content}}, $self->{nc} == 0x007C ? ' | ' : ', ';
4986            $self->{state} = AFTER_CM_GROUP_OPEN_STATE;
4987            !!!next-input-character;
4988            redo A;
4989          } elsif ($self->{nc} == 0x0029) { # )
4990            $self->{group_depth}--;
4991            push @{$self->{ct}->{content}}, chr $self->{nc};
4992            $self->{state} = AFTER_CM_GROUP_CLOSE_STATE;
4993            !!!next-input-character;
4994            redo A;
4995          } elsif ($self->{nc} == 0x003E) { # >
4996            !!!parse-error (type => 'unclosed cm group'); ## TODO: type
4997            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
4998            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4999            !!!next-input-character;
5000            !!!emit ($self->{ct}); # ELEMENT
5001            redo A;
5002          } elsif ($self->{nc} == -1) {
5003            !!!parse-error (type => 'unclosed md'); ## TODO: type
5004            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
5005            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
5006            !!!next-input-character;
5007            !!!emit ($self->{ct}); # ELEMENT
5008            redo A;
5009          } else {
5010            $self->{ct}->{content}->[-1] .= chr $self->{nc};
5011            ## Stay in the state.
5012            !!!next-input-character;
5013            redo A;
5014          }
5015        } elsif ($self->{state} == AFTER_CM_ELEMENT_NAME_STATE) {
5016          if ($is_space->{$self->{nc}}) {
5017            ## Stay in the state.
5018            !!!next-input-character;
5019            redo A;
5020          } elsif ($self->{nc} == 0x007C or # |
5021                   $self->{nc} == 0x002C) { # ,
5022            push @{$self->{ct}->{content}}, $self->{nc} == 0x007C ? ' | ' : ', ';
5023            $self->{state} = AFTER_CM_GROUP_OPEN_STATE;
5024            !!!next-input-character;
5025            redo A;
5026          } elsif ($self->{nc} == 0x0029) { # )
5027            $self->{group_depth}--;
5028            push @{$self->{ct}->{content}}, chr $self->{nc};
5029            $self->{state} = AFTER_CM_GROUP_CLOSE_STATE;
5030            !!!next-input-character;
5031            redo A;
5032          } elsif ($self->{nc} == 0x003E) { # >
5033            !!!parse-error (type => 'unclosed cm group'); ## TODO: type
5034            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
5035            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
5036            !!!next-input-character;
5037            !!!emit ($self->{ct}); # ELEMENT
5038            redo A;
5039          } elsif ($self->{nc} == -1) {
5040            !!!parse-error (type => 'unclosed md'); ## TODO: type
5041            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
5042            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
5043            !!!next-input-character;
5044            !!!emit ($self->{ct}); # ELEMENT
5045            redo A;
5046          } else {
5047            !!!parse-error (type => 'after element name'); ## TODO: type
5048            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
5049            $self->{state} = BOGUS_MD_STATE;
5050            !!!next-input-character;
5051            redo A;
5052          }
5053        } elsif ($self->{state} == AFTER_CM_GROUP_CLOSE_STATE) {
5054          if ($is_space->{$self->{nc}}) {
5055            if ($self->{group_depth}) {
5056              $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
5057            } else {
5058              $self->{state} = AFTER_MD_DEF_STATE;
5059            }
5060            !!!next-input-character;
5061            redo A;
5062          } elsif ($self->{nc} == 0x002A or # *
5063                   $self->{nc} == 0x002B or # +
5064                   $self->{nc} == 0x003F) { # ?
5065            push @{$self->{ct}->{content}}, chr $self->{nc};
5066            if ($self->{group_depth}) {
5067              $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
5068            } else {
5069              $self->{state} = AFTER_MD_DEF_STATE;
5070            }
5071            !!!next-input-character;
5072            redo A;
5073          } elsif ($self->{nc} == 0x0029) { # )
5074            if ($self->{group_depth}) {
5075              $self->{group_depth}--;
5076              push @{$self->{ct}->{content}}, chr $self->{nc};
5077              ## Stay in the state.
5078              !!!next-input-character;
5079              redo A;
5080            } else {
5081              !!!parse-error (type => 'string after md def'); ## TODO: type
5082              $self->{state} = BOGUS_MD_STATE;
5083              ## Reconsume.
5084              redo A;
5085            }
5086          } elsif ($self->{nc} == 0x003E) { # >
5087            if ($self->{group_depth}) {
5088              !!!parse-error (type => 'unclosed cm group'); ## TODO: type
5089              push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
5090            }
5091            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
5092            !!!next-input-character;
5093            !!!emit ($self->{ct}); # ELEMENT
5094            redo A;
5095          } elsif ($self->{nc} == -1) {
5096            !!!parse-error (type => 'unclosed md'); ## TODO: type
5097            push @{$self->{ct}->{content}}, (')') x $self->{group_depth};
5098            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
5099            !!!next-input-character;
5100            !!!emit ($self->{ct}); # ELEMENT
5101            redo A;
5102          } else {
5103            if ($self->{group_depth}) {
5104              $self->{state} = AFTER_CM_ELEMENT_NAME_STATE;
5105            } else {
5106              !!!parse-error (type => 'string after md def'); ## TODO: type
5107              $self->{state} = BOGUS_MD_STATE;
5108            }
5109            ## Reconsume.
5110            redo A;
5111          }
5112        } elsif ($self->{state} == AFTER_MD_DEF_STATE) {
5113          if ($is_space->{$self->{nc}}) {
5114            ## Stay in the state.
5115            !!!next-input-character;
5116            redo A;
5117          } elsif ($self->{nc} == 0x003E) { # >
5118            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
5119            !!!next-input-character;
5120            !!!emit ($self->{ct}); # ENTITY/ELEMENT
5121            redo A;
5122          } elsif ($self->{nc} == -1) {
5123            !!!parse-error (type => 'unclosed md'); ## TODO: type
5124            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
5125            !!!next-input-character;
5126            !!!emit ($self->{ct}); # ENTITY/ELEMENT
5127            redo A;
5128          } else {
5129            !!!parse-error (type => 'string after md def'); ## TODO: type
5130            $self->{state} = BOGUS_MD_STATE;
5131            ## Reconsume.
5132            redo A;
5133          }
5134        } elsif ($self->{state} == BOGUS_MD_STATE) {
5135          if ($self->{nc} == 0x003E) { # >
5136            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
5137            !!!next-input-character;
5138            !!!emit ($self->{ct}); # ATTLIST/ENTITY/NOTATION
5139            redo A;
5140          } elsif ($self->{nc} == -1) {
5141            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
5142            ## Reconsume.
5143            !!!emit ($self->{ct}); # ATTLIST/ENTITY/NOTATION
5144            redo A;
5145          } else {
5146            ## Stay in the state.
5147            !!!next-input-character;
5148            redo A;
5149          }
5150      } else {      } else {
5151        die "$0: $self->{state}: Unknown state";        die "$0: $self->{state}: Unknown state";
5152      }      }
# Line 3092  sub _get_next_token ($) { Line 5157  sub _get_next_token ($) {
5157    
5158  1;  1;
5159  ## $Date$  ## $Date$
5160                                    
Legend:
Removed from v.1.11  
changed lines
  Added in v.1.30
admin@suikawiki.org
 ViewVC Help
Powered by ViewVC 1.1.24