/[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.190 by wakaba, Sun Sep 21 05:08:16 2008 UTC
# Line 401  sub parse_byte_stream ($$$$;$$) { Line 401  sub parse_byte_stream ($$$$;$$) {
401            ## TODO: Is this ok?  Transfer protocol's parameter should be            ## TODO: Is this ok?  Transfer protocol's parameter should be
402            ## interpreted in its semantics?            ## interpreted in its semantics?
403    
       ## ISSUE: Unsupported encoding is not ignored according to the spec.  
404        ($char_stream, $e_status) = $charset->get_decode_handle        ($char_stream, $e_status) = $charset->get_decode_handle
405            ($byte_stream, allow_error_reporting => 1,            ($byte_stream, allow_error_reporting => 1,
406             allow_fallback => 1);             allow_fallback => 1);
# Line 409  sub parse_byte_stream ($$$$;$$) { Line 408  sub parse_byte_stream ($$$$;$$) {
408          $self->{confident} = 1;          $self->{confident} = 1;
409          last SNIFFING;          last SNIFFING;
410        } else {        } else {
411          ## TODO: unsupported error          !!!parse-error (type => 'charset:not supported',
412                            layer => 'encode',
413                            line => 1, column => 1,
414                            value => $charset_name,
415                            level => $self->{level}->{uncertain});
416        }        }
417      }      }
418    
# Line 726  sub parse_char_stream ($$$;$$) { Line 729  sub parse_char_stream ($$$;$$) {
729            $self->{char_buffer_pos} += $count;            $self->{char_buffer_pos} += $count;
730            $self->{line_prev} = $self->{line};            $self->{line_prev} = $self->{line};
731            $self->{column_prev} = $self->{column} - 1;            $self->{column_prev} = $self->{column} - 1;
           $self->{prev_char} = [-1, -1, -1];  
732            $self->{nc} = -1;            $self->{nc} = -1;
733          }          }
734          return $count;          return $count;
# Line 739  sub parse_char_stream ($$$;$$) { Line 741  sub parse_char_stream ($$$;$$) {
741          $self->{column} += $count;          $self->{column} += $count;
742          $self->{line_prev} = $self->{line};          $self->{line_prev} = $self->{line};
743          $self->{column_prev} = $self->{column} - 1;          $self->{column_prev} = $self->{column} - 1;
         $self->{prev_char} = [-1, -1, -1];  
744          $self->{nc} = -1;          $self->{nc} = -1;
745        }        }
746        return $count;        return $count;
# Line 855  sub CDATA_SECTION_STATE () { 35 } Line 856  sub CDATA_SECTION_STATE () { 35 }
856  sub MD_HYPHEN_STATE () { 36 } # "markup declaration open state" in the spec  sub MD_HYPHEN_STATE () { 36 } # "markup declaration open state" in the spec
857  sub MD_DOCTYPE_STATE () { 37 } # "markup declaration open state" in the spec  sub MD_DOCTYPE_STATE () { 37 } # "markup declaration open state" in the spec
858  sub MD_CDATA_STATE () { 38 } # "markup declaration open state" in the spec  sub MD_CDATA_STATE () { 38 } # "markup declaration open state" in the spec
859  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
860  sub CDATA_SECTION_MSE1_STATE () { 40 } # "CDATA section state" in the spec  sub CDATA_SECTION_MSE1_STATE () { 40 } # "CDATA section state" in the spec
861  sub CDATA_SECTION_MSE2_STATE () { 41 } # "CDATA section state" in the spec  sub CDATA_SECTION_MSE2_STATE () { 41 } # "CDATA section state" in the spec
862  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 870  sub NCR_NUM_STATE () { 46 }
870  sub HEXREF_X_STATE () { 47 }  sub HEXREF_X_STATE () { 47 }
871  sub HEXREF_HEX_STATE () { 48 }  sub HEXREF_HEX_STATE () { 48 }
872  sub ENTITY_NAME_STATE () { 49 }  sub ENTITY_NAME_STATE () { 49 }
873    sub PCDATA_STATE () { 50 } # "data state" in the spec
874    
875  sub DOCTYPE_TOKEN () { 1 }  sub DOCTYPE_TOKEN () { 1 }
876  sub COMMENT_TOKEN () { 2 }  sub COMMENT_TOKEN () { 2 }
# Line 932  sub _initialize_tokenizer ($) { Line 934  sub _initialize_tokenizer ($) {
934    delete $self->{self_closing};    delete $self->{self_closing};
935    $self->{char_buffer} = '';    $self->{char_buffer} = '';
936    $self->{char_buffer_pos} = 0;    $self->{char_buffer_pos} = 0;
   $self->{prev_char} = [-1, -1, -1];  
937    $self->{nc} = -1; # next input character    $self->{nc} = -1; # next input character
938    #$self->{next_nc}    #$self->{next_nc}
939    !!!next-input-character;    !!!next-input-character;
# Line 968  sub _initialize_tokenizer ($) { Line 969  sub _initialize_tokenizer ($) {
969  ## TODO: Polytheistic slash SHOULD NOT be used. (Applied only to atheists.)  ## TODO: Polytheistic slash SHOULD NOT be used. (Applied only to atheists.)
970  ## (This requirement was dropped from HTML5 spec, unfortunately.)  ## (This requirement was dropped from HTML5 spec, unfortunately.)
971    
972    my $is_space = {
973      0x0009 => 1, # CHARACTER TABULATION (HT)
974      0x000A => 1, # LINE FEED (LF)
975      #0x000B => 0, # LINE TABULATION (VT)
976      0x000C => 1, # FORM FEED (FF)
977      #0x000D => 1, # CARRIAGE RETURN (CR)
978      0x0020 => 1, # SPACE (SP)
979    };
980    
981  sub _get_next_token ($) {  sub _get_next_token ($) {
982    my $self = shift;    my $self = shift;
983    
# Line 985  sub _get_next_token ($) { Line 995  sub _get_next_token ($) {
995    }    }
996    
997    A: {    A: {
998      if ($self->{state} == DATA_STATE) {      if ($self->{state} == PCDATA_STATE) {
999          ## NOTE: Same as |DATA_STATE|, but only for |PCDATA| content model.
1000    
1001        if ($self->{nc} == 0x0026) { # &        if ($self->{nc} == 0x0026) { # &
1002            !!!cp (0.1);
1003            ## NOTE: In the spec, the tokenizer is switched to the
1004            ## "entity data state".  In this implementation, the tokenizer
1005            ## is switched to the |ENTITY_STATE|, which is an implementation
1006            ## of the "consume a character reference" algorithm.
1007            $self->{entity_add} = -1;
1008            $self->{prev_state} = DATA_STATE;
1009            $self->{state} = ENTITY_STATE;
1010            !!!next-input-character;
1011            redo A;
1012          } elsif ($self->{nc} == 0x003C) { # <
1013            !!!cp (0.2);
1014            $self->{state} = TAG_OPEN_STATE;
1015            !!!next-input-character;
1016            redo A;
1017          } elsif ($self->{nc} == -1) {
1018            !!!cp (0.3);
1019            !!!emit ({type => END_OF_FILE_TOKEN,
1020                      line => $self->{line}, column => $self->{column}});
1021            last A; ## TODO: ok?
1022          } else {
1023            !!!cp (0.4);
1024            #
1025          }
1026    
1027          # Anything else
1028          my $token = {type => CHARACTER_TOKEN,
1029                       data => chr $self->{nc},
1030                       line => $self->{line}, column => $self->{column},
1031                      };
1032          $self->{read_until}->($token->{data}, q[<&], length $token->{data});
1033    
1034          ## Stay in the state.
1035          !!!next-input-character;
1036          !!!emit ($token);
1037          redo A;
1038        } elsif ($self->{state} == DATA_STATE) {
1039          $self->{s_kwd} = '' unless defined $self->{s_kwd};
1040          if ($self->{nc} == 0x0026) { # &
1041            $self->{s_kwd} = '';
1042          if ($self->{content_model} & CM_ENTITY and # PCDATA | RCDATA          if ($self->{content_model} & CM_ENTITY and # PCDATA | RCDATA
1043              not $self->{escape}) {              not $self->{escape}) {
1044            !!!cp (1);            !!!cp (1);
# Line 1005  sub _get_next_token ($) { Line 1057  sub _get_next_token ($) {
1057          }          }
1058        } elsif ($self->{nc} == 0x002D) { # -        } elsif ($self->{nc} == 0x002D) { # -
1059          if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA          if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
1060            unless ($self->{escape}) {            $self->{s_kwd} .= '-';
1061              if ($self->{prev_char}->[0] == 0x002D and # -            
1062                  $self->{prev_char}->[1] == 0x0021 and # !            if ($self->{s_kwd} eq '<!--') {
1063                  $self->{prev_char}->[2] == 0x003C) { # <              !!!cp (3);
1064                !!!cp (3);              $self->{escape} = 1; # unless $self->{escape};
1065                $self->{escape} = 1;              $self->{s_kwd} = '--';
1066              } else {              #
1067                !!!cp (4);            } elsif ($self->{s_kwd} eq '---') {
1068              }              !!!cp (4);
1069                $self->{s_kwd} = '--';
1070                #
1071            } else {            } else {
1072              !!!cp (5);              !!!cp (5);
1073                #
1074            }            }
1075          }          }
1076                    
1077          #          #
1078          } elsif ($self->{nc} == 0x0021) { # !
1079            if (length $self->{s_kwd}) {
1080              !!!cp (5.1);
1081              $self->{s_kwd} .= '!';
1082              #
1083            } else {
1084              !!!cp (5.2);
1085              #$self->{s_kwd} = '';
1086              #
1087            }
1088            #
1089        } elsif ($self->{nc} == 0x003C) { # <        } elsif ($self->{nc} == 0x003C) { # <
1090          if ($self->{content_model} & CM_FULL_MARKUP or # PCDATA          if ($self->{content_model} & CM_FULL_MARKUP or # PCDATA
1091              (($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 1096  sub _get_next_token ($) {
1096            redo A;            redo A;
1097          } else {          } else {
1098            !!!cp (7);            !!!cp (7);
1099              $self->{s_kwd} = '';
1100            #            #
1101          }          }
1102        } elsif ($self->{nc} == 0x003E) { # >        } elsif ($self->{nc} == 0x003E) { # >
1103          if ($self->{escape} and          if ($self->{escape} and
1104              ($self->{content_model} & CM_LIMITED_MARKUP)) { # RCDATA | CDATA              ($self->{content_model} & CM_LIMITED_MARKUP)) { # RCDATA | CDATA
1105            if ($self->{prev_char}->[0] == 0x002D and # -            if ($self->{s_kwd} eq '--') {
               $self->{prev_char}->[1] == 0x002D) { # -  
1106              !!!cp (8);              !!!cp (8);
1107              delete $self->{escape};              delete $self->{escape};
1108            } else {            } else {
# Line 1046  sub _get_next_token ($) { Line 1112  sub _get_next_token ($) {
1112            !!!cp (10);            !!!cp (10);
1113          }          }
1114                    
1115            $self->{s_kwd} = '';
1116          #          #
1117        } elsif ($self->{nc} == -1) {        } elsif ($self->{nc} == -1) {
1118          !!!cp (11);          !!!cp (11);
1119            $self->{s_kwd} = '';
1120          !!!emit ({type => END_OF_FILE_TOKEN,          !!!emit ({type => END_OF_FILE_TOKEN,
1121                    line => $self->{line}, column => $self->{column}});                    line => $self->{line}, column => $self->{column}});
1122          last A; ## TODO: ok?          last A; ## TODO: ok?
1123        } else {        } else {
1124          !!!cp (12);          !!!cp (12);
1125            $self->{s_kwd} = '';
1126            #
1127        }        }
1128    
1129        # Anything else        # Anything else
1130        my $token = {type => CHARACTER_TOKEN,        my $token = {type => CHARACTER_TOKEN,
1131                     data => chr $self->{nc},                     data => chr $self->{nc},
1132                     line => $self->{line}, column => $self->{column},                     line => $self->{line}, column => $self->{column},
1133                    };                    };
1134        $self->{read_until}->($token->{data}, q[-!<>&], length $token->{data});        if ($self->{read_until}->($token->{data}, q[-!<>&],
1135                                    length $token->{data})) {
1136            $self->{s_kwd} = '';
1137          }
1138    
1139        ## Stay in the data state        ## Stay in the data state.
1140          if ($self->{content_model} == PCDATA_CONTENT_MODEL) {
1141            !!!cp (13);
1142            $self->{state} = PCDATA_STATE;
1143          } else {
1144            !!!cp (14);
1145            ## Stay in the state.
1146          }
1147        !!!next-input-character;        !!!next-input-character;
   
1148        !!!emit ($token);        !!!emit ($token);
   
1149        redo A;        redo A;
1150      } elsif ($self->{state} == TAG_OPEN_STATE) {      } elsif ($self->{state} == TAG_OPEN_STATE) {
1151        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 1154  sub _get_next_token ($) {
1154            !!!next-input-character;            !!!next-input-character;
1155            $self->{state} = CLOSE_TAG_OPEN_STATE;            $self->{state} = CLOSE_TAG_OPEN_STATE;
1156            redo A;            redo A;
1157            } elsif ($self->{nc} == 0x0021) { # !
1158              !!!cp (15.1);
1159              $self->{s_kwd} = '<' unless $self->{escape};
1160              #
1161          } else {          } else {
1162            !!!cp (16);            !!!cp (16);
1163            ## reconsume            #
           $self->{state} = DATA_STATE;  
   
           !!!emit ({type => CHARACTER_TOKEN, data => '<',  
                     line => $self->{line_prev},  
                     column => $self->{column_prev},  
                    });  
   
           redo A;  
1164          }          }
1165    
1166            ## reconsume
1167            $self->{state} = DATA_STATE;
1168            !!!emit ({type => CHARACTER_TOKEN, data => '<',
1169                      line => $self->{line_prev},
1170                      column => $self->{column_prev},
1171                     });
1172            redo A;
1173        } elsif ($self->{content_model} & CM_FULL_MARKUP) { # PCDATA        } elsif ($self->{content_model} & CM_FULL_MARKUP) { # PCDATA
1174          if ($self->{nc} == 0x0021) { # !          if ($self->{nc} == 0x0021) { # !
1175            !!!cp (17);            !!!cp (17);
# Line 1165  sub _get_next_token ($) { Line 1248  sub _get_next_token ($) {
1248        }        }
1249      } elsif ($self->{state} == CLOSE_TAG_OPEN_STATE) {      } elsif ($self->{state} == CLOSE_TAG_OPEN_STATE) {
1250        ## NOTE: The "close tag open state" in the spec is implemented as        ## NOTE: The "close tag open state" in the spec is implemented as
1251        ## |CLOSE_TAG_OPEN_STATE| and |CDATA_PCDATA_CLOSE_TAG_STATE|.        ## |CLOSE_TAG_OPEN_STATE| and |CDATA_RCDATA_CLOSE_TAG_STATE|.
1252    
1253        my ($l, $c) = ($self->{line_prev}, $self->{column_prev} - 1); # "<"of"</"        my ($l, $c) = ($self->{line_prev}, $self->{column_prev} - 1); # "<"of"</"
1254        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
1255          if (defined $self->{last_stag_name}) {          if (defined $self->{last_stag_name}) {
1256            $self->{state} = CDATA_PCDATA_CLOSE_TAG_STATE;            $self->{state} = CDATA_RCDATA_CLOSE_TAG_STATE;
1257            $self->{s_kwd} = '';            $self->{s_kwd} = '';
1258            ## Reconsume.            ## Reconsume.
1259            redo A;            redo A;
# Line 1241  sub _get_next_token ($) { Line 1324  sub _get_next_token ($) {
1324          ## "bogus comment state" entry.          ## "bogus comment state" entry.
1325          redo A;          redo A;
1326        }        }
1327      } elsif ($self->{state} == CDATA_PCDATA_CLOSE_TAG_STATE) {      } elsif ($self->{state} == CDATA_RCDATA_CLOSE_TAG_STATE) {
1328        my $ch = substr $self->{last_stag_name}, length $self->{s_kwd}, 1;        my $ch = substr $self->{last_stag_name}, length $self->{s_kwd}, 1;
1329        if (length $ch) {        if (length $ch) {
1330          my $CH = $ch;          my $CH = $ch;
# Line 1265  sub _get_next_token ($) { Line 1348  sub _get_next_token ($) {
1348            redo A;            redo A;
1349          }          }
1350        } else { # after "<{tag-name}"        } else { # after "<{tag-name}"
1351          unless ({          unless ($is_space->{$self->{nc}} or
1352                   0x0009 => 1, # HT                  {
                  0x000A => 1, # LF  
                  0x000B => 1, # VT  
                  0x000C => 1, # FF  
                  0x0020 => 1, # SP  
1353                   0x003E => 1, # >                   0x003E => 1, # >
1354                   0x002F => 1, # /                   0x002F => 1, # /
1355                   -1 => 1, # EOF                   -1 => 1, # EOF
# Line 1297  sub _get_next_token ($) { Line 1376  sub _get_next_token ($) {
1376          }          }
1377        }        }
1378      } elsif ($self->{state} == TAG_NAME_STATE) {      } elsif ($self->{state} == TAG_NAME_STATE) {
1379        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  
1380          !!!cp (34);          !!!cp (34);
1381          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
1382          !!!next-input-character;          !!!next-input-character;
# Line 1373  sub _get_next_token ($) { Line 1448  sub _get_next_token ($) {
1448          redo A;          redo A;
1449        }        }
1450      } elsif ($self->{state} == BEFORE_ATTRIBUTE_NAME_STATE) {      } elsif ($self->{state} == BEFORE_ATTRIBUTE_NAME_STATE) {
1451        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  
1452          !!!cp (45);          !!!cp (45);
1453          ## Stay in the state          ## Stay in the state
1454          !!!next-input-character;          !!!next-input-character;
# Line 1473  sub _get_next_token ($) { Line 1544  sub _get_next_token ($) {
1544          }          }
1545        }; # $before_leave        }; # $before_leave
1546    
1547        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  
1548          !!!cp (59);          !!!cp (59);
1549          $before_leave->();          $before_leave->();
1550          $self->{state} = AFTER_ATTRIBUTE_NAME_STATE;          $self->{state} = AFTER_ATTRIBUTE_NAME_STATE;
# Line 1560  sub _get_next_token ($) { Line 1627  sub _get_next_token ($) {
1627          redo A;          redo A;
1628        }        }
1629      } elsif ($self->{state} == AFTER_ATTRIBUTE_NAME_STATE) {      } elsif ($self->{state} == AFTER_ATTRIBUTE_NAME_STATE) {
1630        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  
1631          !!!cp (71);          !!!cp (71);
1632          ## Stay in the state          ## Stay in the state
1633          !!!next-input-character;          !!!next-input-character;
# Line 1651  sub _get_next_token ($) { Line 1714  sub _get_next_token ($) {
1714          redo A;                  redo A;        
1715        }        }
1716      } elsif ($self->{state} == BEFORE_ATTRIBUTE_VALUE_STATE) {      } elsif ($self->{state} == BEFORE_ATTRIBUTE_VALUE_STATE) {
1717        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        
1718          !!!cp (83);          !!!cp (83);
1719          ## Stay in the state          ## Stay in the state
1720          !!!next-input-character;          !!!next-input-character;
# Line 1836  sub _get_next_token ($) { Line 1895  sub _get_next_token ($) {
1895          redo A;          redo A;
1896        }        }
1897      } elsif ($self->{state} == ATTRIBUTE_VALUE_UNQUOTED_STATE) {      } elsif ($self->{state} == ATTRIBUTE_VALUE_UNQUOTED_STATE) {
1898        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  
1899          !!!cp (107);          !!!cp (107);
1900          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
1901          !!!next-input-character;          !!!next-input-character;
# Line 1922  sub _get_next_token ($) { Line 1977  sub _get_next_token ($) {
1977          redo A;          redo A;
1978        }        }
1979      } elsif ($self->{state} == AFTER_ATTRIBUTE_VALUE_QUOTED_STATE) {      } elsif ($self->{state} == AFTER_ATTRIBUTE_VALUE_QUOTED_STATE) {
1980        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  
1981          !!!cp (118);          !!!cp (118);
1982          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;          $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;
1983          !!!next-input-character;          !!!next-input-character;
# Line 2367  sub _get_next_token ($) { Line 2418  sub _get_next_token ($) {
2418          redo A;          redo A;
2419        }        }
2420      } elsif ($self->{state} == DOCTYPE_STATE) {      } elsif ($self->{state} == DOCTYPE_STATE) {
2421        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  
2422          !!!cp (155);          !!!cp (155);
2423          $self->{state} = BEFORE_DOCTYPE_NAME_STATE;          $self->{state} = BEFORE_DOCTYPE_NAME_STATE;
2424          !!!next-input-character;          !!!next-input-character;
# Line 2384  sub _get_next_token ($) { Line 2431  sub _get_next_token ($) {
2431          redo A;          redo A;
2432        }        }
2433      } elsif ($self->{state} == BEFORE_DOCTYPE_NAME_STATE) {      } elsif ($self->{state} == BEFORE_DOCTYPE_NAME_STATE) {
2434        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  
2435          !!!cp (157);          !!!cp (157);
2436          ## Stay in the state          ## Stay in the state
2437          !!!next-input-character;          !!!next-input-character;
# Line 2422  sub _get_next_token ($) { Line 2465  sub _get_next_token ($) {
2465        }        }
2466      } elsif ($self->{state} == DOCTYPE_NAME_STATE) {      } elsif ($self->{state} == DOCTYPE_NAME_STATE) {
2467  ## ISSUE: Redundant "First," in the spec.  ## ISSUE: Redundant "First," in the spec.
2468        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  
2469          !!!cp (161);          !!!cp (161);
2470          $self->{state} = AFTER_DOCTYPE_NAME_STATE;          $self->{state} = AFTER_DOCTYPE_NAME_STATE;
2471          !!!next-input-character;          !!!next-input-character;
# Line 2458  sub _get_next_token ($) { Line 2497  sub _get_next_token ($) {
2497          redo A;          redo A;
2498        }        }
2499      } elsif ($self->{state} == AFTER_DOCTYPE_NAME_STATE) {      } elsif ($self->{state} == AFTER_DOCTYPE_NAME_STATE) {
2500        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  
2501          !!!cp (165);          !!!cp (165);
2502          ## Stay in the state          ## Stay in the state
2503          !!!next-input-character;          !!!next-input-character;
# Line 2585  sub _get_next_token ($) { Line 2620  sub _get_next_token ($) {
2620          redo A;          redo A;
2621        }        }
2622      } elsif ($self->{state} == BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {      } elsif ($self->{state} == BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {
2623        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}}) {  
2624          !!!cp (181);          !!!cp (181);
2625          ## Stay in the state          ## Stay in the state
2626          !!!next-input-character;          !!!next-input-character;
# Line 2715  sub _get_next_token ($) { Line 2747  sub _get_next_token ($) {
2747          redo A;          redo A;
2748        }        }
2749      } elsif ($self->{state} == AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {      } elsif ($self->{state} == AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {
2750        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}}) {  
2751          !!!cp (195);          !!!cp (195);
2752          ## Stay in the state          ## Stay in the state
2753          !!!next-input-character;          !!!next-input-character;
# Line 2764  sub _get_next_token ($) { Line 2793  sub _get_next_token ($) {
2793          redo A;          redo A;
2794        }        }
2795      } elsif ($self->{state} == BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {      } elsif ($self->{state} == BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {
2796        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}}) {  
2797          !!!cp (201);          !!!cp (201);
2798          ## Stay in the state          ## Stay in the state
2799          !!!next-input-character;          !!!next-input-character;
# Line 2893  sub _get_next_token ($) { Line 2919  sub _get_next_token ($) {
2919          redo A;          redo A;
2920        }        }
2921      } elsif ($self->{state} == AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {      } elsif ($self->{state} == AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {
2922        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}}) {  
2923          !!!cp (215);          !!!cp (215);
2924          ## Stay in the state          ## Stay in the state
2925          !!!next-input-character;          !!!next-input-character;
# Line 3028  sub _get_next_token ($) { Line 3051  sub _get_next_token ($) {
3051          redo A;          redo A;
3052        }        }
3053      } elsif ($self->{state} == ENTITY_STATE) {      } elsif ($self->{state} == ENTITY_STATE) {
3054        if ({        if ($is_space->{$self->{nc}} or
3055          0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, # HT, LF, VT, FF,            {
3056          0x0020 => 1, 0x003C => 1, 0x0026 => 1, -1 => 1, # SP, <, &              0x003C => 1, 0x0026 => 1, -1 => 1, # <, &
3057          $self->{entity_add} => 1,              $self->{entity_add} => 1,
3058        }->{$self->{nc}}) {            }->{$self->{nc}}) {
3059          !!!cp (1001);          !!!cp (1001);
3060          ## Don't consume          ## Don't consume
3061          ## No error          ## No error
# Line 3630  sub _tree_construction_initial ($) { Line 3653  sub _tree_construction_initial ($) {
3653        !!!ack-later;        !!!ack-later;
3654        return;        return;
3655      } elsif ($token->{type} == CHARACTER_TOKEN) {      } elsif ($token->{type} == CHARACTER_TOKEN) {
3656        if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D        if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
3657          ## Ignore the token          ## Ignore the token
3658    
3659          unless (length $token->{data}) {          unless (length $token->{data}) {
# Line 3687  sub _tree_construction_root_element ($) Line 3710  sub _tree_construction_root_element ($)
3710          !!!next-token;          !!!next-token;
3711          redo B;          redo B;
3712        } elsif ($token->{type} == CHARACTER_TOKEN) {        } elsif ($token->{type} == CHARACTER_TOKEN) {
3713          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D          if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
3714            ## Ignore the token.            ## Ignore the token.
3715    
3716            unless (length $token->{data}) {            unless (length $token->{data}) {
# Line 4501  sub _tree_construction_main ($) { Line 4524  sub _tree_construction_main ($) {
4524    
4525      if ($self->{insertion_mode} & HEAD_IMS) {      if ($self->{insertion_mode} & HEAD_IMS) {
4526        if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == CHARACTER_TOKEN) {
4527          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
4528            unless ($self->{insertion_mode} == BEFORE_HEAD_IM) {            unless ($self->{insertion_mode} == BEFORE_HEAD_IM) {
4529              !!!cp ('t88.2');              !!!cp ('t88.2');
4530              $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 4703  sub _tree_construction_main ($) {
4703                  } elsif ($token->{attributes}->{content}) {                  } elsif ($token->{attributes}->{content}) {
4704                    if ($token->{attributes}->{content}->{value}                    if ($token->{attributes}->{content}->{value}
4705                        =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt]                        =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt]
4706                            [\x09-\x0D\x20]*=                            [\x09\x0A\x0C\x0D\x20]*=
4707                            [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'|                            [\x09\x0A\x0C\x0D\x20]*(?>"([^"]*)"|'([^']*)'|
4708                            ([^"'\x09-\x0D\x20][^\x09-\x0D\x20\x3B]*))/x) {                            ([^"'\x09\x0A\x0C\x0D\x20]
4709                               [^\x09\x0A\x0C\x0D\x20\x3B]*))/x) {
4710                      !!!cp ('t107');                      !!!cp ('t107');
4711                      ## NOTE: Whether the encoding is supported or not is handled                      ## NOTE: Whether the encoding is supported or not is handled
4712                      ## in the {change_encoding} callback.                      ## in the {change_encoding} callback.
# Line 5491  sub _tree_construction_main ($) { Line 5515  sub _tree_construction_main ($) {
5515      } elsif ($self->{insertion_mode} & TABLE_IMS) {      } elsif ($self->{insertion_mode} & TABLE_IMS) {
5516        if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == CHARACTER_TOKEN) {
5517          if (not $open_tables->[-1]->[1] and # tainted          if (not $open_tables->[-1]->[1] and # tainted
5518              $token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {              $token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
5519            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
5520                                
5521            unless (length $token->{data}) {            unless (length $token->{data}) {
# Line 6175  sub _tree_construction_main ($) { Line 6199  sub _tree_construction_main ($) {
6199        }        }
6200      } elsif ($self->{insertion_mode} == IN_COLUMN_GROUP_IM) {      } elsif ($self->{insertion_mode} == IN_COLUMN_GROUP_IM) {
6201            if ($token->{type} == CHARACTER_TOKEN) {            if ($token->{type} == CHARACTER_TOKEN) {
6202              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {              if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
6203                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
6204                unless (length $token->{data}) {                unless (length $token->{data}) {
6205                  !!!cp ('t260');                  !!!cp ('t260');
# Line 6516  sub _tree_construction_main ($) { Line 6540  sub _tree_construction_main ($) {
6540        }        }
6541      } elsif ($self->{insertion_mode} & BODY_AFTER_IMS) {      } elsif ($self->{insertion_mode} & BODY_AFTER_IMS) {
6542        if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == CHARACTER_TOKEN) {
6543          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
6544            my $data = $1;            my $data = $1;
6545            ## As if in body            ## As if in body
6546            $reconstruct_active_formatting_elements->($insert_to_current);            $reconstruct_active_formatting_elements->($insert_to_current);
# Line 6533  sub _tree_construction_main ($) { Line 6557  sub _tree_construction_main ($) {
6557          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
6558            !!!cp ('t301');            !!!cp ('t301');
6559            !!!parse-error (type => 'after html:#text', token => $token);            !!!parse-error (type => 'after html:#text', token => $token);
6560              #
           ## Reprocess in the "after body" insertion mode.  
6561          } else {          } else {
6562            !!!cp ('t302');            !!!cp ('t302');
6563              ## "after body" insertion mode
6564              !!!parse-error (type => 'after body:#text', token => $token);
6565              #
6566          }          }
           
         ## "after body" insertion mode  
         !!!parse-error (type => 'after body:#text', token => $token);  
6567    
6568          $self->{insertion_mode} = IN_BODY_IM;          $self->{insertion_mode} = IN_BODY_IM;
6569          ## reprocess          ## reprocess
# Line 6550  sub _tree_construction_main ($) { Line 6573  sub _tree_construction_main ($) {
6573            !!!cp ('t303');            !!!cp ('t303');
6574            !!!parse-error (type => 'after html',            !!!parse-error (type => 'after html',
6575                            text => $token->{tag_name}, token => $token);                            text => $token->{tag_name}, token => $token);
6576                        #
           ## Reprocess in the "after body" insertion mode.  
6577          } else {          } else {
6578            !!!cp ('t304');            !!!cp ('t304');
6579              ## "after body" insertion mode
6580              !!!parse-error (type => 'after body',
6581                              text => $token->{tag_name}, token => $token);
6582              #
6583          }          }
6584    
         ## "after body" insertion mode  
         !!!parse-error (type => 'after body',  
                         text => $token->{tag_name}, token => $token);  
   
6585          $self->{insertion_mode} = IN_BODY_IM;          $self->{insertion_mode} = IN_BODY_IM;
6586          !!!ack-later;          !!!ack-later;
6587          ## reprocess          ## reprocess
# Line 6570  sub _tree_construction_main ($) { Line 6592  sub _tree_construction_main ($) {
6592            !!!parse-error (type => 'after html:/',            !!!parse-error (type => 'after html:/',
6593                            text => $token->{tag_name}, token => $token);                            text => $token->{tag_name}, token => $token);
6594                        
6595            $self->{insertion_mode} = AFTER_BODY_IM;            $self->{insertion_mode} = IN_BODY_IM;
6596            ## Reprocess in the "after body" insertion mode.            ## Reprocess.
6597              next B;
6598          } else {          } else {
6599            !!!cp ('t306');            !!!cp ('t306');
6600          }          }
# Line 6609  sub _tree_construction_main ($) { Line 6632  sub _tree_construction_main ($) {
6632        }        }
6633      } elsif ($self->{insertion_mode} & FRAME_IMS) {      } elsif ($self->{insertion_mode} & FRAME_IMS) {
6634        if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == CHARACTER_TOKEN) {
6635          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
6636            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
6637                        
6638            unless (length $token->{data}) {            unless (length $token->{data}) {
# Line 6619  sub _tree_construction_main ($) { Line 6642  sub _tree_construction_main ($) {
6642            }            }
6643          }          }
6644                    
6645          if ($token->{data} =~ s/^[^\x09\x0A\x0B\x0C\x20]+//) {          if ($token->{data} =~ s/^[^\x09\x0A\x0C\x20]+//) {
6646            if ($self->{insertion_mode} == IN_FRAMESET_IM) {            if ($self->{insertion_mode} == IN_FRAMESET_IM) {
6647              !!!cp ('t311');              !!!cp ('t311');
6648              !!!parse-error (type => 'in frameset:#text', token => $token);              !!!parse-error (type => 'in frameset:#text', token => $token);
# Line 6796  sub _tree_construction_main ($) { Line 6819  sub _tree_construction_main ($) {
6819            } elsif ($token->{attributes}->{content}) {            } elsif ($token->{attributes}->{content}) {
6820              if ($token->{attributes}->{content}->{value}              if ($token->{attributes}->{content}->{value}
6821                  =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt]                  =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt]
6822                      [\x09-\x0D\x20]*=                      [\x09\x0A\x0C\x0D\x20]*=
6823                      [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'|                      [\x09\x0A\x0C\x0D\x20]*(?>"([^"]*)"|'([^']*)'|
6824                      ([^"'\x09-\x0D\x20][^\x09-\x0D\x20\x3B]*))/x) {                      ([^"'\x09\x0A\x0C\x0D\x20][^\x09\x0A\x0C\x0D\x20\x3B]*))
6825                       /x) {
6826                !!!cp ('t336');                !!!cp ('t336');
6827                ## NOTE: Whether the encoding is supported or not is handled                ## NOTE: Whether the encoding is supported or not is handled
6828                ## in the {change_encoding} callback.                ## in the {change_encoding} callback.
# Line 7882  sub set_inner_html ($$$$;$) { Line 7906  sub set_inner_html ($$$$;$) {
7906              $p->{char_buffer_pos} += $count;              $p->{char_buffer_pos} += $count;
7907              $p->{line_prev} = $p->{line};              $p->{line_prev} = $p->{line};
7908              $p->{column_prev} = $p->{column} - 1;              $p->{column_prev} = $p->{column} - 1;
             $p->{prev_char} = [-1, -1, -1];  
7909              $p->{nc} = -1;              $p->{nc} = -1;
7910            }            }
7911            return $count;            return $count;
# Line 7894  sub set_inner_html ($$$$;$) { Line 7917  sub set_inner_html ($$$$;$) {
7917          if ($count) {          if ($count) {
7918            $p->{column} += $count;            $p->{column} += $count;
7919            $p->{column_prev} += $count;            $p->{column_prev} += $count;
           $p->{prev_char} = [-1, -1, -1];  
7920            $p->{nc} = -1;            $p->{nc} = -1;
7921          }          }
7922          return $count;          return $count;
Legend:
Removed from v.1.183  
changed lines
  Added in v.1.190
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.24