/[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.14 by wakaba, Fri Oct 17 07:14:29 2008 UTC revision 1.30 by wakaba, Sun Aug 16 05:24:47 2009 UTC
# Line 164  sub BEFORE_MD_NAME_STATE () { 68 } Line 164  sub BEFORE_MD_NAME_STATE () { 68 }
164  sub MD_NAME_STATE () { 69 }  sub MD_NAME_STATE () { 69 }
165  sub DOCTYPE_ENTITY_PARAMETER_BEFORE_STATE () { 70 }  sub DOCTYPE_ENTITY_PARAMETER_BEFORE_STATE () { 70 }
166  sub DOCTYPE_ATTLIST_NAME_AFTER_STATE () { 71 }  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 918  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 1040  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 1152  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 1240  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 1257  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 1278  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 1292  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 1312  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 1320  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 1341  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 1355  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 1375  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 1386  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 1409  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 1418  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 1442  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 1466  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 2002  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 2017  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: Unless EOF, swith to the bogus comment state.          ## 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
# Line 2044  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 2090  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 2111  sub _get_next_token ($) { Line 2257  sub _get_next_token ($) {
2257          redo A;          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        }        }
# Line 2127  sub _get_next_token ($) { Line 2272  sub _get_next_token ($) {
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
# Line 2160  sub _get_next_token ($) { Line 2315  sub _get_next_token ($) {
2315          $self->{kwd} = chr $self->{nc};          $self->{kwd} = chr $self->{nc};
2316          !!!next-input-character;          !!!next-input-character;
2317          redo A;          redo A;
2318        } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [        } 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);          !!!cp (167.3);
2338          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2339          $self->{ct}->{has_internal_subset} = 1; # DOCTYPE          $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
# Line 2169  sub _get_next_token ($) { Line 2342  sub _get_next_token ($) {
2342          !!!emit ($self->{ct}); # DOCTYPE          !!!emit ($self->{ct}); # DOCTYPE
2343          redo A;          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 2215  sub _get_next_token ($) { Line 2394  sub _get_next_token ($) {
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->{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 2263  sub _get_next_token ($) { Line 2446  sub _get_next_token ($) {
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->{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 2292  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;          redo A;
2513        } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [        } elsif ($self->{is_xml} and
2514                   $self->{ct}->{type} == DOCTYPE_TOKEN and
2515                   $self->{nc} == 0x005B) { # [
2516          !!!cp (186.1);          !!!cp (186.1);
2517          !!!parse-error (type => 'no PUBLIC literal');          !!!parse-error (type => 'no PUBLIC literal');
2518          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
# Line 2325  sub _get_next_token ($) { Line 2522  sub _get_next_token ($) {
2522          !!!emit ($self->{ct}); # DOCTYPE          !!!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 2340  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 2381  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 2423  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          if ($self->{is_xml}) {          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2655            !!!cp (198.1);            if ($self->{is_xml}) {
2656            !!!parse-error (type => 'no SYSTEM literal');              !!!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 {          } else {
2664            !!!cp (198);            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          $self->{state} = DATA_STATE;          
         $self->{s_kwd} = '';  
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
         $self->{ct}->{quirks} = 1;  
         !!!emit ($self->{ct}); # DOCTYPE  
   
2691          redo A;          redo A;
2692        } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [        } elsif ($self->{is_xml} and
2693                   $self->{ct}->{type} == DOCTYPE_TOKEN and
2694                   $self->{nc} == 0x005B) { # [
2695          !!!cp (200.1);          !!!cp (200.1);
2696          !!!parse-error (type => 'no SYSTEM literal');          !!!parse-error (type => 'no SYSTEM literal');
2697          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
# Line 2469  sub _get_next_token ($) { Line 2701  sub _get_next_token ($) {
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 2496  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
         $self->{ct}->{quirks} = 1;  
         !!!emit ($self->{ct}); # DOCTYPE  
   
2767          redo A;          redo A;
2768        } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [        } elsif ($self->{is_xml} and
2769                   $self->{ct}->{type} == DOCTYPE_TOKEN and
2770                   $self->{nc} == 0x005B) { # [
2771          !!!cp (206.1);          !!!cp (206.1);
2772          !!!parse-error (type => 'no SYSTEM literal');          !!!parse-error (type => 'no SYSTEM literal');
2773    
# Line 2529  sub _get_next_token ($) { Line 2778  sub _get_next_token ($) {
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 2544  sub _get_next_token ($) { Line 2799  sub _get_next_token ($) {
2799          !!!next-input-character;          !!!next-input-character;
2800          redo A;          redo A;
2801        } elsif (not $self->{is_xml} and $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 2597  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 2621  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          !!!next-input-character;            $self->{s_kwd} = '';
2903            } else {
2904          !!!emit ($self->{ct}); # DOCTYPE            !!!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;
2919          redo A;          redo A;
2920        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
2921          !!!cp (217);          if ($self->{ct}->{type} == DOCTYPE_TOKEN) {
2922          !!!parse-error (type => 'unclosed DOCTYPE');            !!!cp (217);
2923          $self->{state} = DATA_STATE;            !!!parse-error (type => 'unclosed DOCTYPE');
2924          $self->{s_kwd} = '';            $self->{state} = DATA_STATE;
2925          ## reconsume            $self->{s_kwd} = '';
2926              $self->{ct}->{quirks} = 1;
2927          $self->{ct}->{quirks} = 1;          } else {
2928          !!!emit ($self->{ct}); # DOCTYPE            !!!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;          redo A;
2936        } elsif ($self->{is_xml} and $self->{nc} == 0x005B) { # [        } elsif ($self->{is_xml} and
2937                   $self->{ct}->{type} == DOCTYPE_TOKEN and
2938                   $self->{nc} == 0x005B) { # [
2939          !!!cp (218.1);          !!!cp (218.1);
2940          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2941          $self->{ct}->{has_internal_subset} = 1; # DOCTYPE          $self->{ct}->{has_internal_subset} = 1; # DOCTYPE
# Line 2654  sub _get_next_token ($) { Line 2944  sub _get_next_token ($) {
2944          !!!emit ($self->{ct}); # DOCTYPE          !!!emit ($self->{ct}); # DOCTYPE
2945          redo A;          redo A;
2946        } else {        } else {
         !!!cp (218);  
2947          !!!parse-error (type => 'string after SYSTEM literal');          !!!parse-error (type => 'string after SYSTEM literal');
         #$self->{ct}->{quirks} = 1;  
2948    
2949          $self->{state} = BOGUS_DOCTYPE_STATE;          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;
2980          } elsif ($self->{nc} == -1) {
2981            !!!cp (218.6);
2982            !!!parse-error (type => 'unclosed md'); ## TODO: type
2983            $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
2984            ## reconsume
2985            !!!emit ($self->{ct}); # ENTITY
2986            redo A;
2987          } else {
2988            !!!cp (218.7);
2989            !!!parse-error (type => 'string after SYSTEM literal');
2990            $self->{state} = BOGUS_MD_STATE;
2991          !!!next-input-character;          !!!next-input-character;
2992          redo A;          redo A;
2993        }        }
# Line 2792  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) { # #
# Line 2803  sub _get_next_token ($) { Line 3140  sub _get_next_token ($) {
3140          $self->{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
# Line 2847  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->{kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
3192          !!!next-input-character;          !!!next-input-character;
3193          redo A;          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;
3202            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);
# Line 2914  sub _get_next_token ($) { Line 3260  sub _get_next_token ($) {
3260        my $code = $self->{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 3027  sub _get_next_token ($) { Line 3375  sub _get_next_token ($) {
3375        my $code = $self->{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 3061  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->{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->{kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
3429          if (defined $EntityChar->{$self->{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->{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              #              #
# Line 3321  sub _get_next_token ($) { Line 3706  sub _get_next_token ($) {
3706          ## XML5: Not defined yet.          ## XML5: Not defined yet.
3707    
3708          ## TODO:          ## 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;          !!!next-input-character;
3718          redo A;          redo A;
3719        } elsif ($self->{nc} == 0x005D) { # ]        } elsif ($self->{nc} == 0x005D) { # ]
# Line 3423  sub _get_next_token ($) { Line 3816  sub _get_next_token ($) {
3816          $self->{state} = MD_HYPHEN_STATE;          $self->{state} = MD_HYPHEN_STATE;
3817          !!!next-input-character;          !!!next-input-character;
3818          redo A;          redo A;
3819        } elsif ($self->{nc} == 0x0045) { # E        } elsif ($self->{nc} == 0x0045 or # E
3820                   $self->{nc} == 0x0065) { # e
3821          $self->{state} = MD_E_STATE;          $self->{state} = MD_E_STATE;
3822          $self->{kwd} = chr $self->{nc};          $self->{kwd} = chr $self->{nc};
3823          !!!next-input-character;          !!!next-input-character;
3824          redo A;          redo A;
3825        } elsif ($self->{nc} == 0x0041) { # A        } elsif ($self->{nc} == 0x0041 or # A
3826                   $self->{nc} == 0x0061) { # a
3827          $self->{state} = MD_ATTLIST_STATE;          $self->{state} = MD_ATTLIST_STATE;
3828          $self->{kwd} = chr $self->{nc};          $self->{kwd} = chr $self->{nc};
3829          !!!next-input-character;          !!!next-input-character;
3830          redo A;          redo A;
3831        } elsif ($self->{nc} == 0x004E) { # N        } elsif ($self->{nc} == 0x004E or # N
3832                   $self->{nc} == 0x006E) { # n
3833          $self->{state} = MD_NOTATION_STATE;          $self->{state} = MD_NOTATION_STATE;
3834          $self->{kwd} = chr $self->{nc};          $self->{kwd} = chr $self->{nc};
3835          !!!next-input-character;          !!!next-input-character;
# Line 3451  sub _get_next_token ($) { Line 3847  sub _get_next_token ($) {
3847        $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded.        $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded.
3848        redo A;        redo A;
3849      } elsif ($self->{state} == MD_E_STATE) {      } elsif ($self->{state} == MD_E_STATE) {
3850        if ($self->{nc} == 0x004E) { # N        if ($self->{nc} == 0x004E or # N
3851              $self->{nc} == 0x006E) { # n
3852          $self->{state} = MD_ENTITY_STATE;          $self->{state} = MD_ENTITY_STATE;
3853          $self->{kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
3854          !!!next-input-character;          !!!next-input-character;
3855          redo A;          redo A;
3856        } elsif ($self->{nc} == 0x004C) { # L        } elsif ($self->{nc} == 0x004C or # L
3857                   $self->{nc} == 0x006C) { # l
3858          ## XML5: <!ELEMENT> not supported.          ## XML5: <!ELEMENT> not supported.
3859          $self->{state} = MD_ELEMENT_STATE;          $self->{state} = MD_ELEMENT_STATE;
3860          $self->{kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
# Line 3474  sub _get_next_token ($) { Line 3872  sub _get_next_token ($) {
3872          redo A;          redo A;
3873        }        }
3874      } elsif ($self->{state} == MD_ENTITY_STATE) {      } elsif ($self->{state} == MD_ENTITY_STATE) {
3875        if ($self->{nc} == {        if ($self->{nc} == [
3876              'EN' => 0x0054, # T              undef,
3877              'ENT' => 0x0049, # I              undef,
3878              'ENTI' => 0x0054, # T              0x0054, # T
3879            }->{$self->{kwd}}) {              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.          ## Stay in the state.
3890          $self->{kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
3891          !!!next-input-character;          !!!next-input-character;
3892          redo A;          redo A;
3893        } elsif ($self->{kwd} eq 'ENTIT' and        } elsif ((length $self->{kwd}) == 5 and
3894                 $self->{nc} == 0x0059) { # Y                 ($self->{nc} == 0x0059 or # Y
3895          $self->{ct} = {type => GENERAL_ENTITY_TOKEN, name => '', text => '',                  $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},                         line => $self->{line_prev},
3904                         column => $self->{column_prev} - 6};                         column => $self->{column_prev} - 6};
3905          $self->{state} = DOCTYPE_MD_STATE;          $self->{state} = DOCTYPE_MD_STATE;
# Line 3503  sub _get_next_token ($) { Line 3917  sub _get_next_token ($) {
3917          redo A;          redo A;
3918        }        }
3919      } elsif ($self->{state} == MD_ELEMENT_STATE) {      } elsif ($self->{state} == MD_ELEMENT_STATE) {
3920        if ($self->{nc} == {        if ($self->{nc} == [
3921              'EL' => 0x0045, # E             undef,
3922              'ELE' => 0x004D, # M             undef,
3923              'ELEM' => 0x0045, # E             0x0045, # E
3924              'ELEME' => 0x004E, # N             0x004D, # M
3925            }->{$self->{kwd}}) {             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.          ## Stay in the state.
3937          $self->{kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
3938          !!!next-input-character;          !!!next-input-character;
3939          redo A;          redo A;
3940        } elsif ($self->{kwd} eq 'ELEMEN' and        } elsif ((length $self->{kwd}) == 6 and
3941                 $self->{nc} == 0x0054) { # T                 ($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 => '',          $self->{ct} = {type => ELEMENT_TOKEN, name => '',
3950                         line => $self->{line_prev},                         line => $self->{line_prev},
3951                         column => $self->{column_prev} - 6};                         column => $self->{column_prev} - 7};
3952          $self->{state} = DOCTYPE_MD_STATE;          $self->{state} = DOCTYPE_MD_STATE;
3953          !!!next-input-character;          !!!next-input-character;
3954          redo A;          redo A;
# Line 3533  sub _get_next_token ($) { Line 3964  sub _get_next_token ($) {
3964          redo A;          redo A;
3965        }        }
3966      } elsif ($self->{state} == MD_ATTLIST_STATE) {      } elsif ($self->{state} == MD_ATTLIST_STATE) {
3967        if ($self->{nc} == {        if ($self->{nc} == [
3968              'A' => 0x0054, # T             undef,
3969              'AT' => 0x0054, # T             0x0054, # T
3970              'ATT' => 0x004C, # L             0x0054, # T
3971              'ATTL' => 0x0049, # I             0x004C, # L
3972              'ATTLI' => 0x0053, # S             0x0049, # I
3973            }->{$self->{kwd}}) {             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.          ## Stay in the state.
3984          $self->{kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
3985          !!!next-input-character;          !!!next-input-character;
3986          redo A;          redo A;
3987        } elsif ($self->{kwd} eq 'ATTLIS' and        } elsif ((length $self->{kwd}) == 6 and
3988                 $self->{nc} == 0x0054) { # T                 ($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 => '',          $self->{ct} = {type => ATTLIST_TOKEN, name => '',
3997                           attrdefs => [],
3998                         line => $self->{line_prev},                         line => $self->{line_prev},
3999                         column => $self->{column_prev} - 6};                         column => $self->{column_prev} - 7};
4000          $self->{state} = DOCTYPE_MD_STATE;          $self->{state} = DOCTYPE_MD_STATE;
4001          !!!next-input-character;          !!!next-input-character;
4002          redo A;          redo A;
# Line 3564  sub _get_next_token ($) { Line 4012  sub _get_next_token ($) {
4012          redo A;          redo A;
4013        }        }
4014      } elsif ($self->{state} == MD_NOTATION_STATE) {      } elsif ($self->{state} == MD_NOTATION_STATE) {
4015        if ($self->{nc} == {        if ($self->{nc} == [
4016              'N' => 0x004F, # O             undef,
4017              'NO' => 0x0054, # T             0x004F, # O
4018              'NOT' => 0x0041, # A             0x0054, # T
4019              'NOTA' => 0x0054, # T             0x0041, # A
4020              'NOTAT' => 0x0049, # I             0x0054, # T
4021              'NOTATI' => 0x004F, # O             0x0049, # I
4022            }->{$self->{kwd}}) {             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.          ## Stay in the state.
4034          $self->{kwd} .= chr $self->{nc};          $self->{kwd} .= chr $self->{nc};
4035          !!!next-input-character;          !!!next-input-character;
4036          redo A;          redo A;
4037        } elsif ($self->{kwd} eq 'NOTATIO' and        } elsif ((length $self->{kwd}) == 7 and
4038                 $self->{nc} == 0x004E) { # N                 ($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 => '',          $self->{ct} = {type => NOTATION_TOKEN, name => '',
4047                         line => $self->{line_prev},                         line => $self->{line_prev},
4048                         column => $self->{column_prev} - 6};                         column => $self->{column_prev} - 8};
4049          $self->{state} = DOCTYPE_MD_STATE;          $self->{state} = DOCTYPE_MD_STATE;
4050          !!!next-input-character;          !!!next-input-character;
4051          redo A;          redo A;
# Line 3689  sub _get_next_token ($) { Line 4154  sub _get_next_token ($) {
4154        ## XML5: "DOCTYPE ENTITY name state" and "DOCTYPE ATTLIST name state".        ## XML5: "DOCTYPE ENTITY name state" and "DOCTYPE ATTLIST name state".
4155                
4156        if ($is_space->{$self->{nc}}) {        if ($is_space->{$self->{nc}}) {
4157          ## TODO:          if ($self->{ct}->{type} == ATTLIST_TOKEN) {
4158          $self->{state} = DOCTYPE_ATTLIST_NAME_AFTER_STATE;            $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;          !!!next-input-character;
4165          redo A;          redo A;
4166        } elsif ($self->{nc} == 0x003E) { # >        } elsif ($self->{nc} == 0x003E) { # >
4167          if ($self->{ct}->{type} == ATTLIST_TOKEN) {          if ($self->{ct}->{type} == ATTLIST_TOKEN) {
4168            #            #
4169          } else {          } else {
4170            !!!parse-error (type => 'no md body'); ## TODO: type            !!!parse-error (type => 'no md def'); ## TODO: type
4171          }          }
4172          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE;
4173          !!!next-input-character;          !!!next-input-character;
# Line 3731  sub _get_next_token ($) { Line 4201  sub _get_next_token ($) {
4201          ## XML5: No parse error.          ## XML5: No parse error.
4202          !!!parse-error (type => 'unclosed md'); ## TODO: type          !!!parse-error (type => 'unclosed md'); ## TODO: type
4203          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".          $self->{state} = DOCTYPE_INTERNAL_SUBSET_STATE; ## XML5: "Data state".
4204            !!!emit ($self->{ct});
4205          redo A;          redo A;
4206        } else {        } else {
4207          ## XML5: Not defined yet.          ## XML5: Not defined yet.
4208            $self->{ca} = {name => chr ($self->{nc}), # attrdef
4209          ## TODO: ...                         tokens => [],
4210                           line => $self->{line}, column => $self->{column}};
4211          $self->{state} = BOGUS_COMMENT_STATE;          $self->{state} = DOCTYPE_ATTLIST_ATTRIBUTE_NAME_STATE;
4212          $self->{ct} = {type => COMMENT_TOKEN, data => ''}; ## Will be discarded          !!!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.          ## 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;          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 3753  sub _get_next_token ($) { Line 5157  sub _get_next_token ($) {
5157    
5158  1;  1;
5159  ## $Date$  ## $Date$
5160                                    
Legend:
Removed from v.1.14  
changed lines
  Added in v.1.30
admin@suikawiki.org
 ViewVC Help
Powered by ViewVC 1.1.24