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

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

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

revision 1.183 by wakaba, Mon Sep 15 08:09:39 2008 UTC revision 1.189 by wakaba, Sat Sep 20 11:25:56 2008 UTC
# Line 726  sub parse_char_stream ($$$;$$) { Line 726  sub parse_char_stream ($$$;$$) {
726            $self->{char_buffer_pos} += $count;            $self->{char_buffer_pos} += $count;
727            $self->{line_prev} = $self->{line};            $self->{line_prev} = $self->{line};
728            $self->{column_prev} = $self->{column} - 1;            $self->{column_prev} = $self->{column} - 1;
           $self->{prev_char} = [-1, -1, -1];  
729            $self->{nc} = -1;            $self->{nc} = -1;
730          }          }
731          return $count;          return $count;
# Line 739  sub parse_char_stream ($$$;$$) { Line 738  sub parse_char_stream ($$$;$$) {
738          $self->{column} += $count;          $self->{column} += $count;
739          $self->{line_prev} = $self->{line};          $self->{line_prev} = $self->{line};
740          $self->{column_prev} = $self->{column} - 1;          $self->{column_prev} = $self->{column} - 1;
         $self->{prev_char} = [-1, -1, -1];  
741          $self->{nc} = -1;          $self->{nc} = -1;
742        }        }
743        return $count;        return $count;
# Line 855  sub CDATA_SECTION_STATE () { 35 } Line 853  sub CDATA_SECTION_STATE () { 35 }
853  sub MD_HYPHEN_STATE () { 36 } # "markup declaration open state" in the spec  sub MD_HYPHEN_STATE () { 36 } # "markup declaration open state" in the spec
854  sub MD_DOCTYPE_STATE () { 37 } # "markup declaration open state" in the spec  sub MD_DOCTYPE_STATE () { 37 } # "markup declaration open state" in the spec
855  sub MD_CDATA_STATE () { 38 } # "markup declaration open state" in the spec  sub MD_CDATA_STATE () { 38 } # "markup declaration open state" in the spec
856  sub CDATA_PCDATA_CLOSE_TAG_STATE () { 39 } # "close tag open state" in the spec  sub CDATA_RCDATA_CLOSE_TAG_STATE () { 39 } # "close tag open state" in the spec
857  sub CDATA_SECTION_MSE1_STATE () { 40 } # "CDATA section state" in the spec  sub CDATA_SECTION_MSE1_STATE () { 40 } # "CDATA section state" in the spec
858  sub CDATA_SECTION_MSE2_STATE () { 41 } # "CDATA section state" in the spec  sub CDATA_SECTION_MSE2_STATE () { 41 } # "CDATA section state" in the spec
859  sub PUBLIC_STATE () { 42 } # "after DOCTYPE name state" in the spec  sub PUBLIC_STATE () { 42 } # "after DOCTYPE name state" in the spec
# Line 869  sub NCR_NUM_STATE () { 46 } Line 867  sub NCR_NUM_STATE () { 46 }
867  sub HEXREF_X_STATE () { 47 }  sub HEXREF_X_STATE () { 47 }
868  sub HEXREF_HEX_STATE () { 48 }  sub HEXREF_HEX_STATE () { 48 }
869  sub ENTITY_NAME_STATE () { 49 }  sub ENTITY_NAME_STATE () { 49 }
870    sub PCDATA_STATE () { 50 } # "data state" in the spec
871    
872  sub DOCTYPE_TOKEN () { 1 }  sub DOCTYPE_TOKEN () { 1 }
873  sub COMMENT_TOKEN () { 2 }  sub COMMENT_TOKEN () { 2 }
# Line 932  sub _initialize_tokenizer ($) { Line 931  sub _initialize_tokenizer ($) {
931    delete $self->{self_closing};    delete $self->{self_closing};
932    $self->{char_buffer} = '';    $self->{char_buffer} = '';
933    $self->{char_buffer_pos} = 0;    $self->{char_buffer_pos} = 0;
   $self->{prev_char} = [-1, -1, -1];  
934    $self->{nc} = -1; # next input character    $self->{nc} = -1; # next input character
935    #$self->{next_nc}    #$self->{next_nc}
936    !!!next-input-character;    !!!next-input-character;
# Line 968  sub _initialize_tokenizer ($) { Line 966  sub _initialize_tokenizer ($) {
966  ## TODO: Polytheistic slash SHOULD NOT be used. (Applied only to atheists.)  ## TODO: Polytheistic slash SHOULD NOT be used. (Applied only to atheists.)
967  ## (This requirement was dropped from HTML5 spec, unfortunately.)  ## (This requirement was dropped from HTML5 spec, unfortunately.)
968    
969    my $is_space = {
970      0x0009 => 1, # CHARACTER TABULATION (HT)
971      0x000A => 1, # LINE FEED (LF)
972      #0x000B => 0, # LINE TABULATION (VT)
973      0x000C => 1, # FORM FEED (FF)
974      #0x000D => 1, # CARRIAGE RETURN (CR)
975      0x0020 => 1, # SPACE (SP)
976    };
977    
978  sub _get_next_token ($) {  sub _get_next_token ($) {
979    my $self = shift;    my $self = shift;
980    
# Line 985  sub _get_next_token ($) { Line 992  sub _get_next_token ($) {
992    }    }
993    
994    A: {    A: {
995      if ($self->{state} == DATA_STATE) {      if ($self->{state} == PCDATA_STATE) {
996          ## NOTE: Same as |DATA_STATE|, but only for |PCDATA| content model.
997    
998          if ($self->{nc} == 0x0026) { # &
999            !!!cp (0.1);
1000            ## NOTE: In the spec, the tokenizer is switched to the
1001            ## "entity data state".  In this implementation, the tokenizer
1002            ## is switched to the |ENTITY_STATE|, which is an implementation
1003            ## of the "consume a character reference" algorithm.
1004            $self->{entity_add} = -1;
1005            $self->{prev_state} = DATA_STATE;
1006            $self->{state} = ENTITY_STATE;
1007            !!!next-input-character;
1008            redo A;
1009          } elsif ($self->{nc} == 0x003C) { # <
1010            !!!cp (0.2);
1011            $self->{state} = TAG_OPEN_STATE;
1012            !!!next-input-character;
1013            redo A;
1014          } elsif ($self->{nc} == -1) {
1015            !!!cp (0.3);
1016            !!!emit ({type => END_OF_FILE_TOKEN,
1017                      line => $self->{line}, column => $self->{column}});
1018            last A; ## TODO: ok?
1019          } else {
1020            !!!cp (0.4);
1021            #
1022          }
1023    
1024          # Anything else
1025          my $token = {type => CHARACTER_TOKEN,
1026                       data => chr $self->{nc},
1027                       line => $self->{line}, column => $self->{column},
1028                      };
1029          $self->{read_until}->($token->{data}, q[<&], length $token->{data});
1030    
1031          ## Stay in the state.
1032          !!!next-input-character;
1033          !!!emit ($token);
1034          redo A;
1035        } elsif ($self->{state} == DATA_STATE) {
1036          $self->{s_kwd} = '' unless defined $self->{s_kwd};
1037        if ($self->{nc} == 0x0026) { # &        if ($self->{nc} == 0x0026) { # &
1038            $self->{s_kwd} = '';
1039          if ($self->{content_model} & CM_ENTITY and # PCDATA | RCDATA          if ($self->{content_model} & CM_ENTITY and # PCDATA | RCDATA
1040              not $self->{escape}) {              not $self->{escape}) {
1041            !!!cp (1);            !!!cp (1);
# Line 1005  sub _get_next_token ($) { Line 1054  sub _get_next_token ($) {
1054          }          }
1055        } elsif ($self->{nc} == 0x002D) { # -        } elsif ($self->{nc} == 0x002D) { # -
1056          if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA          if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
1057            unless ($self->{escape}) {            $self->{s_kwd} .= '-';
1058              if ($self->{prev_char}->[0] == 0x002D and # -            
1059                  $self->{prev_char}->[1] == 0x0021 and # !            if ($self->{s_kwd} eq '<!--') {
1060                  $self->{prev_char}->[2] == 0x003C) { # <              !!!cp (3);
1061                !!!cp (3);              $self->{escape} = 1; # unless $self->{escape};
1062                $self->{escape} = 1;              $self->{s_kwd} = '--';
1063              } else {              #
1064                !!!cp (4);            } elsif ($self->{s_kwd} eq '---') {
1065              }              !!!cp (4);
1066                $self->{s_kwd} = '--';
1067                #
1068            } else {            } else {
1069              !!!cp (5);              !!!cp (5);
1070                #
1071            }            }
1072          }          }
1073                    
1074          #          #
1075          } elsif ($self->{nc} == 0x0021) { # !
1076            if (length $self->{s_kwd}) {
1077              !!!cp (5.1);
1078              $self->{s_kwd} .= '!';
1079              #
1080            } else {
1081              !!!cp (5.2);
1082              #$self->{s_kwd} = '';
1083              #
1084            }
1085            #
1086        } elsif ($self->{nc} == 0x003C) { # <        } elsif ($self->{nc} == 0x003C) { # <
1087          if ($self->{content_model} & CM_FULL_MARKUP or # PCDATA          if ($self->{content_model} & CM_FULL_MARKUP or # PCDATA
1088              (($self->{content_model} & CM_LIMITED_MARKUP) and # CDATA | RCDATA              (($self->{content_model} & CM_LIMITED_MARKUP) and # CDATA | RCDATA
# Line 1030  sub _get_next_token ($) { Line 1093  sub _get_next_token ($) {
1093            redo A;            redo A;
1094          } else {          } else {
1095            !!!cp (7);            !!!cp (7);
1096              $self->{s_kwd} = '';
1097            #            #
1098          }          }
1099        } elsif ($self->{nc} == 0x003E) { # >        } elsif ($self->{nc} == 0x003E) { # >
1100          if ($self->{escape} and          if ($self->{escape} and
1101              ($self->{content_model} & CM_LIMITED_MARKUP)) { # RCDATA | CDATA              ($self->{content_model} & CM_LIMITED_MARKUP)) { # RCDATA | CDATA
1102            if ($self->{prev_char}->[0] == 0x002D and # -            if ($self->{s_kwd} eq '--') {
               $self->{prev_char}->[1] == 0x002D) { # -  
1103              !!!cp (8);              !!!cp (8);
1104              delete $self->{escape};              delete $self->{escape};
1105            } else {            } else {
# Line 1046  sub _get_next_token ($) { Line 1109  sub _get_next_token ($) {
1109            !!!cp (10);            !!!cp (10);
1110          }          }
1111                    
1112            $self->{s_kwd} = '';
1113          #          #
1114        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
1115          !!!cp (11);          !!!cp (11);
1116            $self->{s_kwd} = '';
1117          !!!emit ({type => END_OF_FILE_TOKEN,          !!!emit ({type => END_OF_FILE_TOKEN,
1118                    line => $self->{line}, column => $self->{column}});                    line => $self->{line}, column => $self->{column}});
1119          last A; ## TODO: ok?          last A; ## TODO: ok?
1120        } else {        } else {
1121          !!!cp (12);          !!!cp (12);
1122            $self->{s_kwd} = '';
1123            #
1124        }        }
1125    
1126        # Anything else        # Anything else
1127        my $token = {type => CHARACTER_TOKEN,        my $token = {type => CHARACTER_TOKEN,
1128                     data => chr $self->{nc},                     data => chr $self->{nc},
1129                     line => $self->{line}, column => $self->{column},                     line => $self->{line}, column => $self->{column},
1130                    };                    };
1131        $self->{read_until}->($token->{data}, q[-!<>&], length $token->{data});        if ($self->{read_until}->($token->{data}, q[-!<>&],
1132                                    length $token->{data})) {
1133            $self->{s_kwd} = '';
1134          }
1135    
1136        ## Stay in the data state        ## Stay in the data state.
1137          if ($self->{content_model} == PCDATA_CONTENT_MODEL) {
1138            !!!cp (13);
1139            $self->{state} = PCDATA_STATE;
1140          } else {
1141            !!!cp (14);
1142            ## Stay in the state.
1143          }
1144        !!!next-input-character;        !!!next-input-character;
   
1145        !!!emit ($token);        !!!emit ($token);
   
1146        redo A;        redo A;
1147      } elsif ($self->{state} == TAG_OPEN_STATE) {      } elsif ($self->{state} == TAG_OPEN_STATE) {
1148        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
# Line 1075  sub _get_next_token ($) { Line 1151  sub _get_next_token ($) {
1151            !!!next-input-character;            !!!next-input-character;
1152            $self->{state} = CLOSE_TAG_OPEN_STATE;            $self->{state} = CLOSE_TAG_OPEN_STATE;
1153            redo A;            redo A;
1154            } elsif ($self->{nc} == 0x0021) { # !
1155              !!!cp (15.1);
1156              $self->{s_kwd} = '<' unless $self->{escape};
1157              #
1158          } else {          } else {
1159            !!!cp (16);            !!!cp (16);
1160            ## reconsume            #
           $self->{state} = DATA_STATE;  
   
           !!!emit ({type => CHARACTER_TOKEN, data => '<',  
                     line => $self->{line_prev},  
                     column => $self->{column_prev},  
                    });  
   
           redo A;  
1161          }          }
1162    
1163            ## reconsume
1164            $self->{state} = DATA_STATE;
1165            !!!emit ({type => CHARACTER_TOKEN, data => '<',
1166                      line => $self->{line_prev},
1167                      column => $self->{column_prev},
1168                     });
1169            redo A;
1170        } elsif ($self->{content_model} & CM_FULL_MARKUP) { # PCDATA        } elsif ($self->{content_model} & CM_FULL_MARKUP) { # PCDATA
1171          if ($self->{nc} == 0x0021) { # !          if ($self->{nc} == 0x0021) { # !
1172            !!!cp (17);            !!!cp (17);
# Line 1165  sub _get_next_token ($) { Line 1245  sub _get_next_token ($) {
1245        }        }
1246      } elsif ($self->{state} == CLOSE_TAG_OPEN_STATE) {      } elsif ($self->{state} == CLOSE_TAG_OPEN_STATE) {
1247        ## NOTE: The "close tag open state" in the spec is implemented as        ## NOTE: The "close tag open state" in the spec is implemented as
1248        ## |CLOSE_TAG_OPEN_STATE| and |CDATA_PCDATA_CLOSE_TAG_STATE|.        ## |CLOSE_TAG_OPEN_STATE| and |CDATA_RCDATA_CLOSE_TAG_STATE|.
1249    
1250        my ($l, $c) = ($self->{line_prev}, $self->{column_prev} - 1); # "<"of"</"        my ($l, $c) = ($self->{line_prev}, $self->{column_prev} - 1); # "<"of"</"
1251        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
1252          if (defined $self->{last_stag_name}) {          if (defined $self->{last_stag_name}) {
1253            $self->{state} = CDATA_PCDATA_CLOSE_TAG_STATE;            $self->{state} = CDATA_RCDATA_CLOSE_TAG_STATE;
1254            $self->{s_kwd} = '';            $self->{s_kwd} = '';
1255            ## Reconsume.            ## Reconsume.
1256            redo A;            redo A;
# Line 1241  sub _get_next_token ($) { Line 1321  sub _get_next_token ($) {
1321          ## "bogus comment state" entry.          ## "bogus comment state" entry.
1322          redo A;          redo A;
1323        }        }
1324      } elsif ($self->{state} == CDATA_PCDATA_CLOSE_TAG_STATE) {      } elsif ($self->{state} == CDATA_RCDATA_CLOSE_TAG_STATE) {
1325        my $ch = substr $self->{last_stag_name}, length $self->{s_kwd}, 1;        my $ch = substr $self->{last_stag_name}, length $self->{s_kwd}, 1;
1326        if (length $ch) {        if (length $ch) {
1327          my $CH = $ch;          my $CH = $ch;
# Line 1265  sub _get_next_token ($) { Line 1345  sub _get_next_token ($) {
1345            redo A;            redo A;
1346          }          }
1347        } else { # after "<{tag-name}"        } else { # after "<{tag-name}"
1348          unless ({          unless ($is_space->{$self->{nc}} or
1349                   0x0009 => 1, # HT                  {
                  0x000A => 1, # LF  
                  0x000B => 1, # VT  
                  0x000C => 1, # FF  
                  0x0020 => 1, # SP  
1350                   0x003E => 1, # >                   0x003E => 1, # >
1351                   0x002F => 1, # /                   0x002F => 1, # /
1352                   -1 => 1, # EOF                   -1 => 1, # EOF
# Line 1297  sub _get_next_token ($) { Line 1373  sub _get_next_token ($) {
1373          }          }
1374        }        }
1375      } elsif ($self->{state} == TAG_NAME_STATE) {      } elsif ($self->{state} == TAG_NAME_STATE) {
1376        if ($self->{nc} == 0x0009 or # HT        if ($is_space->{$self->{nc}}) {
           $self->{nc} == 0x000A or # LF  
           $self->{nc} == 0x000B or # VT  
           $self->{nc} == 0x000C or # FF  
           $self->{nc} == 0x0020) { # SP  
1377          !!!cp (34);          !!!cp (34);
1378          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
1379          !!!next-input-character;          !!!next-input-character;
# Line 1373  sub _get_next_token ($) { Line 1445  sub _get_next_token ($) {
1445          redo A;          redo A;
1446        }        }
1447      } elsif ($self->{state} == BEFORE_ATTRIBUTE_NAME_STATE) {      } elsif ($self->{state} == BEFORE_ATTRIBUTE_NAME_STATE) {
1448        if ($self->{nc} == 0x0009 or # HT        if ($is_space->{$self->{nc}}) {
           $self->{nc} == 0x000A or # LF  
           $self->{nc} == 0x000B or # VT  
           $self->{nc} == 0x000C or # FF  
           $self->{nc} == 0x0020) { # SP  
1449          !!!cp (45);          !!!cp (45);
1450          ## Stay in the state          ## Stay in the state
1451          !!!next-input-character;          !!!next-input-character;
# Line 1473  sub _get_next_token ($) { Line 1541  sub _get_next_token ($) {
1541          }          }
1542        }; # $before_leave        }; # $before_leave
1543    
1544        if ($self->{nc} == 0x0009 or # HT        if ($is_space->{$self->{nc}}) {
           $self->{nc} == 0x000A or # LF  
           $self->{nc} == 0x000B or # VT  
           $self->{nc} == 0x000C or # FF  
           $self->{nc} == 0x0020) { # SP  
1545          !!!cp (59);          !!!cp (59);
1546          $before_leave->();          $before_leave->();
1547          $self->{state} = AFTER_ATTRIBUTE_NAME_STATE;          $self->{state} = AFTER_ATTRIBUTE_NAME_STATE;
# Line 1560  sub _get_next_token ($) { Line 1624  sub _get_next_token ($) {
1624          redo A;          redo A;
1625        }        }
1626      } elsif ($self->{state} == AFTER_ATTRIBUTE_NAME_STATE) {      } elsif ($self->{state} == AFTER_ATTRIBUTE_NAME_STATE) {
1627        if ($self->{nc} == 0x0009 or # HT        if ($is_space->{$self->{nc}}) {
           $self->{nc} == 0x000A or # LF  
           $self->{nc} == 0x000B or # VT  
           $self->{nc} == 0x000C or # FF  
           $self->{nc} == 0x0020) { # SP  
1628          !!!cp (71);          !!!cp (71);
1629          ## Stay in the state          ## Stay in the state
1630          !!!next-input-character;          !!!next-input-character;
# Line 1651  sub _get_next_token ($) { Line 1711  sub _get_next_token ($) {
1711          redo A;                  redo A;        
1712        }        }
1713      } elsif ($self->{state} == BEFORE_ATTRIBUTE_VALUE_STATE) {      } elsif ($self->{state} == BEFORE_ATTRIBUTE_VALUE_STATE) {
1714        if ($self->{nc} == 0x0009 or # HT        if ($is_space->{$self->{nc}}) {
           $self->{nc} == 0x000A or # LF  
           $self->{nc} == 0x000B or # VT  
           $self->{nc} == 0x000C or # FF  
           $self->{nc} == 0x0020) { # SP        
1715          !!!cp (83);          !!!cp (83);
1716          ## Stay in the state          ## Stay in the state
1717          !!!next-input-character;          !!!next-input-character;
# Line 1836  sub _get_next_token ($) { Line 1892  sub _get_next_token ($) {
1892          redo A;          redo A;
1893        }        }
1894      } elsif ($self->{state} == ATTRIBUTE_VALUE_UNQUOTED_STATE) {      } elsif ($self->{state} == ATTRIBUTE_VALUE_UNQUOTED_STATE) {
1895        if ($self->{nc} == 0x0009 or # HT        if ($is_space->{$self->{nc}}) {
           $self->{nc} == 0x000A or # LF  
           $self->{nc} == 0x000B or # HT  
           $self->{nc} == 0x000C or # FF  
           $self->{nc} == 0x0020) { # SP  
1896          !!!cp (107);          !!!cp (107);
1897          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
1898          !!!next-input-character;          !!!next-input-character;
# Line 1922  sub _get_next_token ($) { Line 1974  sub _get_next_token ($) {
1974          redo A;          redo A;
1975        }        }
1976      } elsif ($self->{state} == AFTER_ATTRIBUTE_VALUE_QUOTED_STATE) {      } elsif ($self->{state} == AFTER_ATTRIBUTE_VALUE_QUOTED_STATE) {
1977        if ($self->{nc} == 0x0009 or # HT        if ($is_space->{$self->{nc}}) {
           $self->{nc} == 0x000A or # LF  
           $self->{nc} == 0x000B or # VT  
           $self->{nc} == 0x000C or # FF  
           $self->{nc} == 0x0020) { # SP  
1978          !!!cp (118);          !!!cp (118);
1979          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
1980          !!!next-input-character;          !!!next-input-character;
# Line 2367  sub _get_next_token ($) { Line 2415  sub _get_next_token ($) {
2415          redo A;          redo A;
2416        }        }
2417      } elsif ($self->{state} == DOCTYPE_STATE) {      } elsif ($self->{state} == DOCTYPE_STATE) {
2418        if ($self->{nc} == 0x0009 or # HT        if ($is_space->{$self->{nc}}) {
           $self->{nc} == 0x000A or # LF  
           $self->{nc} == 0x000B or # VT  
           $self->{nc} == 0x000C or # FF  
           $self->{nc} == 0x0020) { # SP  
2419          !!!cp (155);          !!!cp (155);
2420          $self->{state} = BEFORE_DOCTYPE_NAME_STATE;          $self->{state} = BEFORE_DOCTYPE_NAME_STATE;
2421          !!!next-input-character;          !!!next-input-character;
# Line 2384  sub _get_next_token ($) { Line 2428  sub _get_next_token ($) {
2428          redo A;          redo A;
2429        }        }
2430      } elsif ($self->{state} == BEFORE_DOCTYPE_NAME_STATE) {      } elsif ($self->{state} == BEFORE_DOCTYPE_NAME_STATE) {
2431        if ($self->{nc} == 0x0009 or # HT        if ($is_space->{$self->{nc}}) {
           $self->{nc} == 0x000A or # LF  
           $self->{nc} == 0x000B or # VT  
           $self->{nc} == 0x000C or # FF  
           $self->{nc} == 0x0020) { # SP  
2432          !!!cp (157);          !!!cp (157);
2433          ## Stay in the state          ## Stay in the state
2434          !!!next-input-character;          !!!next-input-character;
# Line 2422  sub _get_next_token ($) { Line 2462  sub _get_next_token ($) {
2462        }        }
2463      } elsif ($self->{state} == DOCTYPE_NAME_STATE) {      } elsif ($self->{state} == DOCTYPE_NAME_STATE) {
2464  ## ISSUE: Redundant "First," in the spec.  ## ISSUE: Redundant "First," in the spec.
2465        if ($self->{nc} == 0x0009 or # HT        if ($is_space->{$self->{nc}}) {
           $self->{nc} == 0x000A or # LF  
           $self->{nc} == 0x000B or # VT  
           $self->{nc} == 0x000C or # FF  
           $self->{nc} == 0x0020) { # SP  
2466          !!!cp (161);          !!!cp (161);
2467          $self->{state} = AFTER_DOCTYPE_NAME_STATE;          $self->{state} = AFTER_DOCTYPE_NAME_STATE;
2468          !!!next-input-character;          !!!next-input-character;
# Line 2458  sub _get_next_token ($) { Line 2494  sub _get_next_token ($) {
2494          redo A;          redo A;
2495        }        }
2496      } elsif ($self->{state} == AFTER_DOCTYPE_NAME_STATE) {      } elsif ($self->{state} == AFTER_DOCTYPE_NAME_STATE) {
2497        if ($self->{nc} == 0x0009 or # HT        if ($is_space->{$self->{nc}}) {
           $self->{nc} == 0x000A or # LF  
           $self->{nc} == 0x000B or # VT  
           $self->{nc} == 0x000C or # FF  
           $self->{nc} == 0x0020) { # SP  
2498          !!!cp (165);          !!!cp (165);
2499          ## Stay in the state          ## Stay in the state
2500          !!!next-input-character;          !!!next-input-character;
# Line 2585  sub _get_next_token ($) { Line 2617  sub _get_next_token ($) {
2617          redo A;          redo A;
2618        }        }
2619      } elsif ($self->{state} == BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {      } elsif ($self->{state} == BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {
2620        if ({        if ($is_space->{$self->{nc}}) {
             0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,  
             #0x000D => 1, # HT, LF, VT, FF, SP, CR  
           }->{$self->{nc}}) {  
2621          !!!cp (181);          !!!cp (181);
2622          ## Stay in the state          ## Stay in the state
2623          !!!next-input-character;          !!!next-input-character;
# Line 2715  sub _get_next_token ($) { Line 2744  sub _get_next_token ($) {
2744          redo A;          redo A;
2745        }        }
2746      } elsif ($self->{state} == AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {      } elsif ($self->{state} == AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {
2747        if ({        if ($is_space->{$self->{nc}}) {
             0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,  
             #0x000D => 1, # HT, LF, VT, FF, SP, CR  
           }->{$self->{nc}}) {  
2748          !!!cp (195);          !!!cp (195);
2749          ## Stay in the state          ## Stay in the state
2750          !!!next-input-character;          !!!next-input-character;
# Line 2764  sub _get_next_token ($) { Line 2790  sub _get_next_token ($) {
2790          redo A;          redo A;
2791        }        }
2792      } elsif ($self->{state} == BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {      } elsif ($self->{state} == BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {
2793        if ({        if ($is_space->{$self->{nc}}) {
             0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,  
             #0x000D => 1, # HT, LF, VT, FF, SP, CR  
           }->{$self->{nc}}) {  
2794          !!!cp (201);          !!!cp (201);
2795          ## Stay in the state          ## Stay in the state
2796          !!!next-input-character;          !!!next-input-character;
# Line 2893  sub _get_next_token ($) { Line 2916  sub _get_next_token ($) {
2916          redo A;          redo A;
2917        }        }
2918      } elsif ($self->{state} == AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {      } elsif ($self->{state} == AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {
2919        if ({        if ($is_space->{$self->{nc}}) {
             0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,  
             #0x000D => 1, # HT, LF, VT, FF, SP, CR  
           }->{$self->{nc}}) {  
2920          !!!cp (215);          !!!cp (215);
2921          ## Stay in the state          ## Stay in the state
2922          !!!next-input-character;          !!!next-input-character;
# Line 3028  sub _get_next_token ($) { Line 3048  sub _get_next_token ($) {
3048          redo A;          redo A;
3049        }        }
3050      } elsif ($self->{state} == ENTITY_STATE) {      } elsif ($self->{state} == ENTITY_STATE) {
3051        if ({        if ($is_space->{$self->{nc}} or
3052          0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, # HT, LF, VT, FF,            {
3053          0x0020 => 1, 0x003C => 1, 0x0026 => 1, -1 => 1, # SP, <, &              0x003C => 1, 0x0026 => 1, -1 => 1, # <, &
3054          $self->{entity_add} => 1,              $self->{entity_add} => 1,
3055        }->{$self->{nc}}) {            }->{$self->{nc}}) {
3056          !!!cp (1001);          !!!cp (1001);
3057          ## Don't consume          ## Don't consume
3058          ## No error          ## No error
# Line 3630  sub _tree_construction_initial ($) { Line 3650  sub _tree_construction_initial ($) {
3650        !!!ack-later;        !!!ack-later;
3651        return;        return;
3652      } elsif ($token->{type} == CHARACTER_TOKEN) {      } elsif ($token->{type} == CHARACTER_TOKEN) {
3653        if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D        if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
3654          ## Ignore the token          ## Ignore the token
3655    
3656          unless (length $token->{data}) {          unless (length $token->{data}) {
# Line 3687  sub _tree_construction_root_element ($) Line 3707  sub _tree_construction_root_element ($)
3707          !!!next-token;          !!!next-token;
3708          redo B;          redo B;
3709        } elsif ($token->{type} == CHARACTER_TOKEN) {        } elsif ($token->{type} == CHARACTER_TOKEN) {
3710          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D          if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
3711            ## Ignore the token.            ## Ignore the token.
3712    
3713            unless (length $token->{data}) {            unless (length $token->{data}) {
# Line 4501  sub _tree_construction_main ($) { Line 4521  sub _tree_construction_main ($) {
4521    
4522      if ($self->{insertion_mode} & HEAD_IMS) {      if ($self->{insertion_mode} & HEAD_IMS) {
4523        if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == CHARACTER_TOKEN) {
4524          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
4525            unless ($self->{insertion_mode} == BEFORE_HEAD_IM) {            unless ($self->{insertion_mode} == BEFORE_HEAD_IM) {
4526              !!!cp ('t88.2');              !!!cp ('t88.2');
4527              $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);              $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
# Line 4680  sub _tree_construction_main ($) { Line 4700  sub _tree_construction_main ($) {
4700                  } elsif ($token->{attributes}->{content}) {                  } elsif ($token->{attributes}->{content}) {
4701                    if ($token->{attributes}->{content}->{value}                    if ($token->{attributes}->{content}->{value}
4702                        =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt]                        =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt]
4703                            [\x09-\x0D\x20]*=                            [\x09\x0A\x0C\x0D\x20]*=
4704                            [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'|                            [\x09\x0A\x0C\x0D\x20]*(?>"([^"]*)"|'([^']*)'|
4705                            ([^"'\x09-\x0D\x20][^\x09-\x0D\x20\x3B]*))/x) {                            ([^"'\x09\x0A\x0C\x0D\x20]
4706                               [^\x09\x0A\x0C\x0D\x20\x3B]*))/x) {
4707                      !!!cp ('t107');                      !!!cp ('t107');
4708                      ## NOTE: Whether the encoding is supported or not is handled                      ## NOTE: Whether the encoding is supported or not is handled
4709                      ## in the {change_encoding} callback.                      ## in the {change_encoding} callback.
# Line 5491  sub _tree_construction_main ($) { Line 5512  sub _tree_construction_main ($) {
5512      } elsif ($self->{insertion_mode} & TABLE_IMS) {      } elsif ($self->{insertion_mode} & TABLE_IMS) {
5513        if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == CHARACTER_TOKEN) {
5514          if (not $open_tables->[-1]->[1] and # tainted          if (not $open_tables->[-1]->[1] and # tainted
5515              $token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {              $token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
5516            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
5517                                
5518            unless (length $token->{data}) {            unless (length $token->{data}) {
# Line 6175  sub _tree_construction_main ($) { Line 6196  sub _tree_construction_main ($) {
6196        }        }
6197      } elsif ($self->{insertion_mode} == IN_COLUMN_GROUP_IM) {      } elsif ($self->{insertion_mode} == IN_COLUMN_GROUP_IM) {
6198            if ($token->{type} == CHARACTER_TOKEN) {            if ($token->{type} == CHARACTER_TOKEN) {
6199              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {              if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
6200                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
6201                unless (length $token->{data}) {                unless (length $token->{data}) {
6202                  !!!cp ('t260');                  !!!cp ('t260');
# Line 6516  sub _tree_construction_main ($) { Line 6537  sub _tree_construction_main ($) {
6537        }        }
6538      } elsif ($self->{insertion_mode} & BODY_AFTER_IMS) {      } elsif ($self->{insertion_mode} & BODY_AFTER_IMS) {
6539        if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == CHARACTER_TOKEN) {
6540          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
6541            my $data = $1;            my $data = $1;
6542            ## As if in body            ## As if in body
6543            $reconstruct_active_formatting_elements->($insert_to_current);            $reconstruct_active_formatting_elements->($insert_to_current);
# Line 6533  sub _tree_construction_main ($) { Line 6554  sub _tree_construction_main ($) {
6554          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
6555            !!!cp ('t301');            !!!cp ('t301');
6556            !!!parse-error (type => 'after html:#text', token => $token);            !!!parse-error (type => 'after html:#text', token => $token);
6557              #
           ## Reprocess in the "after body" insertion mode.  
6558          } else {          } else {
6559            !!!cp ('t302');            !!!cp ('t302');
6560              ## "after body" insertion mode
6561              !!!parse-error (type => 'after body:#text', token => $token);
6562              #
6563          }          }
           
         ## "after body" insertion mode  
         !!!parse-error (type => 'after body:#text', token => $token);  
6564    
6565          $self->{insertion_mode} = IN_BODY_IM;          $self->{insertion_mode} = IN_BODY_IM;
6566          ## reprocess          ## reprocess
# Line 6550  sub _tree_construction_main ($) { Line 6570  sub _tree_construction_main ($) {
6570            !!!cp ('t303');            !!!cp ('t303');
6571            !!!parse-error (type => 'after html',            !!!parse-error (type => 'after html',
6572                            text => $token->{tag_name}, token => $token);                            text => $token->{tag_name}, token => $token);
6573                        #
           ## Reprocess in the "after body" insertion mode.  
6574          } else {          } else {
6575            !!!cp ('t304');            !!!cp ('t304');
6576              ## "after body" insertion mode
6577              !!!parse-error (type => 'after body',
6578                              text => $token->{tag_name}, token => $token);
6579              #
6580          }          }
6581    
         ## "after body" insertion mode  
         !!!parse-error (type => 'after body',  
                         text => $token->{tag_name}, token => $token);  
   
6582          $self->{insertion_mode} = IN_BODY_IM;          $self->{insertion_mode} = IN_BODY_IM;
6583          !!!ack-later;          !!!ack-later;
6584          ## reprocess          ## reprocess
# Line 6570  sub _tree_construction_main ($) { Line 6589  sub _tree_construction_main ($) {
6589            !!!parse-error (type => 'after html:/',            !!!parse-error (type => 'after html:/',
6590                            text => $token->{tag_name}, token => $token);                            text => $token->{tag_name}, token => $token);
6591                        
6592            $self->{insertion_mode} = AFTER_BODY_IM;            $self->{insertion_mode} = IN_BODY_IM;
6593            ## Reprocess in the "after body" insertion mode.            ## Reprocess.
6594              next B;
6595          } else {          } else {
6596            !!!cp ('t306');            !!!cp ('t306');
6597          }          }
# Line 6609  sub _tree_construction_main ($) { Line 6629  sub _tree_construction_main ($) {
6629        }        }
6630      } elsif ($self->{insertion_mode} & FRAME_IMS) {      } elsif ($self->{insertion_mode} & FRAME_IMS) {
6631        if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == CHARACTER_TOKEN) {
6632          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
6633            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
6634                        
6635            unless (length $token->{data}) {            unless (length $token->{data}) {
# Line 6619  sub _tree_construction_main ($) { Line 6639  sub _tree_construction_main ($) {
6639            }            }
6640          }          }
6641                    
6642          if ($token->{data} =~ s/^[^\x09\x0A\x0B\x0C\x20]+//) {          if ($token->{data} =~ s/^[^\x09\x0A\x0C\x20]+//) {
6643            if ($self->{insertion_mode} == IN_FRAMESET_IM) {            if ($self->{insertion_mode} == IN_FRAMESET_IM) {
6644              !!!cp ('t311');              !!!cp ('t311');
6645              !!!parse-error (type => 'in frameset:#text', token => $token);              !!!parse-error (type => 'in frameset:#text', token => $token);
# Line 6796  sub _tree_construction_main ($) { Line 6816  sub _tree_construction_main ($) {
6816            } elsif ($token->{attributes}->{content}) {            } elsif ($token->{attributes}->{content}) {
6817              if ($token->{attributes}->{content}->{value}              if ($token->{attributes}->{content}->{value}
6818                  =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt]                  =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt]
6819                      [\x09-\x0D\x20]*=                      [\x09\x0A\x0C\x0D\x20]*=
6820                      [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'|                      [\x09\x0A\x0C\x0D\x20]*(?>"([^"]*)"|'([^']*)'|
6821                      ([^"'\x09-\x0D\x20][^\x09-\x0D\x20\x3B]*))/x) {                      ([^"'\x09\x0A\x0C\x0D\x20][^\x09\x0A\x0C\x0D\x20\x3B]*))
6822                       /x) {
6823                !!!cp ('t336');                !!!cp ('t336');
6824                ## NOTE: Whether the encoding is supported or not is handled                ## NOTE: Whether the encoding is supported or not is handled
6825                ## in the {change_encoding} callback.                ## in the {change_encoding} callback.
# Line 7882  sub set_inner_html ($$$$;$) { Line 7903  sub set_inner_html ($$$$;$) {
7903              $p->{char_buffer_pos} += $count;              $p->{char_buffer_pos} += $count;
7904              $p->{line_prev} = $p->{line};              $p->{line_prev} = $p->{line};
7905              $p->{column_prev} = $p->{column} - 1;              $p->{column_prev} = $p->{column} - 1;
             $p->{prev_char} = [-1, -1, -1];  
7906              $p->{nc} = -1;              $p->{nc} = -1;
7907            }            }
7908            return $count;            return $count;
# Line 7894  sub set_inner_html ($$$$;$) { Line 7914  sub set_inner_html ($$$$;$) {
7914          if ($count) {          if ($count) {
7915            $p->{column} += $count;            $p->{column} += $count;
7916            $p->{column_prev} += $count;            $p->{column_prev} += $count;
           $p->{prev_char} = [-1, -1, -1];  
7917            $p->{nc} = -1;            $p->{nc} = -1;
7918          }          }
7919          return $count;          return $count;
Legend:
Removed from v.1.183  
changed lines
  Added in v.1.189
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.24