/[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.172 by wakaba, Sun Sep 14 03:07:58 2008 UTC revision 1.180 by wakaba, Sun Sep 14 14:35:43 2008 UTC
# Line 496  sub parse_byte_stream ($$$$;$$) { Line 496  sub parse_byte_stream ($$$$;$$) {
496                      line => 1, column => 1,                      line => 1, column => 1,
497                      layer => 'encode');                      layer => 'encode');
498    } elsif (not ($e_status &    } elsif (not ($e_status &
499                  Message::Charset::Info::ERROR_REPORTING_ENCODING_IMPL())) {                  Message::Charset::Info::ERROR_REPORTING_ENCODING_IMPL ())) {
500      $self->{input_encoding} = $charset->get_iana_name;      $self->{input_encoding} = $charset->get_iana_name;
501      !!!parse-error (type => 'chardecode:no error',      !!!parse-error (type => 'chardecode:no error',
502                      text => $self->{input_encoding},                      text => $self->{input_encoding},
# Line 561  sub parse_byte_stream ($$$$;$$) { Line 561  sub parse_byte_stream ($$$$;$$) {
561    my $char_onerror = sub {    my $char_onerror = sub {
562      my (undef, $type, %opt) = @_;      my (undef, $type, %opt) = @_;
563      !!!parse-error (layer => 'encode',      !!!parse-error (layer => 'encode',
564                      %opt, type => $type,                      line => $self->{line}, column => $self->{column} + 1,
565                      line => $self->{line}, column => $self->{column} + 1);                      %opt, type => $type);
566      if ($opt{octets}) {      if ($opt{octets}) {
567        ${$opt{octets}} = "\x{FFFD}"; # relacement character        ${$opt{octets}} = "\x{FFFD}"; # relacement character
568      }      }
# Line 586  sub parse_byte_stream ($$$$;$$) { Line 586  sub parse_byte_stream ($$$$;$$) {
586                        line => 1, column => 1,                        line => 1, column => 1,
587                        layer => 'encode');                        layer => 'encode');
588      } elsif (not ($e_status &      } elsif (not ($e_status &
589                    Message::Charset::Info::ERROR_REPORTING_ENCODING_IMPL())) {                    Message::Charset::Info::ERROR_REPORTING_ENCODING_IMPL ())) {
590        $self->{input_encoding} = $charset->get_iana_name;        $self->{input_encoding} = $charset->get_iana_name;
591        !!!parse-error (type => 'chardecode:no error',        !!!parse-error (type => 'chardecode:no error',
592                        text => $self->{input_encoding},                        text => $self->{input_encoding},
# Line 639  sub parse_char_stream ($$$;$) { Line 639  sub parse_char_stream ($$$;$) {
639    $self->{confident} = 1 unless exists $self->{confident};    $self->{confident} = 1 unless exists $self->{confident};
640    $self->{document}->input_encoding ($self->{input_encoding})    $self->{document}->input_encoding ($self->{input_encoding})
641        if defined $self->{input_encoding};        if defined $self->{input_encoding};
642    ## TODO: |{input_encoding}| is needless?
643    
644    my $i = 0;    my $i = 0;
645    $self->{line_prev} = $self->{line} = 1;    $self->{line_prev} = $self->{line} = 1;
646    $self->{column_prev} = $self->{column} = 0;    $self->{column_prev} = -1;
647      $self->{column} = 0;
648    $self->{set_next_char} = sub {    $self->{set_next_char} = sub {
649      my $self = shift;      my $self = shift;
650    
651      pop @{$self->{prev_char}};      my $char = '';
     unshift @{$self->{prev_char}}, $self->{next_char};  
   
     my $char;  
652      if (defined $self->{next_next_char}) {      if (defined $self->{next_next_char}) {
653        $char = $self->{next_next_char};        $char = $self->{next_next_char};
654        delete $self->{next_next_char};        delete $self->{next_next_char};
655          $self->{next_char} = ord $char;
656      } else {      } else {
657        $char = $input->getc;        $self->{char_buffer} = '';
658          $self->{char_buffer_pos} = 0;
659    
660          my $count = $input->manakai_read_until
661             ($self->{char_buffer},
662              qr/(?![\x{FDD0}-\x{FDDF}\x{FFFE}\x{FFFF}\x{1FFFE}\x{1FFFF}\x{2FFFE}\x{2FFFF}\x{3FFFE}\x{3FFFF}\x{4FFFE}\x{4FFFF}\x{5FFFE}\x{5FFFF}\x{6FFFE}\x{6FFFF}\x{7FFFE}\x{7FFFF}\x{8FFFE}\x{8FFFF}\x{9FFFE}\x{9FFFF}\x{AFFFE}\x{AFFFF}\x{BFFFE}\x{BFFFF}\x{CFFFE}\x{CFFFF}\x{DFFFE}\x{DFFFF}\x{EFFFE}\x{EFFFF}\x{FFFFE}\x{FFFFF}])[\x20-\x7E\xA0-\x{D7FF}\x{E000}-\x{10FFFD}]/,
663              $self->{char_buffer_pos});
664          if ($count) {
665            $self->{line_prev} = $self->{line};
666            $self->{column_prev} = $self->{column};
667            $self->{column}++;
668            $self->{next_char}
669                = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
670            return;
671          }
672    
673          if ($input->read ($char, 1)) {
674            $self->{next_char} = ord $char;
675          } else {
676            $self->{next_char} = -1;
677            return;
678          }
679      }      }
     $self->{next_char} = -1 and return unless defined $char;  
     $self->{next_char} = ord $char;  
680    
681      ($self->{line_prev}, $self->{column_prev})      ($self->{line_prev}, $self->{column_prev})
682          = ($self->{line}, $self->{column});          = ($self->{line}, $self->{column});
# Line 670  sub parse_char_stream ($$$;$) { Line 689  sub parse_char_stream ($$$;$) {
689      } elsif ($self->{next_char} == 0x000D) { # CR      } elsif ($self->{next_char} == 0x000D) { # CR
690        !!!cp ('j2');        !!!cp ('j2');
691  ## TODO: support for abort/streaming  ## TODO: support for abort/streaming
692        my $next = $input->getc;        my $next = '';
693        if (defined $next and $next ne "\x0A") {        if ($input->read ($next, 1) and $next ne "\x0A") {
694          $self->{next_next_char} = $next;          $self->{next_next_char} = $next;
695        }        }
696        $self->{next_char} = 0x000A; # LF # MUST        $self->{next_char} = 0x000A; # LF # MUST
# Line 711  sub parse_char_stream ($$$;$) { Line 730  sub parse_char_stream ($$$;$) {
730        }        }
731      }      }
732    };    };
   $self->{prev_char} = [-1, -1, -1];  
   $self->{next_char} = -1;  
733    
734    $self->{read_until} = sub {    $self->{read_until} = sub {
735      #my ($scalar, $specials_range, $offset) = @_;      #my ($scalar, $specials_range, $offset) = @_;
     my $specials_range = $_[1];  
736      return 0 if defined $self->{next_next_char};      return 0 if defined $self->{next_next_char};
737      my $count = $input->manakai_read_until  
738         ($_[0],      my $pattern = qr/(?![$_[1]\x{FDD0}-\x{FDDF}\x{FFFE}\x{FFFF}\x{1FFFE}\x{1FFFF}\x{2FFFE}\x{2FFFF}\x{3FFFE}\x{3FFFF}\x{4FFFE}\x{4FFFF}\x{5FFFE}\x{5FFFF}\x{6FFFE}\x{6FFFF}\x{7FFFE}\x{7FFFF}\x{8FFFE}\x{8FFFF}\x{9FFFE}\x{9FFFF}\x{AFFFE}\x{AFFFF}\x{BFFFE}\x{BFFFF}\x{CFFFE}\x{CFFFF}\x{DFFFE}\x{DFFFF}\x{EFFFE}\x{EFFFF}\x{FFFFE}\x{FFFFF}])[\x20-\x7E\xA0-\x{D7FF}\x{E000}-\x{10FFFD}]/;
739          qr/(?![$specials_range\x{FDD0}-\x{FDDF}\x{FFFE}\x{FFFF}\x{1FFFE}\x{1FFFF}\x{2FFFE}\x{2FFFF}\x{3FFFE}\x{3FFFF}\x{4FFFE}\x{4FFFF}\x{5FFFE}\x{5FFFF}\x{6FFFE}\x{6FFFF}\x{7FFFE}\x{7FFFF}\x{8FFFE}\x{8FFFF}\x{9FFFE}\x{9FFFF}\x{AFFFE}\x{AFFFF}\x{BFFFE}\x{BFFFF}\x{CFFFE}\x{CFFFF}\x{DFFFE}\x{DFFFF}\x{EFFFE}\x{EFFFF}\x{FFFFE}\x{FFFFF}])[\x20-\x7E\xA0-\x{D7FF}\x{E000}-\x{10FFFD}]/,      my $offset = $_[2] || 0;
740          $_[2]);  
741      if ($count) {      if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
742        $self->{column} += $count;        pos ($self->{char_buffer}) = $self->{char_buffer_pos};
743        $self->{column_prev} += $count;        if ($self->{char_buffer} =~ /\G(?>$pattern)+/) {
744        $self->{prev_char} = [-1, -1, -1];          substr ($_[0], $offset)
745        $self->{next_char} = -1;              = substr ($self->{char_buffer}, $-[0], $+[0] - $-[0]);
746            my $count = $+[0] - $-[0];
747            if ($count) {
748              $self->{column} += $count;
749              $self->{char_buffer_pos} += $count;
750              $self->{line_prev} = $self->{line};
751              $self->{column_prev} = $self->{column} - 1;
752              $self->{prev_char} = [-1, -1, -1];
753              $self->{next_char} = -1;
754            }
755            return $count;
756          } else {
757            return 0;
758          }
759        } else {
760          my $count = $input->manakai_read_until ($_[0], $pattern, $_[2]);
761          if ($count) {
762            $self->{column} += $count;
763            $self->{line_prev} = $self->{line};
764            $self->{column_prev} = $self->{column} - 1;
765            $self->{prev_char} = [-1, -1, -1];
766            $self->{next_char} = -1;
767          }
768          return $count;
769      }      }
     return $count;  
770    }; # $self->{read_until}    }; # $self->{read_until}
771    
772    my $onerror = $_[2] || sub {    my $onerror = $_[2] || sub {
# Line 901  sub _initialize_tokenizer ($) { Line 939  sub _initialize_tokenizer ($) {
939    undef $self->{last_emitted_start_tag_name};    undef $self->{last_emitted_start_tag_name};
940    #$self->{prev_state}; # initialized when used    #$self->{prev_state}; # initialized when used
941    delete $self->{self_closing};    delete $self->{self_closing};
942    # $self->{next_char}    $self->{char_buffer} = '';
943      $self->{char_buffer_pos} = 0;
944      $self->{prev_char} = [-1, -1, -1];
945      $self->{next_char} = -1;
946    !!!next-input-character;    !!!next-input-character;
947    $self->{token} = [];    $self->{token} = [];
948    # $self->{escape}    # $self->{escape}
# Line 1743  sub _get_next_token ($) { Line 1784  sub _get_next_token ($) {
1784        } else {        } else {
1785          !!!cp (100);          !!!cp (100);
1786          $self->{current_attribute}->{value} .= chr ($self->{next_char});          $self->{current_attribute}->{value} .= chr ($self->{next_char});
1787            $self->{read_until}->($self->{current_attribute}->{value},
1788                                  q["&],
1789                                  length $self->{current_attribute}->{value});
1790    
1791          ## Stay in the state          ## Stay in the state
1792          !!!next-input-character;          !!!next-input-character;
1793          redo A;          redo A;
# Line 1790  sub _get_next_token ($) { Line 1835  sub _get_next_token ($) {
1835        } else {        } else {
1836          !!!cp (106);          !!!cp (106);
1837          $self->{current_attribute}->{value} .= chr ($self->{next_char});          $self->{current_attribute}->{value} .= chr ($self->{next_char});
1838            $self->{read_until}->($self->{current_attribute}->{value},
1839                                  q['&],
1840                                  length $self->{current_attribute}->{value});
1841    
1842          ## Stay in the state          ## Stay in the state
1843          !!!next-input-character;          !!!next-input-character;
1844          redo A;          redo A;
# Line 1872  sub _get_next_token ($) { Line 1921  sub _get_next_token ($) {
1921            !!!cp (116);            !!!cp (116);
1922          }          }
1923          $self->{current_attribute}->{value} .= chr ($self->{next_char});          $self->{current_attribute}->{value} .= chr ($self->{next_char});
1924            $self->{read_until}->($self->{current_attribute}->{value},
1925                                  q["'=& >],
1926                                  length $self->{current_attribute}->{value});
1927    
1928          ## Stay in the state          ## Stay in the state
1929          !!!next-input-character;          !!!next-input-character;
1930          redo A;          redo A;
# Line 2016  sub _get_next_token ($) { Line 2069  sub _get_next_token ($) {
2069        } else {        } else {
2070          !!!cp (126);          !!!cp (126);
2071          $self->{current_token}->{data} .= chr ($self->{next_char}); # comment          $self->{current_token}->{data} .= chr ($self->{next_char}); # comment
2072            $self->{read_until}->($self->{current_token}->{data},
2073                                  q[>],
2074                                  length $self->{current_token}->{data});
2075    
2076          ## Stay in the state.          ## Stay in the state.
2077          !!!next-input-character;          !!!next-input-character;
2078          redo A;          redo A;
# Line 2250  sub _get_next_token ($) { Line 2307  sub _get_next_token ($) {
2307        } else {        } else {
2308          !!!cp (147);          !!!cp (147);
2309          $self->{current_token}->{data} .= chr ($self->{next_char}); # comment          $self->{current_token}->{data} .= chr ($self->{next_char}); # comment
2310            $self->{read_until}->($self->{current_token}->{data},
2311                                  q[-],
2312                                  length $self->{current_token}->{data});
2313    
2314          ## Stay in the state          ## Stay in the state
2315          !!!next-input-character;          !!!next-input-character;
2316          redo A;          redo A;
# Line 2615  sub _get_next_token ($) { Line 2676  sub _get_next_token ($) {
2676          !!!cp (190);          !!!cp (190);
2677          $self->{current_token}->{public_identifier} # DOCTYPE          $self->{current_token}->{public_identifier} # DOCTYPE
2678              .= chr $self->{next_char};              .= chr $self->{next_char};
2679            $self->{read_until}->($self->{current_token}->{public_identifier},
2680                                  q[">],
2681                                  length $self->{current_token}->{public_identifier});
2682    
2683          ## Stay in the state          ## Stay in the state
2684          !!!next-input-character;          !!!next-input-character;
2685          redo A;          redo A;
# Line 2651  sub _get_next_token ($) { Line 2716  sub _get_next_token ($) {
2716          !!!cp (194);          !!!cp (194);
2717          $self->{current_token}->{public_identifier} # DOCTYPE          $self->{current_token}->{public_identifier} # DOCTYPE
2718              .= chr $self->{next_char};              .= chr $self->{next_char};
2719            $self->{read_until}->($self->{current_token}->{public_identifier},
2720                                  q['>],
2721                                  length $self->{current_token}->{public_identifier});
2722    
2723          ## Stay in the state          ## Stay in the state
2724          !!!next-input-character;          !!!next-input-character;
2725          redo A;          redo A;
# Line 2787  sub _get_next_token ($) { Line 2856  sub _get_next_token ($) {
2856          !!!cp (210);          !!!cp (210);
2857          $self->{current_token}->{system_identifier} # DOCTYPE          $self->{current_token}->{system_identifier} # DOCTYPE
2858              .= chr $self->{next_char};              .= chr $self->{next_char};
2859            $self->{read_until}->($self->{current_token}->{system_identifier},
2860                                  q[">],
2861                                  length $self->{current_token}->{system_identifier});
2862    
2863          ## Stay in the state          ## Stay in the state
2864          !!!next-input-character;          !!!next-input-character;
2865          redo A;          redo A;
# Line 2823  sub _get_next_token ($) { Line 2896  sub _get_next_token ($) {
2896          !!!cp (214);          !!!cp (214);
2897          $self->{current_token}->{system_identifier} # DOCTYPE          $self->{current_token}->{system_identifier} # DOCTYPE
2898              .= chr $self->{next_char};              .= chr $self->{next_char};
2899            $self->{read_until}->($self->{current_token}->{system_identifier},
2900                                  q['>],
2901                                  length $self->{current_token}->{system_identifier});
2902    
2903          ## Stay in the state          ## Stay in the state
2904          !!!next-input-character;          !!!next-input-character;
2905          redo A;          redo A;
# Line 2883  sub _get_next_token ($) { Line 2960  sub _get_next_token ($) {
2960          redo A;          redo A;
2961        } else {        } else {
2962          !!!cp (221);          !!!cp (221);
2963            my $s = '';
2964            $self->{read_until}->($s, q[>], 0);
2965    
2966          ## Stay in the state          ## Stay in the state
2967          !!!next-input-character;          !!!next-input-character;
2968          redo A;          redo A;
# Line 2911  sub _get_next_token ($) { Line 2991  sub _get_next_token ($) {
2991        } else {        } else {
2992          !!!cp (221.4);          !!!cp (221.4);
2993          $self->{current_token}->{data} .= chr $self->{next_char};          $self->{current_token}->{data} .= chr $self->{next_char};
2994            $self->{read_until}->($self->{current_token}->{data},
2995                                  q<]>,
2996                                  length $self->{current_token}->{data});
2997    
2998          ## Stay in the state.          ## Stay in the state.
2999          !!!next-input-character;          !!!next-input-character;
3000          redo A;          redo A;
# Line 3297  sub _get_next_token ($) { Line 3381  sub _get_next_token ($) {
3381          !!!cp (1026);          !!!cp (1026);
3382          !!!parse-error (type => 'bare ero',          !!!parse-error (type => 'bare ero',
3383                          line => $self->{line_prev},                          line => $self->{line_prev},
3384                          column => $self->{column_prev});                          column => $self->{column_prev} - length $self->{state_keyword});
3385          $data = '&' . $self->{state_keyword};          $data = '&' . $self->{state_keyword};
3386          #          #
3387        }        }
# Line 4435  sub _tree_construction_main ($) { Line 4519  sub _tree_construction_main ($) {
4519            unless ($self->{insertion_mode} == BEFORE_HEAD_IM) {            unless ($self->{insertion_mode} == BEFORE_HEAD_IM) {
4520              !!!cp ('t88.2');              !!!cp ('t88.2');
4521              $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);              $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
4522                #
4523            } else {            } else {
4524              !!!cp ('t88.1');              !!!cp ('t88.1');
4525              ## Ignore the token.              ## Ignore the token.
4526              !!!next-token;              #
             next B;  
4527            }            }
4528            unless (length $token->{data}) {            unless (length $token->{data}) {
4529              !!!cp ('t88');              !!!cp ('t88');
4530              !!!next-token;              !!!next-token;
4531              next B;              next B;
4532            }            }
4533    ## TODO: set $token->{column} appropriately
4534          }          }
4535    
4536          if ($self->{insertion_mode} == BEFORE_HEAD_IM) {          if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
# Line 7690  sub _tree_construction_main ($) { Line 7775  sub _tree_construction_main ($) {
7775    ## TODO: script stuffs    ## TODO: script stuffs
7776  } # _tree_construct_main  } # _tree_construct_main
7777    
7778  sub set_inner_html ($$$;$) {  sub set_inner_html ($$$$;$) {
7779    my $class = shift;    my $class = shift;
7780    my $node = shift;    my $node = shift;
7781    my $s = \$_[0];    #my $s = \$_[0];
7782    my $onerror = $_[1];    my $onerror = $_[1];
7783    my $get_wrapper = $_[2] || sub ($) { return $_[0] };    my $get_wrapper = $_[2] || sub ($) { return $_[0] };
7784    
# Line 7714  sub set_inner_html ($$$;$) { Line 7799  sub set_inner_html ($$$;$) {
7799      }      }
7800    
7801      ## Step 3, 4, 5 # MUST      ## Step 3, 4, 5 # MUST
7802      $class->parse_char_string ($$s => $node, $onerror, $get_wrapper);      $class->parse_char_string ($_[0] => $node, $onerror, $get_wrapper);
7803    } elsif ($nt == 1) {    } elsif ($nt == 1) {
7804      ## TODO: If non-html element      ## TODO: If non-html element
7805    
# Line 7733  sub set_inner_html ($$$;$) { Line 7818  sub set_inner_html ($$$;$) {
7818      my $i = 0;      my $i = 0;
7819      $p->{line_prev} = $p->{line} = 1;      $p->{line_prev} = $p->{line} = 1;
7820      $p->{column_prev} = $p->{column} = 0;      $p->{column_prev} = $p->{column} = 0;
7821        require Whatpm::Charset::DecodeHandle;
7822        my $input = Whatpm::Charset::DecodeHandle::CharString->new (\($_[0]));
7823        $input = $get_wrapper->($input);
7824      $p->{set_next_char} = sub {      $p->{set_next_char} = sub {
7825        my $self = shift;        my $self = shift;
7826    
7827        pop @{$self->{prev_char}};        my $char = '';
7828        unshift @{$self->{prev_char}}, $self->{next_char};        if (defined $self->{next_next_char}) {
7829            $char = $self->{next_next_char};
7830        $self->{next_char} = -1 and return if $i >= length $$s;          delete $self->{next_next_char};
7831        $self->{next_char} = ord substr $$s, $i++, 1;          $self->{next_char} = ord $char;
7832          } else {
7833            $self->{char_buffer} = '';
7834            $self->{char_buffer_pos} = 0;
7835            
7836            my $count = $input->manakai_read_until
7837                ($self->{char_buffer},
7838                 qr/(?![\x{FDD0}-\x{FDDF}\x{FFFE}\x{FFFF}\x{1FFFE}\x{1FFFF}\x{2FFFE}\x{2FFFF}\x{3FFFE}\x{3FFFF}\x{4FFFE}\x{4FFFF}\x{5FFFE}\x{5FFFF}\x{6FFFE}\x{6FFFF}\x{7FFFE}\x{7FFFF}\x{8FFFE}\x{8FFFF}\x{9FFFE}\x{9FFFF}\x{AFFFE}\x{AFFFF}\x{BFFFE}\x{BFFFF}\x{CFFFE}\x{CFFFF}\x{DFFFE}\x{DFFFF}\x{EFFFE}\x{EFFFF}\x{FFFFE}\x{FFFFF}])[\x20-\x7E\xA0-\x{D7FF}\x{E000}-\x{10FFFD}]/,
7839                   $self->{char_buffer_pos});
7840            if ($count) {
7841              $self->{line_prev} = $self->{line};
7842              $self->{column_prev} = $self->{column};
7843              $self->{column}++;
7844              $self->{next_char}
7845                  = ord substr ($self->{char_buffer},
7846                                $self->{char_buffer_pos}++, 1);
7847              return;
7848            }
7849            
7850            if ($input->read ($char, 1)) {
7851              $self->{next_char} = ord $char;
7852            } else {
7853              $self->{next_char} = -1;
7854              return;
7855            }
7856          }
7857    
7858        ($p->{line_prev}, $p->{column_prev}) = ($p->{line}, $p->{column});        ($p->{line_prev}, $p->{column_prev}) = ($p->{line}, $p->{column});
7859        $p->{column}++;        $p->{column}++;
# Line 7750  sub set_inner_html ($$$;$) { Line 7863  sub set_inner_html ($$$;$) {
7863          $p->{column} = 0;          $p->{column} = 0;
7864          !!!cp ('i1');          !!!cp ('i1');
7865        } elsif ($self->{next_char} == 0x000D) { # CR        } elsif ($self->{next_char} == 0x000D) { # CR
7866          $i++ if substr ($$s, $i, 1) eq "\x0A";  ## TODO: support for abort/streaming
7867            my $next = '';
7868            if ($input->read ($next, 1) and $next ne "\x0A") {
7869              $self->{next_next_char} = $next;
7870            }
7871          $self->{next_char} = 0x000A; # LF # MUST          $self->{next_char} = 0x000A; # LF # MUST
7872          $p->{line}++;          $p->{line}++;
7873          $p->{column} = 0;          $p->{column} = 0;
# Line 7792  sub set_inner_html ($$$;$) { Line 7909  sub set_inner_html ($$$;$) {
7909          }          }
7910        }        }
7911      };      };
     $p->{prev_char} = [-1, -1, -1];  
     $p->{next_char} = -1;  
7912    
7913      $p->{read_until} = sub {      $p->{read_until} = sub {
7914        ## TODO: ...        #my ($scalar, $specials_range, $offset) = @_;
7915        return 0;        return 0 if defined $p->{next_next_char};
7916      }; # $p->{read_until};  
7917          my $pattern = qr/(?![$_[1]\x{FDD0}-\x{FDDF}\x{FFFE}\x{FFFF}\x{1FFFE}\x{1FFFF}\x{2FFFE}\x{2FFFF}\x{3FFFE}\x{3FFFF}\x{4FFFE}\x{4FFFF}\x{5FFFE}\x{5FFFF}\x{6FFFE}\x{6FFFF}\x{7FFFE}\x{7FFFF}\x{8FFFE}\x{8FFFF}\x{9FFFE}\x{9FFFF}\x{AFFFE}\x{AFFFF}\x{BFFFE}\x{BFFFF}\x{CFFFE}\x{CFFFF}\x{DFFFE}\x{DFFFF}\x{EFFFE}\x{EFFFF}\x{FFFFE}\x{FFFFF}])[\x20-\x7E\xA0-\x{D7FF}\x{E000}-\x{10FFFD}]/;
7918          my $offset = $_[2] || 0;
7919          
7920          if ($p->{char_buffer_pos} < length $p->{char_buffer}) {
7921            pos ($p->{char_buffer}) = $p->{char_buffer_pos};
7922            if ($p->{char_buffer} =~ /\G(?>$pattern)+/) {
7923              substr ($_[0], $offset)
7924                  = substr ($p->{char_buffer}, $-[0], $+[0] - $-[0]);
7925              my $count = $+[0] - $-[0];
7926              if ($count) {
7927                $p->{column} += $count;
7928                $p->{char_buffer_pos} += $count;
7929                $p->{line_prev} = $p->{line};
7930                $p->{column_prev} = $p->{column} - 1;
7931                $p->{prev_char} = [-1, -1, -1];
7932                $p->{next_char} = -1;
7933              }
7934              return $count;
7935            } else {
7936              return 0;
7937            }
7938          } else {
7939            my $count = $input->manakai_read_until ($_[0], $pattern, $_[2]);
7940            if ($count) {
7941              $p->{column} += $count;
7942              $p->{column_prev} += $count;
7943              $p->{prev_char} = [-1, -1, -1];
7944              $p->{next_char} = -1;
7945            }
7946            return $count;
7947          }
7948        }; # $p->{read_until}
7949    
7950      my $ponerror = $onerror || sub {      my $ponerror = $onerror || sub {
7951        my (%opt) = @_;        my (%opt) = @_;
# Line 7814  sub set_inner_html ($$$;$) { Line 7961  sub set_inner_html ($$$;$) {
7961        $ponerror->(line => $p->{line}, column => $p->{column}, @_);        $ponerror->(line => $p->{line}, column => $p->{column}, @_);
7962      };      };
7963            
7964        my $char_onerror = sub {
7965          my (undef, $type, %opt) = @_;
7966          $ponerror->(layer => 'encode',
7967                      line => $p->{line}, column => $p->{column} + 1,
7968                      %opt, type => $type);
7969        }; # $char_onerror
7970        $input->onerror ($char_onerror);
7971    
7972      $p->_initialize_tokenizer;      $p->_initialize_tokenizer;
7973      $p->_initialize_tree_constructor;      $p->_initialize_tree_constructor;
7974    
Legend:
Removed from v.1.172  
changed lines
  Added in v.1.180
[email protected]
 ViewVC Help
Powered by ViewVC 1.1.24