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

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

Parent Directory | Revision Log | View Patch Patch

-revision 1.155 by wakaba,
Sat Aug 30 12:57:05 2008 UTC
+revision 1.172 by wakaba,
Sun Sep 14 03:07:58 2008 UTC
 Line 354 
 sub parse_byte_string ($$$$;$) {
    return $self->parse_byte_stream ($charset_name, $input, @_[1..$#_]);
  } # parse_byte_string
- sub parse_byte_stream ($$$$;$) {
+ sub parse_byte_stream ($$$$;$$) {
+   # my ($self, $charset_name, $byte_stream, $doc, $onerror, $get_wrapper) = @_;
    my $self = ref $_[0] ? shift : shift->new;
    my $charset_name = shift;
    my $byte_stream = $_[0];
-Line 365 
 sub parse_byte_stream ($$$$;$) {
+Line 366 
 sub parse_byte_stream ($$$$;$) {
    };
    $self->{parse_error} = $onerror; # updated later by parse_char_string
+   my $get_wrapper = $_[3] || sub ($) {
+     return $_[0]; # $_[0] = byte stream handle, returned = arg to char handle
+   };
    ## HTML5 encoding sniffing algorithm
    require Message::Charset::Info;
    my $charset;
-Line 372 
 sub parse_byte_stream ($$$$;$) {
+Line 377 
 sub parse_byte_stream ($$$$;$) {
    my ($char_stream, $e_status);
    SNIFFING: {
+     ## NOTE: By setting |allow_fallback| option true when the
+     ## |get_decode_handle| method is invoked, we ignore what the HTML5
+     ## spec requires, i.e. unsupported encoding should be ignored.
+       ## TODO: We should not do this unless the parser is invoked
+       ## in the conformance checking mode, in which this behavior
+       ## would be useful.
      ## Step 1
      if (defined $charset_name) {
-       $charset = Message::Charset::Info->get_by_iana_name ($charset_name);
+       $charset = Message::Charset::Info->get_by_html_name ($charset_name);
+           ## TODO: Is this ok?  Transfer protocol's parameter should be
+           ## interpreted in its semantics?
        ## ISSUE: Unsupported encoding is not ignored according to the spec.
        ($char_stream, $e_status) = $charset->get_decode_handle
-Line 399 
 sub parse_byte_stream ($$$$;$) {
+Line 412 
 sub parse_byte_stream ($$$$;$) {
      ## Step 3
      if ($byte_buffer =~ /^\xFE\xFF/) {
-       $charset = Message::Charset::Info->get_by_iana_name ('utf-16be');
+       $charset = Message::Charset::Info->get_by_html_name ('utf-16be');
        ($char_stream, $e_status) = $charset->get_decode_handle
            ($byte_stream, allow_error_reporting => 1,
             allow_fallback => 1, byte_buffer => \$byte_buffer);
        $self->{confident} = 1;
        last SNIFFING;
      } elsif ($byte_buffer =~ /^\xFF\xFE/) {
-       $charset = Message::Charset::Info->get_by_iana_name ('utf-16le');
+       $charset = Message::Charset::Info->get_by_html_name ('utf-16le');
        ($char_stream, $e_status) = $charset->get_decode_handle
            ($byte_stream, allow_error_reporting => 1,
             allow_fallback => 1, byte_buffer => \$byte_buffer);
        $self->{confident} = 1;
        last SNIFFING;
      } elsif ($byte_buffer =~ /^\xEF\xBB\xBF/) {
-       $charset = Message::Charset::Info->get_by_iana_name ('utf-8');
+       $charset = Message::Charset::Info->get_by_html_name ('utf-8');
        ($char_stream, $e_status) = $charset->get_decode_handle
            ($byte_stream, allow_error_reporting => 1,
             allow_fallback => 1, byte_buffer => \$byte_buffer);
-Line 432 
 sub parse_byte_stream ($$$$;$) {
+Line 445 
 sub parse_byte_stream ($$$$;$) {
      $charset_name = Whatpm::Charset::UniversalCharDet->detect_byte_string
          ($byte_buffer);
      if (defined $charset_name) {
-       $charset = Message::Charset::Info->get_by_iana_name ($charset_name);
+       $charset = Message::Charset::Info->get_by_html_name ($charset_name);
        ## ISSUE: Unsupported encoding is not ignored according to the spec.
        require Whatpm::Charset::DecodeHandle;
-Line 455 
 sub parse_byte_stream ($$$$;$) {
+Line 468 
 sub parse_byte_stream ($$$$;$) {
      ## Step 7: default
      ## TODO: Make this configurable.
-     $charset = Message::Charset::Info->get_by_iana_name ('windows-1252');
+     $charset = Message::Charset::Info->get_by_html_name ('windows-1252');
          ## NOTE: We choose |windows-1252| here, since |utf-8| should be
          ## detectable in the step 6.
      require Whatpm::Charset::DecodeHandle;
-Line 475 
 sub parse_byte_stream ($$$$;$) {
+Line 488 
 sub parse_byte_stream ($$$$;$) {
      $self->{confident} = 0;
    } # SNIFFING
-   $self->{input_encoding} = $charset->get_iana_name;
    if ($e_status & Message::Charset::Info::FALLBACK_ENCODING_IMPL ()) {
+     $self->{input_encoding} = $charset->get_iana_name; ## TODO: Should we set actual charset decoder's encoding name?
      !!!parse-error (type => 'chardecode:fallback',
-                     text => $self->{input_encoding},
+                     #text => $self->{input_encoding},
                      level => $self->{level}->{uncertain},
                      line => 1, column => 1,
                      layer => 'encode');
    } elsif (not ($e_status &
                  Message::Charset::Info::ERROR_REPORTING_ENCODING_IMPL())) {
+     $self->{input_encoding} = $charset->get_iana_name;
      !!!parse-error (type => 'chardecode:no error',
                      text => $self->{input_encoding},
                      level => $self->{level}->{uncertain},
                      line => 1, column => 1,
                      layer => 'encode');
+   } else {
+     $self->{input_encoding} = $charset->get_iana_name;
    }
    $self->{change_encoding} = sub {
-Line 496 
 sub parse_byte_stream ($$$$;$) {
+Line 512 
 sub parse_byte_stream ($$$$;$) {
      $charset_name = shift;
      my $token = shift;
-     $charset = Message::Charset::Info->get_by_iana_name ($charset_name);
+     $charset = Message::Charset::Info->get_by_html_name ($charset_name);
      ($char_stream, $e_status) = $charset->get_decode_handle
          ($byte_stream, allow_error_reporting => 1, allow_fallback => 1,
           byte_buffer => \ $buffer->{buffer});
-Line 507 
 sub parse_byte_stream ($$$$;$) {
+Line 523 
 sub parse_byte_stream ($$$$;$) {
        ## Step 1
        if ($charset->{category} &
            Message::Charset::Info::CHARSET_CATEGORY_UTF16 ()) {
-         $charset = Message::Charset::Info->get_by_iana_name ('utf-8');
+         $charset = Message::Charset::Info->get_by_html_name ('utf-8');
          ($char_stream, $e_status) = $charset->get_decode_handle
              ($byte_stream,
               byte_buffer => \ $buffer->{buffer});
-Line 551 
 sub parse_byte_stream ($$$$;$) {
+Line 567 
 sub parse_byte_stream ($$$$;$) {
        ${$opt{octets}} = "\x{FFFD}"; # relacement character
      }
    };
-   $char_stream->onerror ($char_onerror);
+   my $wrapped_char_stream = $get_wrapper->($char_stream);
+   $wrapped_char_stream->onerror ($char_onerror);
    my @args = @_; shift @args; # $s
    my $return;
    try {
-     $return = $self->parse_char_stream ($char_stream, @args);
+     $return = $self->parse_char_stream ($wrapped_char_stream, @args);
    } catch Whatpm::HTML::RestartParser with {
      ## NOTE: Invoked after {change_encoding}.
-     $self->{input_encoding} = $charset->get_iana_name;
      if ($e_status & Message::Charset::Info::FALLBACK_ENCODING_IMPL ()) {
+       $self->{input_encoding} = $charset->get_iana_name; ## TODO: Should we set actual charset decoder's encoding name?
        !!!parse-error (type => 'chardecode:fallback',
-                       text => $self->{input_encoding},
                        level => $self->{level}->{uncertain},
+                       #text => $self->{input_encoding},
                        line => 1, column => 1,
                        layer => 'encode');
      } elsif (not ($e_status &
                    Message::Charset::Info::ERROR_REPORTING_ENCODING_IMPL())) {
+       $self->{input_encoding} = $charset->get_iana_name;
        !!!parse-error (type => 'chardecode:no error',
                        text => $self->{input_encoding},
                        level => $self->{level}->{uncertain},
                        line => 1, column => 1,
                        layer => 'encode');
+     } else {
+       $self->{input_encoding} = $charset->get_iana_name;
      }
      $self->{confident} = 1;
-     $char_stream->onerror ($char_onerror);
-     $return = $self->parse_char_stream ($char_stream, @args);
+     $wrapped_char_stream = $get_wrapper->($char_stream);
+     $wrapped_char_stream->onerror ($char_onerror);
+     $return = $self->parse_char_stream ($wrapped_char_stream, @args);
    };
    return $return;
  } # parse_byte_stream
-Line 591 
 sub parse_byte_stream ($$$$;$) {
+Line 615 
 sub parse_byte_stream ($$$$;$) {
  ## such as |parse_byte_string| in this module, must ensure that it does
  ## strip the BOM and never strip any ZWNBSP.
- sub parse_char_string ($$$;$) {
+ sub parse_char_string ($$$;$$) {
+   #my ($self, $s, $doc, $onerror, $get_wrapper) = @_;
    my $self = shift;
-   require utf8;
    my $s = ref $_[0] ? $_[0] : \($_[0]);
-   open my $input, '<' . (utf8::is_utf8 ($$s) ? ':utf8' : ''), $s;
+   require Whatpm::Charset::DecodeHandle;
+   my $input = Whatpm::Charset::DecodeHandle::CharString->new ($s);
+   if ($_[3]) {
+     $input = $_[3]->($input);
+   }
    return $self->parse_char_stream ($input, @_[1..$#_]);
  } # parse_char_string
- *parse_string = \&parse_char_string;
+ *parse_string = \&parse_char_string; ## NOTE: Alias for backward compatibility.
  sub parse_char_stream ($$$;$) {
    my $self = ref $_[0] ? shift : shift->new;
-Line 641 
 sub parse_char_stream ($$$;$) {
+Line 669 
 sub parse_char_stream ($$$;$) {
        $self->{column} = 0;
      } elsif ($self->{next_char} == 0x000D) { # CR
        !!!cp ('j2');
+ ## TODO: support for abort/streaming
        my $next = $input->getc;
        if (defined $next and $next ne "\x0A") {
          $self->{next_next_char} = $next;
-Line 660 
 sub parse_char_stream ($$$;$) {
+Line 689 
 sub parse_char_stream ($$$;$) {
               (0x007F <= $self->{next_char} and $self->{next_char} <= 0x009F) or
               (0xD800 <= $self->{next_char} and $self->{next_char} <= 0xDFFF) or
               (0xFDD0 <= $self->{next_char} and $self->{next_char} <= 0xFDDF) or
+ ## ISSUE: U+FDE0-U+FDEF are not excluded
               {
 xFFFE => 1, 0xFFFF => 1, 0x1FFFE => 1, 0x1FFFF => 1,
 x2FFFE => 1, 0x2FFFF => 1, 0x3FFFE => 1, 0x3FFFF => 1,
-Line 684 
 sub parse_char_stream ($$$;$) {
+Line 714 
 sub parse_char_stream ($$$;$) {
    $self->{prev_char} = [-1, -1, -1];
    $self->{next_char} = -1;
+   $self->{read_until} = sub {
+     #my ($scalar, $specials_range, $offset) = @_;
+     my $specials_range = $_[1];
+     return 0 if defined $self->{next_next_char};
+     my $count = $input->manakai_read_until
+        ($_[0],
+         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}]/,
+         $_[2]);
+     if ($count) {
+       $self->{column} += $count;
+       $self->{column_prev} += $count;
+       $self->{prev_char} = [-1, -1, -1];
+       $self->{next_char} = -1;
+     }
+     return $count;
+   }; # $self->{read_until}
    my $onerror = $_[2] || sub {
      my (%opt) = @_;
      my $line = $opt{token} ? $opt{token}->{line} : $opt{line};
-Line 708 
 sub new ($) {
+Line 755 
 sub new ($) {
    my $class = shift;
    my $self = bless {
      level => {must => 'm',
+               should => 's',
                warn => 'w',
                info => 'i',
                uncertain => 'u'},
-Line 740 
 sub RCDATA_CONTENT_MODEL () { CM_ENTITY
+Line 788 
 sub RCDATA_CONTENT_MODEL () { CM_ENTITY
  sub PCDATA_CONTENT_MODEL () { CM_ENTITY | CM_FULL_MARKUP }
  sub DATA_STATE () { 0 }
- sub ENTITY_DATA_STATE () { 1 }
+ #sub ENTITY_DATA_STATE () { 1 }
  sub TAG_OPEN_STATE () { 2 }
  sub CLOSE_TAG_OPEN_STATE () { 3 }
  sub TAG_NAME_STATE () { 4 }
-Line 751 
 sub BEFORE_ATTRIBUTE_VALUE_STATE () { 8
+Line 799 
 sub BEFORE_ATTRIBUTE_VALUE_STATE () { 8
  sub ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE () { 9 }
  sub ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE () { 10 }
  sub ATTRIBUTE_VALUE_UNQUOTED_STATE () { 11 }
- sub ENTITY_IN_ATTRIBUTE_VALUE_STATE () { 12 }
+ #sub ENTITY_IN_ATTRIBUTE_VALUE_STATE () { 12 }
  sub MARKUP_DECLARATION_OPEN_STATE () { 13 }
  sub COMMENT_START_STATE () { 14 }
  sub COMMENT_START_DASH_STATE () { 15 }
-Line 774 
 sub AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STAT
+Line 822 
 sub AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STAT
  sub BOGUS_DOCTYPE_STATE () { 32 }
  sub AFTER_ATTRIBUTE_VALUE_QUOTED_STATE () { 33 }
  sub SELF_CLOSING_START_TAG_STATE () { 34 }
- sub CDATA_BLOCK_STATE () { 35 }
+ sub CDATA_SECTION_STATE () { 35 }
+ sub MD_HYPHEN_STATE () { 36 } # "markup declaration open state" in the spec
+ sub MD_DOCTYPE_STATE () { 37 } # "markup declaration open state" in the spec
+ sub MD_CDATA_STATE () { 38 } # "markup declaration open state" in the spec
+ sub CDATA_PCDATA_CLOSE_TAG_STATE () { 39 } # "close tag open state" in the spec
+ sub CDATA_SECTION_MSE1_STATE () { 40 } # "CDATA section state" in the spec
+ sub CDATA_SECTION_MSE2_STATE () { 41 } # "CDATA section state" in the spec
+ sub PUBLIC_STATE () { 42 } # "after DOCTYPE name state" in the spec
+ sub SYSTEM_STATE () { 43 } # "after DOCTYPE name state" in the spec
+ ## NOTE: "Entity data state", "entity in attribute value state", and
+ ## "consume a character reference" algorithm are jointly implemented
+ ## using the following six states:
+ sub ENTITY_STATE () { 44 }
+ sub ENTITY_HASH_STATE () { 45 }
+ sub NCR_NUM_STATE () { 46 }
+ sub HEXREF_X_STATE () { 47 }
+ sub HEXREF_HEX_STATE () { 48 }
+ sub ENTITY_NAME_STATE () { 49 }
  sub DOCTYPE_TOKEN () { 1 }
  sub COMMENT_TOKEN () { 2 }
-Line 827 
 sub IN_COLUMN_GROUP_IM () { 0b10 }
+Line 892 
 sub IN_COLUMN_GROUP_IM () { 0b10 }
  sub _initialize_tokenizer ($) {
    my $self = shift;
    $self->{state} = DATA_STATE; # MUST
+   #$self->{state_keyword}; # initialized when used
+   #$self->{entity__value}; # initialized when used
+   #$self->{entity__match}; # initialized when used
    $self->{content_model} = PCDATA_CONTENT_MODEL; # be
-   undef $self->{current_token}; # start tag, end tag, comment, or DOCTYPE
+   undef $self->{current_token};
    undef $self->{current_attribute};
    undef $self->{last_emitted_start_tag_name};
-   undef $self->{last_attribute_value_state};
+   #$self->{prev_state}; # initialized when used
    delete $self->{self_closing};
-   $self->{char} = [];
    # $self->{next_char}
    !!!next-input-character;
    $self->{token} = [];
-Line 865 
 sub _initialize_tokenizer ($) {
+Line 932 
 sub _initialize_tokenizer ($) {
  ## has completed loading.  If one has, then it MUST be executed
  ## and removed from the list.
- ## NOTE: HTML5 "Writing HTML documents" section, applied to
+ ## TODO: Polytheistic slash SHOULD NOT be used. (Applied only to atheists.)
- ## documents and not to user agents and conformance checkers,
+ ## (This requirement was dropped from HTML5 spec, unfortunately.)
- ## contains some requirements that are not detected by the
- ## parsing algorithm:
- ## - Some requirements on character encoding declarations. ## TODO
- ## - "Elements MUST NOT contain content that their content model disallows."
- ##   ... Some are parse error, some are not (will be reported by c.c.).
- ## - Polytheistic slash SHOULD NOT be used. (Applied only to atheists.) ## TODO
- ## - Text (in elements, attributes, and comments) SHOULD NOT contain
- ##   control characters other than space characters. ## TODO: (what is control character? C0, C1 and DEL?  Unicode control character?)
- ## TODO: HTML5 poses authors two SHOULD-level requirements that cannot
- ## be detected by the HTML5 parsing algorithm:
- ## - Text,
  sub _get_next_token ($) {
    my $self = shift;
-Line 902 
 sub _get_next_token ($) {
+Line 957 
 sub _get_next_token ($) {
          if ($self->{content_model} & CM_ENTITY and # PCDATA | RCDATA
              not $self->{escape}) {
            !!!cp (1);
-           $self->{state} = ENTITY_DATA_STATE;
+           ## NOTE: In the spec, the tokenizer is switched to the
+           ## "entity data state".  In this implementation, the tokenizer
+           ## is switched to the |ENTITY_STATE|, which is an implementation
+           ## of the "consume a character reference" algorithm.
+           $self->{entity_additional} = -1;
+           $self->{prev_state} = DATA_STATE;
+           $self->{state} = ENTITY_STATE;
            !!!next-input-character;
            redo A;
          } else {
-Line 966 
 sub _get_next_token ($) {
+Line 1027 
 sub _get_next_token ($) {
                     data => chr $self->{next_char},
                     line => $self->{line}, column => $self->{column},
                    };
+       $self->{read_until}->($token->{data}, q[-!<>&], length $token->{data});
        ## Stay in the data state
        !!!next-input-character;
        !!!emit ($token);
        redo A;
-     } elsif ($self->{state} == ENTITY_DATA_STATE) {
-       ## (cannot happen in CDATA state)
-       my ($l, $c) = ($self->{line_prev}, $self->{column_prev});
-       my $token = $self->_tokenize_attempt_to_consume_an_entity (0, -1);
-       $self->{state} = DATA_STATE;
-       # next-input-character is already done
-       unless (defined $token) {
-         !!!cp (13);
-         !!!emit ({type => CHARACTER_TOKEN, data => '&',
-                   line => $l, column => $c,
-                  });
-       } else {
-         !!!cp (14);
-         !!!emit ($token);
-       }
-       redo A;
      } elsif ($self->{state} == TAG_OPEN_STATE) {
        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
          if ($self->{next_char} == 0x002F) { # /
-Line 1089 
 sub _get_next_token ($) {
+Line 1131 
 sub _get_next_token ($) {
          die "$0: $self->{content_model} in tag open";
        }
      } elsif ($self->{state} == CLOSE_TAG_OPEN_STATE) {
+       ## NOTE: The "close tag open state" in the spec is implemented as
+       ## |CLOSE_TAG_OPEN_STATE| and |CDATA_PCDATA_CLOSE_TAG_STATE|.
        my ($l, $c) = ($self->{line_prev}, $self->{column_prev} - 1); # "<"of"</"
        if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA
          if (defined $self->{last_emitted_start_tag_name}) {
+           $self->{state} = CDATA_PCDATA_CLOSE_TAG_STATE;
-           ## NOTE: <http://krijnhoetmer.nl/irc-logs/whatwg/20070626#l-564>
+           $self->{state_keyword} = '';
-           my @next_char;
+           ## Reconsume.
-           TAGNAME: for (my $i = 0; $i < length $self->{last_emitted_start_tag_name}; $i++) {
+           redo A;
-             push @next_char, $self->{next_char};
-             my $c = ord substr ($self->{last_emitted_start_tag_name}, $i, 1);
-             my $C = 0x0061 <= $c && $c <= 0x007A ? $c - 0x0020 : $c;
-             if ($self->{next_char} == $c or $self->{next_char} == $C) {
-               !!!cp (24);
-               !!!next-input-character;
-               next TAGNAME;
-             } else {
-               !!!cp (25);
-               $self->{next_char} = shift @next_char; # reconsume
-               !!!back-next-input-character (@next_char);
-               $self->{state} = DATA_STATE;
-               !!!emit ({type => CHARACTER_TOKEN, data => '</',
-                         line => $l, column => $c,
-                        });
-               redo A;
-             }
-           }
-           push @next_char, $self->{next_char};
-           unless ($self->{next_char} == 0x0009 or # HT
-                   $self->{next_char} == 0x000A or # LF
-                   $self->{next_char} == 0x000B or # VT
-                   $self->{next_char} == 0x000C or # FF
-                   $self->{next_char} == 0x0020 or # SP
-                   $self->{next_char} == 0x003E or # >
-                   $self->{next_char} == 0x002F or # /
-                   $self->{next_char} == -1) {
-             !!!cp (26);
-             $self->{next_char} = shift @next_char; # reconsume
-             !!!back-next-input-character (@next_char);
-             $self->{state} = DATA_STATE;
-             !!!emit ({type => CHARACTER_TOKEN, data => '</',
-                       line => $l, column => $c,
-                      });
-             redo A;
-           } else {
-             !!!cp (27);
-             $self->{next_char} = shift @next_char;
-             !!!back-next-input-character (@next_char);
-             # and consume...
-           }
          } else {
            ## No start tag token has ever been emitted
+           ## NOTE: See <http://krijnhoetmer.nl/irc-logs/whatwg/20070626#l-564>.
            !!!cp (28);
-           # next-input-character is already done
            $self->{state} = DATA_STATE;
+           ## Reconsume.
            !!!emit ({type => CHARACTER_TOKEN, data => '</',
                      line => $l, column => $c,
                     });
            redo A;
          }
        }
        if (0x0041 <= $self->{next_char} and
            $self->{next_char} <= 0x005A) { # A..Z
          !!!cp (29);
-Line 1198 
 sub _get_next_token ($) {
+Line 1200 
 sub _get_next_token ($) {
                                    line => $self->{line_prev}, # "<" of "</"
                                    column => $self->{column_prev} - 1,
                                   };
-         ## $self->{next_char} is intentionally left as is
+         ## NOTE: $self->{next_char} is intentionally left as is.
-         redo A;
+         ## Although the "anything else" case of the spec not explicitly
+         ## states that the next input character is to be reconsumed,
+         ## it will be included to the |data| of the comment token
+         ## generated from the bogus end tag, as defined in the
+         ## "bogus comment state" entry.
+         redo A;
+       }
+     } elsif ($self->{state} == CDATA_PCDATA_CLOSE_TAG_STATE) {
+       my $ch = substr $self->{last_emitted_start_tag_name}, length $self->{state_keyword}, 1;
+       if (length $ch) {
+         my $CH = $ch;
+         $ch =~ tr/a-z/A-Z/;
+         my $nch = chr $self->{next_char};
+         if ($nch eq $ch or $nch eq $CH) {
+           !!!cp (24);
+           ## Stay in the state.
+           $self->{state_keyword} .= $nch;
+           !!!next-input-character;
+           redo A;
+         } else {
+           !!!cp (25);
+           $self->{state} = DATA_STATE;
+           ## Reconsume.
+           !!!emit ({type => CHARACTER_TOKEN,
+                     data => '</' . $self->{state_keyword},
+                     line => $self->{line_prev},
+                     column => $self->{column_prev} - 1 - length $self->{state_keyword},
+                    });
+           redo A;
+         }
+       } else { # after "<{tag-name}"
+         unless ({
+x0009 => 1, # HT
+x000A => 1, # LF
+x000B => 1, # VT
+x000C => 1, # FF
+x0020 => 1, # SP
+x003E => 1, # >
+x002F => 1, # /
+                  -1 => 1, # EOF
+                 }->{$self->{next_char}}) {
+           !!!cp (26);
+           ## Reconsume.
+           $self->{state} = DATA_STATE;
+           !!!emit ({type => CHARACTER_TOKEN,
+                     data => '</' . $self->{state_keyword},
+                     line => $self->{line_prev},
+                     column => $self->{column_prev} - 1 - length $self->{state_keyword},
+                    });
+           redo A;
+         } else {
+           !!!cp (27);
+           $self->{current_token}
+               = {type => END_TAG_TOKEN,
+                  tag_name => $self->{last_emitted_start_tag_name},
+                  line => $self->{line_prev},
+                  column => $self->{column_prev} - 1 - length $self->{state_keyword}};
+           $self->{state} = TAG_NAME_STATE;
+           ## Reconsume.
+           redo A;
+         }
        }
      } elsif ($self->{state} == TAG_NAME_STATE) {
        if ($self->{next_char} == 0x0009 or # HT
-Line 1540 
 sub _get_next_token ($) {
+Line 1602 
 sub _get_next_token ($) {
          redo A;
        } else {
-         !!!cp (82);
+         if ($self->{next_char} == 0x0022 or # "
+             $self->{next_char} == 0x0027) { # '
+           !!!cp (78);
+           !!!parse-error (type => 'bad attribute name');
+         } else {
+           !!!cp (82);
+         }
          $self->{current_attribute}
              = {name => chr ($self->{next_char}),
                 value => '',
-Line 1575 
 sub _get_next_token ($) {
+Line 1643 
 sub _get_next_token ($) {
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x003E) { # >
+         !!!parse-error (type => 'empty unquoted attribute value');
          if ($self->{current_token}->{type} == START_TAG_TOKEN) {
            !!!cp (87);
            $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};
-Line 1639 
 sub _get_next_token ($) {
+Line 1708 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{next_char} == 0x0026) { # &
          !!!cp (96);
-         $self->{last_attribute_value_state} = $self->{state};
+         ## NOTE: In the spec, the tokenizer is switched to the
-         $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;
+         ## "entity in attribute value state".  In this implementation, the
+         ## tokenizer is switched to the |ENTITY_STATE|, which is an
+         ## implementation of the "consume a character reference" algorithm.
+         $self->{prev_state} = $self->{state};
+         $self->{entity_additional} = 0x0022; # "
+         $self->{state} = ENTITY_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == -1) {
-Line 1681 
 sub _get_next_token ($) {
+Line 1755 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{next_char} == 0x0026) { # &
          !!!cp (102);
-         $self->{last_attribute_value_state} = $self->{state};
+         ## NOTE: In the spec, the tokenizer is switched to the
-         $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;
+         ## "entity in attribute value state".  In this implementation, the
+         ## tokenizer is switched to the |ENTITY_STATE|, which is an
+         ## implementation of the "consume a character reference" algorithm.
+         $self->{entity_additional} = 0x0027; # '
+         $self->{prev_state} = $self->{state};
+         $self->{state} = ENTITY_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == -1) {
-Line 1727 
 sub _get_next_token ($) {
+Line 1806 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{next_char} == 0x0026) { # &
          !!!cp (108);
-         $self->{last_attribute_value_state} = $self->{state};
+         ## NOTE: In the spec, the tokenizer is switched to the
-         $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;
+         ## "entity in attribute value state".  In this implementation, the
+         ## tokenizer is switched to the |ENTITY_STATE|, which is an
+         ## implementation of the "consume a character reference" algorithm.
+         $self->{entity_additional} = -1;
+         $self->{prev_state} = $self->{state};
+         $self->{state} = ENTITY_STATE;
          !!!next-input-character;
          redo A;
        } elsif ($self->{next_char} == 0x003E) { # >
-Line 1792 
 sub _get_next_token ($) {
+Line 1876 
 sub _get_next_token ($) {
          !!!next-input-character;
          redo A;
        }
-     } elsif ($self->{state} == ENTITY_IN_ATTRIBUTE_VALUE_STATE) {
-       my $token = $self->_tokenize_attempt_to_consume_an_entity
-           (1,
-            $self->{last_attribute_value_state}
-              == ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE ? 0x0022 : # "
-            $self->{last_attribute_value_state}
-              == ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE ? 0x0027 : # '
-            -1);
-       unless (defined $token) {
-         !!!cp (117);
-         $self->{current_attribute}->{value} .= '&';
-       } else {
-         !!!cp (118);
-         $self->{current_attribute}->{value} .= $token->{data};
-         $self->{current_attribute}->{has_reference} = $token->{has_reference};
-         ## ISSUE: spec says "append the returned character token to the current attribute's value"
-       }
-       $self->{state} = $self->{last_attribute_value_state};
-       # next-input-character is already done
-       redo A;
      } elsif ($self->{state} == AFTER_ATTRIBUTE_VALUE_QUOTED_STATE) {
        if ($self->{next_char} == 0x0009 or # HT
            $self->{next_char} == 0x000A or # LF
-Line 1933 
 sub _get_next_token ($) {
+Line 1995 
 sub _get_next_token ($) {
        }
      } elsif ($self->{state} == BOGUS_COMMENT_STATE) {
        ## (only happen if PCDATA state)
-       ## NOTE: Set by the previous state
-       #my $token = {type => COMMENT_TOKEN, data => ''};
-       BC: {
+       ## NOTE: Unlike spec's "bogus comment state", this implementation
-         if ($self->{next_char} == 0x003E) { # >
+       ## consumes characters one-by-one basis.
-           !!!cp (124);
-           $self->{state} = DATA_STATE;
+       if ($self->{next_char} == 0x003E) { # >
-           !!!next-input-character;
+         !!!cp (124);
+         $self->{state} = DATA_STATE;
-           !!!emit ($self->{current_token}); # comment
+         !!!next-input-character;
-           redo A;
-         } elsif ($self->{next_char} == -1) {
-           !!!cp (125);
-           $self->{state} = DATA_STATE;
-           ## reconsume
-           !!!emit ($self->{current_token}); # comment
-           redo A;
+         !!!emit ($self->{current_token}); # comment
-         } else {
+         redo A;
-           !!!cp (126);
+       } elsif ($self->{next_char} == -1) {
-           $self->{current_token}->{data} .= chr ($self->{next_char}); # comment
+         !!!cp (125);
-           !!!next-input-character;
+         $self->{state} = DATA_STATE;
-           redo BC;
+         ## reconsume
-         }
-       } # BC
-       die "$0: _get_next_token: unexpected case [BC]";
+         !!!emit ($self->{current_token}); # comment
+         redo A;
+       } else {
+         !!!cp (126);
+         $self->{current_token}->{data} .= chr ($self->{next_char}); # comment
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       }
      } elsif ($self->{state} == MARKUP_DECLARATION_OPEN_STATE) {
        ## (only happen if PCDATA state)
-       my ($l, $c) = ($self->{line_prev}, $self->{column_prev} - 1);
-       my @next_char;
-       push @next_char, $self->{next_char};
        if ($self->{next_char} == 0x002D) { # -
+         !!!cp (133);
+         $self->{state} = MD_HYPHEN_STATE;
          !!!next-input-character;
-         push @next_char, $self->{next_char};
+         redo A;
-         if ($self->{next_char} == 0x002D) { # -
-           !!!cp (127);
-           $self->{current_token} = {type => COMMENT_TOKEN, data => '',
-                                     line => $l, column => $c,
-                                    };
-           $self->{state} = COMMENT_START_STATE;
-           !!!next-input-character;
-           redo A;
-         } else {
-           !!!cp (128);
-         }
        } elsif ($self->{next_char} == 0x0044 or # D
                 $self->{next_char} == 0x0064) { # d
+         ## ASCII case-insensitive.
+         !!!cp (130);
+         $self->{state} = MD_DOCTYPE_STATE;
+         $self->{state_keyword} = chr $self->{next_char};
          !!!next-input-character;
-         push @next_char, $self->{next_char};
+         redo A;
-         if ($self->{next_char} == 0x004F or # O
-             $self->{next_char} == 0x006F) { # o
-           !!!next-input-character;
-           push @next_char, $self->{next_char};
-           if ($self->{next_char} == 0x0043 or # C
-               $self->{next_char} == 0x0063) { # c
-             !!!next-input-character;
-             push @next_char, $self->{next_char};
-             if ($self->{next_char} == 0x0054 or # T
-                 $self->{next_char} == 0x0074) { # t
-               !!!next-input-character;
-               push @next_char, $self->{next_char};
-               if ($self->{next_char} == 0x0059 or # Y
-                   $self->{next_char} == 0x0079) { # y
-                 !!!next-input-character;
-                 push @next_char, $self->{next_char};
-                 if ($self->{next_char} == 0x0050 or # P
-                     $self->{next_char} == 0x0070) { # p
-                   !!!next-input-character;
-                   push @next_char, $self->{next_char};
-                   if ($self->{next_char} == 0x0045 or # E
-                       $self->{next_char} == 0x0065) { # e
-                     !!!cp (129);
-                     ## TODO: What a stupid code this is!
-                     $self->{state} = DOCTYPE_STATE;
-                     $self->{current_token} = {type => DOCTYPE_TOKEN,
-                                               quirks => 1,
-                                               line => $l, column => $c,
-                                              };
-                     !!!next-input-character;
-                     redo A;
-                   } else {
-                     !!!cp (130);
-                   }
-                 } else {
-                   !!!cp (131);
-                 }
-               } else {
-                 !!!cp (132);
-               }
-             } else {
-               !!!cp (133);
-             }
-           } else {
-             !!!cp (134);
-           }
-         } else {
-           !!!cp (135);
-         }
        } elsif ($self->{insertion_mode} & IN_FOREIGN_CONTENT_IM and
                 $self->{open_elements}->[-1]->[1] & FOREIGN_EL and
                 $self->{next_char} == 0x005B) { # [
+         !!!cp (135.4);
+         $self->{state} = MD_CDATA_STATE;
+         $self->{state_keyword} = '[';
          !!!next-input-character;
-         push @next_char, $self->{next_char};
+         redo A;
-         if ($self->{next_char} == 0x0043) { # C
-           !!!next-input-character;
-           push @next_char, $self->{next_char};
-           if ($self->{next_char} == 0x0044) { # D
-             !!!next-input-character;
-             push @next_char, $self->{next_char};
-             if ($self->{next_char} == 0x0041) { # A
-               !!!next-input-character;
-               push @next_char, $self->{next_char};
-               if ($self->{next_char} == 0x0054) { # T
-                 !!!next-input-character;
-                 push @next_char, $self->{next_char};
-                 if ($self->{next_char} == 0x0041) { # A
-                   !!!next-input-character;
-                   push @next_char, $self->{next_char};
-                   if ($self->{next_char} == 0x005B) { # [
-                     !!!cp (135.1);
-                     $self->{state} = CDATA_BLOCK_STATE;
-                     !!!next-input-character;
-                     redo A;
-                   } else {
-                     !!!cp (135.2);
-                   }
-                 } else {
-                   !!!cp (135.3);
-                 }
-               } else {
-                 !!!cp (135.4);
-               }
-             } else {
-               !!!cp (135.5);
-             }
-           } else {
-             !!!cp (135.6);
-           }
-         } else {
-           !!!cp (135.7);
-         }
        } else {
          !!!cp (136);
        }
-       !!!parse-error (type => 'bogus comment');
+       !!!parse-error (type => 'bogus comment',
-       $self->{next_char} = shift @next_char;
+                       line => $self->{line_prev},
-       !!!back-next-input-character (@next_char);
+                       column => $self->{column_prev} - 1);
+       ## Reconsume.
        $self->{state} = BOGUS_COMMENT_STATE;
        $self->{current_token} = {type => COMMENT_TOKEN, data => '',
-                                 line => $l, column => $c,
+                                 line => $self->{line_prev},
+                                 column => $self->{column_prev} - 1,
                                 };
        redo A;
+     } elsif ($self->{state} == MD_HYPHEN_STATE) {
-       ## ISSUE: typos in spec: chacacters, is is a parse error
+       if ($self->{next_char} == 0x002D) { # -
-       ## ISSUE: spec is somewhat unclear on "is the first character that will be in the comment"; what is "that will be in the comment" is what the algorithm defines, isn't it?
+         !!!cp (127);
+         $self->{current_token} = {type => COMMENT_TOKEN, data => '',
+                                   line => $self->{line_prev},
+                                   column => $self->{column_prev} - 2,
+                                  };
+         $self->{state} = COMMENT_START_STATE;
+         !!!next-input-character;
+         redo A;
+       } else {
+         !!!cp (128);
+         !!!parse-error (type => 'bogus comment',
+                         line => $self->{line_prev},
+                         column => $self->{column_prev} - 2);
+         $self->{state} = BOGUS_COMMENT_STATE;
+         ## Reconsume.
+         $self->{current_token} = {type => COMMENT_TOKEN,
+                                   data => '-',
+                                   line => $self->{line_prev},
+                                   column => $self->{column_prev} - 2,
+                                  };
+         redo A;
+       }
+     } elsif ($self->{state} == MD_DOCTYPE_STATE) {
+       ## ASCII case-insensitive.
+       if ($self->{next_char} == [
+             undef,
+x004F, # O
+x0043, # C
+x0054, # T
+x0059, # Y
+x0050, # P
+           ]->[length $self->{state_keyword}] or
+           $self->{next_char} == [
+             undef,
+x006F, # o
+x0063, # c
+x0074, # t
+x0079, # y
+x0070, # p
+           ]->[length $self->{state_keyword}]) {
+         !!!cp (131);
+         ## Stay in the state.
+         $self->{state_keyword} .= chr $self->{next_char};
+         !!!next-input-character;
+         redo A;
+       } elsif ((length $self->{state_keyword}) == 6 and
+                ($self->{next_char} == 0x0045 or # E
+                 $self->{next_char} == 0x0065)) { # e
+         !!!cp (129);
+         $self->{state} = DOCTYPE_STATE;
+         $self->{current_token} = {type => DOCTYPE_TOKEN,
+                                   quirks => 1,
+                                   line => $self->{line_prev},
+                                   column => $self->{column_prev} - 7,
+                                  };
+         !!!next-input-character;
+         redo A;
+       } else {
+         !!!cp (132);
+         !!!parse-error (type => 'bogus comment',
+                         line => $self->{line_prev},
+                         column => $self->{column_prev} - 1 - length $self->{state_keyword});
+         $self->{state} = BOGUS_COMMENT_STATE;
+         ## Reconsume.
+         $self->{current_token} = {type => COMMENT_TOKEN,
+                                   data => $self->{state_keyword},
+                                   line => $self->{line_prev},
+                                   column => $self->{column_prev} - 1 - length $self->{state_keyword},
+                                  };
+         redo A;
+       }
+     } elsif ($self->{state} == MD_CDATA_STATE) {
+       if ($self->{next_char} == {
+             '[' => 0x0043, # C
+             '[C' => 0x0044, # D
+             '[CD' => 0x0041, # A
+             '[CDA' => 0x0054, # T
+             '[CDAT' => 0x0041, # A
+           }->{$self->{state_keyword}}) {
+         !!!cp (135.1);
+         ## Stay in the state.
+         $self->{state_keyword} .= chr $self->{next_char};
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{state_keyword} eq '[CDATA' and
+                $self->{next_char} == 0x005B) { # [
+         !!!cp (135.2);
+         $self->{current_token} = {type => CHARACTER_TOKEN,
+                                   data => '',
+                                   line => $self->{line_prev},
+                                   column => $self->{column_prev} - 7};
+         $self->{state} = CDATA_SECTION_STATE;
+         !!!next-input-character;
+         redo A;
+       } else {
+         !!!cp (135.3);
+         !!!parse-error (type => 'bogus comment',
+                         line => $self->{line_prev},
+                         column => $self->{column_prev} - 1 - length $self->{state_keyword});
+         $self->{state} = BOGUS_COMMENT_STATE;
+         ## Reconsume.
+         $self->{current_token} = {type => COMMENT_TOKEN,
+                                   data => $self->{state_keyword},
+                                   line => $self->{line_prev},
+                                   column => $self->{column_prev} - 1 - length $self->{state_keyword},
+                                  };
+         redo A;
+       }
      } elsif ($self->{state} == COMMENT_START_STATE) {
        if ($self->{next_char} == 0x002D) { # -
          !!!cp (137);
-Line 2362 
 sub _get_next_token ($) {
+Line 2434 
 sub _get_next_token ($) {
          redo A;
        } elsif ($self->{next_char} == 0x0050 or # P
                 $self->{next_char} == 0x0070) { # p
+         $self->{state} = PUBLIC_STATE;
+         $self->{state_keyword} = chr $self->{next_char};
          !!!next-input-character;
-         if ($self->{next_char} == 0x0055 or # U
+         redo A;
-             $self->{next_char} == 0x0075) { # u
-           !!!next-input-character;
-           if ($self->{next_char} == 0x0042 or # B
-               $self->{next_char} == 0x0062) { # b
-             !!!next-input-character;
-             if ($self->{next_char} == 0x004C or # L
-                 $self->{next_char} == 0x006C) { # l
-               !!!next-input-character;
-               if ($self->{next_char} == 0x0049 or # I
-                   $self->{next_char} == 0x0069) { # i
-                 !!!next-input-character;
-                 if ($self->{next_char} == 0x0043 or # C
-                     $self->{next_char} == 0x0063) { # c
-                   !!!cp (168);
-                   $self->{state} = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
-                   !!!next-input-character;
-                   redo A;
-                 } else {
-                   !!!cp (169);
-                 }
-               } else {
-                 !!!cp (170);
-               }
-             } else {
-               !!!cp (171);
-             }
-           } else {
-             !!!cp (172);
-           }
-         } else {
-           !!!cp (173);
-         }
-         #
        } elsif ($self->{next_char} == 0x0053 or # S
                 $self->{next_char} == 0x0073) { # s
+         $self->{state} = SYSTEM_STATE;
+         $self->{state_keyword} = chr $self->{next_char};
          !!!next-input-character;
-         if ($self->{next_char} == 0x0059 or # Y
+         redo A;
-             $self->{next_char} == 0x0079) { # y
-           !!!next-input-character;
-           if ($self->{next_char} == 0x0053 or # S
-               $self->{next_char} == 0x0073) { # s
-             !!!next-input-character;
-             if ($self->{next_char} == 0x0054 or # T
-                 $self->{next_char} == 0x0074) { # t
-               !!!next-input-character;
-               if ($self->{next_char} == 0x0045 or # E
-                   $self->{next_char} == 0x0065) { # e
-                 !!!next-input-character;
-                 if ($self->{next_char} == 0x004D or # M
-                     $self->{next_char} == 0x006D) { # m
-                   !!!cp (174);
-                   $self->{state} = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
-                   !!!next-input-character;
-                   redo A;
-                 } else {
-                   !!!cp (175);
-                 }
-               } else {
-                 !!!cp (176);
-               }
-             } else {
-               !!!cp (177);
-             }
-           } else {
-             !!!cp (178);
-           }
-         } else {
-           !!!cp (179);
-         }
-         #
        } else {
          !!!cp (180);
+         !!!parse-error (type => 'string after DOCTYPE name');
+         $self->{current_token}->{quirks} = 1;
+         $self->{state} = BOGUS_DOCTYPE_STATE;
          !!!next-input-character;
-         #
+         redo A;
        }
+     } elsif ($self->{state} == PUBLIC_STATE) {
+       ## ASCII case-insensitive
+       if ($self->{next_char} == [
+             undef,
+x0055, # U
+x0042, # B
+x004C, # L
+x0049, # I
+           ]->[length $self->{state_keyword}] or
+           $self->{next_char} == [
+             undef,
+x0075, # u
+x0062, # b
+x006C, # l
+x0069, # i
+           ]->[length $self->{state_keyword}]) {
+         !!!cp (175);
+         ## Stay in the state.
+         $self->{state_keyword} .= chr $self->{next_char};
+         !!!next-input-character;
+         redo A;
+       } elsif ((length $self->{state_keyword}) == 5 and
+                ($self->{next_char} == 0x0043 or # C
+                 $self->{next_char} == 0x0063)) { # c
+         !!!cp (168);
+         $self->{state} = BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE;
+         !!!next-input-character;
+         redo A;
+       } else {
+         !!!cp (169);
+         !!!parse-error (type => 'string after DOCTYPE name',
+                         line => $self->{line_prev},
+                         column => $self->{column_prev} + 1 - length $self->{state_keyword});
+         $self->{current_token}->{quirks} = 1;
-       !!!parse-error (type => 'string after DOCTYPE name');
+         $self->{state} = BOGUS_DOCTYPE_STATE;
-       $self->{current_token}->{quirks} = 1;
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == SYSTEM_STATE) {
+       ## ASCII case-insensitive
+       if ($self->{next_char} == [
+             undef,
+x0059, # Y
+x0053, # S
+x0054, # T
+x0045, # E
+           ]->[length $self->{state_keyword}] or
+           $self->{next_char} == [
+             undef,
+x0079, # y
+x0073, # s
+x0074, # t
+x0065, # e
+           ]->[length $self->{state_keyword}]) {
+         !!!cp (170);
+         ## Stay in the state.
+         $self->{state_keyword} .= chr $self->{next_char};
+         !!!next-input-character;
+         redo A;
+       } elsif ((length $self->{state_keyword}) == 5 and
+                ($self->{next_char} == 0x004D or # M
+                 $self->{next_char} == 0x006D)) { # m
+         !!!cp (171);
+         $self->{state} = BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE;
+         !!!next-input-character;
+         redo A;
+       } else {
+         !!!cp (172);
+         !!!parse-error (type => 'string after DOCTYPE name',
+                         line => $self->{line_prev},
+                         column => $self->{column_prev} + 1 - length $self->{state_keyword});
+         $self->{current_token}->{quirks} = 1;
-       $self->{state} = BOGUS_DOCTYPE_STATE;
+         $self->{state} = BOGUS_DOCTYPE_STATE;
-       # next-input-character is already done
+         ## Reconsume.
-       redo A;
+         redo A;
+       }
      } elsif ($self->{state} == BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {
        if ({
 x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,
-Line 2804 
 sub _get_next_token ($) {
+Line 2887 
 sub _get_next_token ($) {
          !!!next-input-character;
          redo A;
        }
-     } elsif ($self->{state} == CDATA_BLOCK_STATE) {
+     } elsif ($self->{state} == CDATA_SECTION_STATE) {
-       my $s = '';
+       ## NOTE: "CDATA section state" in the state is jointly implemented
+       ## by three states, |CDATA_SECTION_STATE|, |CDATA_SECTION_MSE1_STATE|,
+       ## and |CDATA_SECTION_MSE2_STATE|.
-       my ($l, $c) = ($self->{line}, $self->{column});
+       if ($self->{next_char} == 0x005D) { # ]
+         !!!cp (221.1);
+         $self->{state} = CDATA_SECTION_MSE1_STATE;
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{next_char} == -1) {
+         $self->{state} = DATA_STATE;
+         !!!next-input-character;
+         if (length $self->{current_token}->{data}) { # character
+           !!!cp (221.2);
+           !!!emit ($self->{current_token}); # character
+         } else {
+           !!!cp (221.3);
+           ## No token to emit. $self->{current_token} is discarded.
+         }
+         redo A;
+       } else {
+         !!!cp (221.4);
+         $self->{current_token}->{data} .= chr $self->{next_char};
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       }
-       CS: while ($self->{next_char} != -1) {
+       ## ISSUE: "text tokens" in spec.
-         if ($self->{next_char} == 0x005D) { # ]
+     } elsif ($self->{state} == CDATA_SECTION_MSE1_STATE) {
-           !!!next-input-character;
+       if ($self->{next_char} == 0x005D) { # ]
-           if ($self->{next_char} == 0x005D) { # ]
+         !!!cp (221.5);
-             !!!next-input-character;
+         $self->{state} = CDATA_SECTION_MSE2_STATE;
-             MDC: {
+         !!!next-input-character;
-               if ($self->{next_char} == 0x003E) { # >
+         redo A;
-                 !!!cp (221.1);
+       } else {
-                 !!!next-input-character;
+         !!!cp (221.6);
-                 last CS;
+         $self->{current_token}->{data} .= ']';
-               } elsif ($self->{next_char} == 0x005D) { # ]
+         $self->{state} = CDATA_SECTION_STATE;
-                 !!!cp (221.2);
+         ## Reconsume.
-                 $s .= ']';
+         redo A;
-                 !!!next-input-character;
+       }
-                 redo MDC;
+     } elsif ($self->{state} == CDATA_SECTION_MSE2_STATE) {
-               } else {
+       if ($self->{next_char} == 0x003E) { # >
-                 !!!cp (221.3);
+         $self->{state} = DATA_STATE;
-                 $s .= ']]';
+         !!!next-input-character;
-                 #
+         if (length $self->{current_token}->{data}) { # character
-               }
+           !!!cp (221.7);
-             } # MDC
+           !!!emit ($self->{current_token}); # character
-           } else {
-             !!!cp (221.4);
-             $s .= ']';
-             #
-           }
          } else {
-           !!!cp (221.5);
+           !!!cp (221.8);
-           #
+           ## No token to emit. $self->{current_token} is discarded.
          }
-         $s .= chr $self->{next_char};
+         redo A;
+       } elsif ($self->{next_char} == 0x005D) { # ]
+         !!!cp (221.9); # character
+         $self->{current_token}->{data} .= ']'; ## Add first "]" of "]]]".
+         ## Stay in the state.
          !!!next-input-character;
-       } # CS
+         redo A;
-       $self->{state} = DATA_STATE;
-       ## next-input-character done or EOF, which is reconsumed.
-       if (length $s) {
-         !!!cp (221.6);
-         !!!emit ({type => CHARACTER_TOKEN, data => $s,
-                   line => $l, column => $c});
        } else {
-         !!!cp (221.7);
+         !!!cp (221.11);
+         $self->{current_token}->{data} .= ']]'; # character
+         $self->{state} = CDATA_SECTION_STATE;
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == ENTITY_STATE) {
+       if ({
+x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, # HT, LF, VT, FF,
+x0020 => 1, 0x003C => 1, 0x0026 => 1, -1 => 1, # SP, <, &
+         $self->{entity_additional} => 1,
+       }->{$self->{next_char}}) {
+         !!!cp (1001);
+         ## Don't consume
+         ## No error
+         ## Return nothing.
+         #
+       } elsif ($self->{next_char} == 0x0023) { # #
+         !!!cp (999);
+         $self->{state} = ENTITY_HASH_STATE;
+         $self->{state_keyword} = '#';
+         !!!next-input-character;
+         redo A;
+       } elsif ((0x0041 <= $self->{next_char} and
+                 $self->{next_char} <= 0x005A) or # A..Z
+                (0x0061 <= $self->{next_char} and
+                 $self->{next_char} <= 0x007A)) { # a..z
+         !!!cp (998);
+         require Whatpm::_NamedEntityList;
+         $self->{state} = ENTITY_NAME_STATE;
+         $self->{state_keyword} = chr $self->{next_char};
+         $self->{entity__value} = $self->{state_keyword};
+         $self->{entity__match} = 0;
+         !!!next-input-character;
+         redo A;
+       } else {
+         !!!cp (1027);
+         !!!parse-error (type => 'bare ero');
+         ## Return nothing.
+         #
        }
-       redo A;
+       ## NOTE: No character is consumed by the "consume a character
+       ## reference" algorithm.  In other word, there is an "&" character
-       ## ISSUE: "text tokens" in spec.
+       ## that does not introduce a character reference, which would be
-       ## TODO: Streaming support
+       ## appended to the parent element or the attribute value in later
-     } else {
+       ## process of the tokenizer.
-       die "$0: $self->{state}: Unknown state";
-     }
+       if ($self->{prev_state} == DATA_STATE) {
-   } # A
+         !!!cp (997);
+         $self->{state} = $self->{prev_state};
-   die "$0: _get_next_token: unexpected case";
+         ## Reconsume.
- } # _get_next_token
+         !!!emit ({type => CHARACTER_TOKEN, data => '&',
+                   line => $self->{line_prev},
- sub _tokenize_attempt_to_consume_an_entity ($$$) {
+                   column => $self->{column_prev},
-   my ($self, $in_attr, $additional) = @_;
+                  });
+         redo A;
-   my ($l, $c) = ($self->{line_prev}, $self->{column_prev});
+       } else {
+         !!!cp (996);
+         $self->{current_attribute}->{value} .= '&';
+         $self->{state} = $self->{prev_state};
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == ENTITY_HASH_STATE) {
+       if ($self->{next_char} == 0x0078 or # x
+           $self->{next_char} == 0x0058) { # X
+         !!!cp (995);
+         $self->{state} = HEXREF_X_STATE;
+         $self->{state_keyword} .= chr $self->{next_char};
+         !!!next-input-character;
+         redo A;
+       } elsif (0x0030 <= $self->{next_char} and
+                $self->{next_char} <= 0x0039) { # 0..9
+         !!!cp (994);
+         $self->{state} = NCR_NUM_STATE;
+         $self->{state_keyword} = $self->{next_char} - 0x0030;
+         !!!next-input-character;
+         redo A;
+       } else {
+         !!!parse-error (type => 'bare nero',
+                         line => $self->{line_prev},
+                         column => $self->{column_prev} - 1);
-   if ({
+         ## NOTE: According to the spec algorithm, nothing is returned,
-x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, # HT, LF, VT, FF,
+         ## and then "&#" is appended to the parent element or the attribute
-x0020 => 1, 0x003C => 1, 0x0026 => 1, -1 => 1, # SP, <, & # 0x000D # CR
+         ## value in the later processing.
-        $additional => 1,
-       }->{$self->{next_char}}) {
+         if ($self->{prev_state} == DATA_STATE) {
-     !!!cp (1001);
+           !!!cp (1019);
-     ## Don't consume
+           $self->{state} = $self->{prev_state};
-     ## No error
+           ## Reconsume.
-     return undef;
+           !!!emit ({type => CHARACTER_TOKEN,
-   } elsif ($self->{next_char} == 0x0023) { # #
+                     data => '&#',
-     !!!next-input-character;
+                     line => $self->{line_prev},
-     if ($self->{next_char} == 0x0078 or # x
+                     column => $self->{column_prev} - 1,
-         $self->{next_char} == 0x0058) { # X
+                    });
-       my $code;
+           redo A;
-       X: {
-         my $x_char = $self->{next_char};
-         !!!next-input-character;
-         if (0x0030 <= $self->{next_char} and
-             $self->{next_char} <= 0x0039) { # 0..9
-           !!!cp (1002);
-           $code ||= 0;
-           $code *= 0x10;
-           $code += $self->{next_char} - 0x0030;
-           redo X;
-         } elsif (0x0061 <= $self->{next_char} and
-                  $self->{next_char} <= 0x0066) { # a..f
-           !!!cp (1003);
-           $code ||= 0;
-           $code *= 0x10;
-           $code += $self->{next_char} - 0x0060 + 9;
-           redo X;
-         } elsif (0x0041 <= $self->{next_char} and
-                  $self->{next_char} <= 0x0046) { # A..F
-           !!!cp (1004);
-           $code ||= 0;
-           $code *= 0x10;
-           $code += $self->{next_char} - 0x0040 + 9;
-           redo X;
-         } elsif (not defined $code) { # no hexadecimal digit
-           !!!cp (1005);
-           !!!parse-error (type => 'bare hcro', line => $l, column => $c);
-           !!!back-next-input-character ($x_char, $self->{next_char});
-           $self->{next_char} = 0x0023; # #
-           return undef;
-         } elsif ($self->{next_char} == 0x003B) { # ;
-           !!!cp (1006);
-           !!!next-input-character;
          } else {
-           !!!cp (1007);
+           !!!cp (993);
-           !!!parse-error (type => 'no refc', line => $l, column => $c);
+           $self->{current_attribute}->{value} .= '&#';
+           $self->{state} = $self->{prev_state};
+           ## Reconsume.
+           redo A;
          }
+       }
-         if ($code == 0 or (0xD800 <= $code and $code <= 0xDFFF)) {
+     } elsif ($self->{state} == NCR_NUM_STATE) {
-           !!!cp (1008);
+       if (0x0030 <= $self->{next_char} and
-           !!!parse-error (type => 'invalid character reference',
+           $self->{next_char} <= 0x0039) { # 0..9
-                           text => (sprintf 'U+%04X', $code),
-                           line => $l, column => $c);
-           $code = 0xFFFD;
-         } elsif ($code > 0x10FFFF) {
-           !!!cp (1009);
-           !!!parse-error (type => 'invalid character reference',
-                           text => (sprintf 'U-%08X', $code),
-                           line => $l, column => $c);
-           $code = 0xFFFD;
-         } elsif ($code == 0x000D) {
-           !!!cp (1010);
-           !!!parse-error (type => 'CR character reference', line => $l, column => $c);
-           $code = 0x000A;
-         } elsif (0x80 <= $code and $code <= 0x9F) {
-           !!!cp (1011);
-           !!!parse-error (type => 'C1 character reference', text => (sprintf 'U+%04X', $code), line => $l, column => $c);
-           $code = $c1_entity_char->{$code};
-         }
-         return {type => CHARACTER_TOKEN, data => chr $code,
-                 has_reference => 1,
-                 line => $l, column => $c,
-                };
-       } # X
-     } elsif (0x0030 <= $self->{next_char} and
-              $self->{next_char} <= 0x0039) { # 0..9
-       my $code = $self->{next_char} - 0x0030;
-       !!!next-input-character;
-       while (0x0030 <= $self->{next_char} and
-                 $self->{next_char} <= 0x0039) { # 0..9
          !!!cp (1012);
-         $code *= 10;
+         $self->{state_keyword} *= 10;
-         $code += $self->{next_char} - 0x0030;
+         $self->{state_keyword} += $self->{next_char} - 0x0030;
+         ## Stay in the state.
          !!!next-input-character;
-       }
+         redo A;
+       } elsif ($self->{next_char} == 0x003B) { # ;
-       if ($self->{next_char} == 0x003B) { # ;
          !!!cp (1013);
          !!!next-input-character;
+         #
        } else {
          !!!cp (1014);
-         !!!parse-error (type => 'no refc', line => $l, column => $c);
+         !!!parse-error (type => 'no refc');
+         ## Reconsume.
+         #
        }
+       my $code = $self->{state_keyword};
+       my $l = $self->{line_prev};
+       my $c = $self->{column_prev};
        if ($code == 0 or (0xD800 <= $code and $code <= 0xDFFF)) {
          !!!cp (1015);
          !!!parse-error (type => 'invalid character reference',
-Line 2996 
 sub _tokenize_attempt_to_consume_an_enti
+Line 3103 
 sub _tokenize_attempt_to_consume_an_enti
                          line => $l, column => $c);
          $code = $c1_entity_char->{$code};
        }
-       return {type => CHARACTER_TOKEN, data => chr $code, has_reference => 1,
+       if ($self->{prev_state} == DATA_STATE) {
-               line => $l, column => $c,
+         !!!cp (992);
-              };
+         $self->{state} = $self->{prev_state};
-     } else {
+         ## Reconsume.
-       !!!cp (1019);
+         !!!emit ({type => CHARACTER_TOKEN, data => chr $code,
-       !!!parse-error (type => 'bare nero', line => $l, column => $c);
+                   line => $l, column => $c,
-       !!!back-next-input-character ($self->{next_char});
+                  });
-       $self->{next_char} = 0x0023; # #
+         redo A;
-       return undef;
+       } else {
-     }
+         !!!cp (991);
-   } elsif ((0x0041 <= $self->{next_char} and
+         $self->{current_attribute}->{value} .= chr $code;
-             $self->{next_char} <= 0x005A) or
+         $self->{current_attribute}->{has_reference} = 1;
-            (0x0061 <= $self->{next_char} and
+         $self->{state} = $self->{prev_state};
-             $self->{next_char} <= 0x007A)) {
+         ## Reconsume.
-     my $entity_name = chr $self->{next_char};
+         redo A;
-     !!!next-input-character;
+       }
+     } elsif ($self->{state} == HEXREF_X_STATE) {
-     my $value = $entity_name;
+       if ((0x0030 <= $self->{next_char} and $self->{next_char} <= 0x0039) or
-     my $match = 0;
+           (0x0041 <= $self->{next_char} and $self->{next_char} <= 0x0046) or
-     require Whatpm::_NamedEntityList;
+           (0x0061 <= $self->{next_char} and $self->{next_char} <= 0x0066)) {
-     our $EntityChar;
+         # 0..9, A..F, a..f
+         !!!cp (990);
-     while (length $entity_name < 30 and
+         $self->{state} = HEXREF_HEX_STATE;
-            ## NOTE: Some number greater than the maximum length of entity name
+         $self->{state_keyword} = 0;
-            ((0x0041 <= $self->{next_char} and # a
+         ## Reconsume.
-              $self->{next_char} <= 0x005A) or # x
+         redo A;
-             (0x0061 <= $self->{next_char} and # a
+       } else {
-              $self->{next_char} <= 0x007A) or # z
+         !!!parse-error (type => 'bare hcro',
-             (0x0030 <= $self->{next_char} and # 0
+                         line => $self->{line_prev},
-              $self->{next_char} <= 0x0039) or # 9
+                         column => $self->{column_prev} - 2);
-             $self->{next_char} == 0x003B)) { # ;
-       $entity_name .= chr $self->{next_char};
+         ## NOTE: According to the spec algorithm, nothing is returned,
-       if (defined $EntityChar->{$entity_name}) {
+         ## and then "&#" followed by "X" or "x" is appended to the parent
-         if ($self->{next_char} == 0x003B) { # ;
+         ## element or the attribute value in the later processing.
-           !!!cp (1020);
-           $value = $EntityChar->{$entity_name};
+         if ($self->{prev_state} == DATA_STATE) {
-           $match = 1;
+           !!!cp (1005);
-           !!!next-input-character;
+           $self->{state} = $self->{prev_state};
-           last;
+           ## Reconsume.
+           !!!emit ({type => CHARACTER_TOKEN,
+                     data => '&' . $self->{state_keyword},
+                     line => $self->{line_prev},
+                     column => $self->{column_prev} - length $self->{state_keyword},
+                    });
+           redo A;
          } else {
-           !!!cp (1021);
+           !!!cp (989);
-           $value = $EntityChar->{$entity_name};
+           $self->{current_attribute}->{value} .= '&' . $self->{state_keyword};
-           $match = -1;
+           $self->{state} = $self->{prev_state};
+           ## Reconsume.
+           redo A;
+         }
+       }
+     } elsif ($self->{state} == HEXREF_HEX_STATE) {
+       if (0x0030 <= $self->{next_char} and $self->{next_char} <= 0x0039) {
+         # 0..9
+         !!!cp (1002);
+         $self->{state_keyword} *= 0x10;
+         $self->{state_keyword} += $self->{next_char} - 0x0030;
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif (0x0061 <= $self->{next_char} and
+                $self->{next_char} <= 0x0066) { # a..f
+         !!!cp (1003);
+         $self->{state_keyword} *= 0x10;
+         $self->{state_keyword} += $self->{next_char} - 0x0060 + 9;
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif (0x0041 <= $self->{next_char} and
+                $self->{next_char} <= 0x0046) { # A..F
+         !!!cp (1004);
+         $self->{state_keyword} *= 0x10;
+         $self->{state_keyword} += $self->{next_char} - 0x0040 + 9;
+         ## Stay in the state.
+         !!!next-input-character;
+         redo A;
+       } elsif ($self->{next_char} == 0x003B) { # ;
+         !!!cp (1006);
+         !!!next-input-character;
+         #
+       } else {
+         !!!cp (1007);
+         !!!parse-error (type => 'no refc',
+                         line => $self->{line},
+                         column => $self->{column});
+         ## Reconsume.
+         #
+       }
+       my $code = $self->{state_keyword};
+       my $l = $self->{line_prev};
+       my $c = $self->{column_prev};
+       if ($code == 0 or (0xD800 <= $code and $code <= 0xDFFF)) {
+         !!!cp (1008);
+         !!!parse-error (type => 'invalid character reference',
+                         text => (sprintf 'U+%04X', $code),
+                         line => $l, column => $c);
+         $code = 0xFFFD;
+       } elsif ($code > 0x10FFFF) {
+         !!!cp (1009);
+         !!!parse-error (type => 'invalid character reference',
+                         text => (sprintf 'U-%08X', $code),
+                         line => $l, column => $c);
+         $code = 0xFFFD;
+       } elsif ($code == 0x000D) {
+         !!!cp (1010);
+         !!!parse-error (type => 'CR character reference', line => $l, column => $c);
+         $code = 0x000A;
+       } elsif (0x80 <= $code and $code <= 0x9F) {
+         !!!cp (1011);
+         !!!parse-error (type => 'C1 character reference', text => (sprintf 'U+%04X', $code), line => $l, column => $c);
+         $code = $c1_entity_char->{$code};
+       }
+       if ($self->{prev_state} == DATA_STATE) {
+         !!!cp (988);
+         $self->{state} = $self->{prev_state};
+         ## Reconsume.
+         !!!emit ({type => CHARACTER_TOKEN, data => chr $code,
+                   line => $l, column => $c,
+                  });
+         redo A;
+       } else {
+         !!!cp (987);
+         $self->{current_attribute}->{value} .= chr $code;
+         $self->{current_attribute}->{has_reference} = 1;
+         $self->{state} = $self->{prev_state};
+         ## Reconsume.
+         redo A;
+       }
+     } elsif ($self->{state} == ENTITY_NAME_STATE) {
+       if (length $self->{state_keyword} < 30 and
+           ## NOTE: Some number greater than the maximum length of entity name
+           ((0x0041 <= $self->{next_char} and # a
+             $self->{next_char} <= 0x005A) or # x
+            (0x0061 <= $self->{next_char} and # a
+             $self->{next_char} <= 0x007A) or # z
+            (0x0030 <= $self->{next_char} and # 0
+             $self->{next_char} <= 0x0039) or # 9
+            $self->{next_char} == 0x003B)) { # ;
+         our $EntityChar;
+         $self->{state_keyword} .= chr $self->{next_char};
+         if (defined $EntityChar->{$self->{state_keyword}}) {
+           if ($self->{next_char} == 0x003B) { # ;
+             !!!cp (1020);
+             $self->{entity__value} = $EntityChar->{$self->{state_keyword}};
+             $self->{entity__match} = 1;
+             !!!next-input-character;
+             #
+           } else {
+             !!!cp (1021);
+             $self->{entity__value} = $EntityChar->{$self->{state_keyword}};
+             $self->{entity__match} = -1;
+             ## Stay in the state.
+             !!!next-input-character;
+             redo A;
+           }
+         } else {
+           !!!cp (1022);
+           $self->{entity__value} .= chr $self->{next_char};
+           $self->{entity__match} *= 2;
+           ## Stay in the state.
            !!!next-input-character;
+           redo A;
+         }
+       }
+       my $data;
+       my $has_ref;
+       if ($self->{entity__match} > 0) {
+         !!!cp (1023);
+         $data = $self->{entity__value};
+         $has_ref = 1;
+         #
+       } elsif ($self->{entity__match} < 0) {
+         !!!parse-error (type => 'no refc');
+         if ($self->{prev_state} != DATA_STATE and # in attribute
+             $self->{entity__match} < -1) {
+           !!!cp (1024);
+           $data = '&' . $self->{state_keyword};
+           #
+         } else {
+           !!!cp (1025);
+           $data = $self->{entity__value};
+           $has_ref = 1;
+           #
          }
        } else {
-         !!!cp (1022);
+         !!!cp (1026);
-         $value .= chr $self->{next_char};
+         !!!parse-error (type => 'bare ero',
-         $match *= 2;
+                         line => $self->{line_prev},
-         !!!next-input-character;
+                         column => $self->{column_prev});
+         $data = '&' . $self->{state_keyword};
+         #
        }
-     }
+       ## NOTE: In these cases, when a character reference is found,
-     if ($match > 0) {
+       ## it is consumed and a character token is returned, or, otherwise,
-       !!!cp (1023);
+       ## nothing is consumed and returned, according to the spec algorithm.
-       return {type => CHARACTER_TOKEN, data => $value, has_reference => 1,
+       ## In this implementation, anything that has been examined by the
-               line => $l, column => $c,
+       ## tokenizer is appended to the parent element or the attribute value
-              };
+       ## as string, either literal string when no character reference or
-     } elsif ($match < 0) {
+       ## entity-replaced string otherwise, in this stage, since any characters
-       !!!parse-error (type => 'no refc', line => $l, column => $c);
+       ## that would not be consumed are appended in the data state or in an
-       if ($in_attr and $match < -1) {
+       ## appropriate attribute value state anyway.
-         !!!cp (1024);
-         return {type => CHARACTER_TOKEN, data => '&'.$entity_name,
+       if ($self->{prev_state} == DATA_STATE) {
-                 line => $l, column => $c,
+         !!!cp (986);
-                };
+         $self->{state} = $self->{prev_state};
-       } else {
+         ## Reconsume.
-         !!!cp (1025);
+         !!!emit ({type => CHARACTER_TOKEN,
-         return {type => CHARACTER_TOKEN, data => $value, has_reference => 1,
+                   data => $data,
-                 line => $l, column => $c,
+                   line => $self->{line_prev},
-                };
+                   column => $self->{column_prev} + 1 - length $self->{state_keyword},
+                  });
+         redo A;
+       } else {
+         !!!cp (985);
+         $self->{current_attribute}->{value} .= $data;
+         $self->{current_attribute}->{has_reference} = 1 if $has_ref;
+         $self->{state} = $self->{prev_state};
+         ## Reconsume.
+         redo A;
        }
      } else {
-       !!!cp (1026);
+       die "$0: $self->{state}: Unknown state";
-       !!!parse-error (type => 'bare ero', line => $l, column => $c);
-       ## NOTE: "No characters are consumed" in the spec.
-       return {type => CHARACTER_TOKEN, data => '&'.$value,
-               line => $l, column => $c,
-              };
      }
-   } else {
+   } # A
-     !!!cp (1027);
-     ## no characters are consumed
+   die "$0: _get_next_token: unexpected case";
-     !!!parse-error (type => 'bare ero', line => $l, column => $c);
+ } # _get_next_token
-     return undef;
-   }
- } # _tokenize_attempt_to_consume_an_entity
  sub _initialize_tree_constructor ($) {
    my $self = shift;
-Line 3147 
 sub _tree_construction_initial ($) {
+Line 3401 
 sub _tree_construction_initial ($) {
        ## language.
        my $doctype_name = $token->{name};
        $doctype_name = '' unless defined $doctype_name;
-       $doctype_name =~ tr/a-z/A-Z/;
+       $doctype_name =~ tr/a-z/A-Z/; # ASCII case-insensitive
        if (not defined $token->{name} or # <!DOCTYPE>
-           defined $token->{public_identifier} or
            defined $token->{system_identifier}) {
          !!!cp ('t1');
          !!!parse-error (type => 'not HTML5', token => $token);
        } elsif ($doctype_name ne 'HTML') {
          !!!cp ('t2');
-         ## ISSUE: ASCII case-insensitive? (in fact it does not matter)
          !!!parse-error (type => 'not HTML5', token => $token);
+       } elsif (defined $token->{public_identifier}) {
+         if ($token->{public_identifier} eq 'XSLT-compat') {
+           !!!cp ('t1.2');
+           !!!parse-error (type => 'XSLT-compat', token => $token,
+                           level => $self->{level}->{should});
+         } else {
+           !!!parse-error (type => 'not HTML5', token => $token);
+         }
        } else {
          !!!cp ('t3');
+         #
        }
        my $doctype = $self->{document}->create_document_type_definition
-Line 6294 
 sub _tree_construction_main ($) {
+Line 6555 
 sub _tree_construction_main ($) {
            } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) {
              !!!cp ('t312');
              !!!parse-error (type => 'after frameset:#text', token => $token);
-           } else { # "after html frameset"
+           } else { # "after after frameset"
              !!!cp ('t313');
              !!!parse-error (type => 'after html:#text', token => $token);
-             $self->{insertion_mode} = AFTER_FRAMESET_IM;
-             ## Reprocess in the "after frameset" insertion mode.
-             !!!parse-error (type => 'after frameset:#text', token => $token);
            }
            ## Ignore the token.
-Line 6316 
 sub _tree_construction_main ($) {
+Line 6573 
 sub _tree_construction_main ($) {
          die qq[$0: Character "$token->{data}"];
        } elsif ($token->{type} == START_TAG_TOKEN) {
-         if ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
-           !!!cp ('t316');
-           !!!parse-error (type => 'after html',
-                           text => $token->{tag_name}, token => $token);
-           $self->{insertion_mode} = AFTER_FRAMESET_IM;
-           ## Process in the "after frameset" insertion mode.
-         } else {
-           !!!cp ('t317');
-         }
          if ($token->{tag_name} eq 'frameset' and
              $self->{insertion_mode} == IN_FRAMESET_IM) {
            !!!cp ('t318');
-Line 6347 
 sub _tree_construction_main ($) {
+Line 6593 
 sub _tree_construction_main ($) {
            ## NOTE: As if in head.
            $parse_rcdata->(CDATA_CONTENT_MODEL);
            next B;
+           ## NOTE: |<!DOCTYPE HTML><frameset></frameset></html><noframes></noframes>|
+           ## has no parse error.
          } else {
            if ($self->{insertion_mode} == IN_FRAMESET_IM) {
              !!!cp ('t321');
              !!!parse-error (type => 'in frameset',
                              text => $token->{tag_name}, token => $token);
-           } else {
+           } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) {
              !!!cp ('t322');
              !!!parse-error (type => 'after frameset',
                              text => $token->{tag_name}, token => $token);
+           } else { # "after after frameset"
+             !!!cp ('t322.2');
+             !!!parse-error (type => 'after after frameset',
+                             text => $token->{tag_name}, token => $token);
            }
            ## Ignore the token
            !!!nack ('t322.1');
-Line 6363 
 sub _tree_construction_main ($) {
+Line 6616 
 sub _tree_construction_main ($) {
            next B;
          }
        } elsif ($token->{type} == END_TAG_TOKEN) {
-         if ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
-           !!!cp ('t323');
-           !!!parse-error (type => 'after html:/',
-                           text => $token->{tag_name}, token => $token);
-           $self->{insertion_mode} = AFTER_FRAMESET_IM;
-           ## Process in the "after frameset" insertion mode.
-         } else {
-           !!!cp ('t324');
-         }
          if ($token->{tag_name} eq 'frameset' and
              $self->{insertion_mode} == IN_FRAMESET_IM) {
            if ($self->{open_elements}->[-1]->[1] & HTML_EL and
-Line 6408 
 sub _tree_construction_main ($) {
+Line 6650 
 sub _tree_construction_main ($) {
              !!!cp ('t330');
              !!!parse-error (type => 'in frameset:/',
                              text => $token->{tag_name}, token => $token);
-           } else {
+           } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) {
-             !!!cp ('t331');
+             !!!cp ('t330.1');
              !!!parse-error (type => 'after frameset:/',
                              text => $token->{tag_name}, token => $token);
+           } else { # "after after html"
+             !!!cp ('t331');
+             !!!parse-error (type => 'after after frameset:/',
+                             text => $token->{tag_name}, token => $token);
            }
            ## Ignore the token
            !!!next-token;
-Line 7134 
 sub _tree_construction_main ($) {
+Line 7380 
 sub _tree_construction_main ($) {
            !!!cp ('t413');
            !!!parse-error (type => 'unmatched end tag',
                            text => $token->{tag_name}, token => $token);
+           ## NOTE: Ignore the token.
          } else {
            ## Step 1. generate implied end tags
            while ({
-Line 7193 
 sub _tree_construction_main ($) {
+Line 7440 
 sub _tree_construction_main ($) {
            !!!cp ('t421');
            !!!parse-error (type => 'unmatched end tag',
                            text => $token->{tag_name}, token => $token);
+           ## NOTE: Ignore the token.
          } else {
            ## Step 1. generate implied end tags
            while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
-Line 7239 
 sub _tree_construction_main ($) {
+Line 7487 
 sub _tree_construction_main ($) {
            !!!cp ('t425.1');
            !!!parse-error (type => 'unmatched end tag',
                            text => $token->{tag_name}, token => $token);
+           ## NOTE: Ignore the token.
          } else {
            ## Step 1. generate implied end tags
            while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
-Line 7441 
 sub _tree_construction_main ($) {
+Line 7690 
 sub _tree_construction_main ($) {
    ## TODO: script stuffs
  } # _tree_construct_main
- sub set_inner_html ($$$) {
+ sub set_inner_html ($$$;$) {
    my $class = shift;
    my $node = shift;
    my $s = \$_[0];
    my $onerror = $_[1];
+   my $get_wrapper = $_[2] || sub ($) { return $_[0] };
    ## ISSUE: Should {confident} be true?
-Line 7464 
 sub set_inner_html ($$$) {
+Line 7714 
 sub set_inner_html ($$$) {
      }
      ## Step 3, 4, 5 # MUST
-     $class->parse_string ($$s => $node, $onerror);
+     $class->parse_char_string ($$s => $node, $onerror, $get_wrapper);
    } elsif ($nt == 1) {
      ## TODO: If non-html element
      ## NOTE: Most of this code is copied from |parse_string|
+ ## TODO: Support for $get_wrapper
      ## Step 1 # MUST
      my $this_doc = $node->owner_document;
      my $doc = $this_doc->implementation->create_document;
-Line 7542 
 sub set_inner_html ($$$) {
+Line 7794 
 sub set_inner_html ($$$) {
      };
      $p->{prev_char} = [-1, -1, -1];
      $p->{next_char} = -1;
+     $p->{read_until} = sub {
+       ## TODO: ...
+       return 0;
+     }; # $p->{read_until};
      my $ponerror = $onerror || sub {
        my (%opt) = @_;
        my $line = $opt{line};

 Legend:



Removed from v.1.155
 


changed lines


 
Added in v.1.172
 Legend:



Removed from v.1.155
 


changed lines


 
Added in v.1.172
-Removed from v.1.155
+Added in v.1.172

[email protected]	ViewVC Help
Powered by ViewVC 1.1.24