/[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.121 by wakaba, Thu Mar 20 08:04:58 2008 UTC revision 1.243 by wakaba, Sun Sep 6 13:52:06 2009 UTC
# Line 3  use strict; Line 3  use strict;
3  our $VERSION=do{my @r=(q$Revision$=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};  our $VERSION=do{my @r=(q$Revision$=~/\d+/g);sprintf "%d."."%02d" x $#r,@r};
4  use Error qw(:try);  use Error qw(:try);
5    
6    use Whatpm::HTML::Tokenizer;
7    
8    ## NOTE: This module don't check all HTML5 parse errors; character
9    ## encoding related parse errors are expected to be handled by relevant
10    ## modules.
11    ## Parse errors for control characters that are not allowed in HTML5
12    ## documents, for surrogate code points, and for noncharacter code
13    ## points, as well as U+FFFD substitions for characters whose code points
14    ## is higher than U+10FFFF may be detected by combining the parser with
15    ## the checker implemented by Whatpm::Charset::UnicodeChecker (for its
16    ## usage example, see |t/HTML-tree.t| in the Whatpm package or the
17    ## WebHACC::Language::HTML module in the WebHACC package).
18    
19  ## ISSUE:  ## ISSUE:
20  ## var doc = implementation.createDocument (null, null, null);  ## var doc = implementation.createDocument (null, null, null);
21  ## doc.write ('');  ## doc.write ('');
22  ## alert (doc.compatMode);  ## alert (doc.compatMode);
23    
24  ## TODO: Control charcters and noncharacters are not allowed (HTML5 revision 1263)  require IO::Handle;
25  ## TODO: 1252 parse error (revision 1264)  
26  ## TODO: 8859-11 = 874 (revision 1271)  ## Namespace URLs
27    
28  my $permitted_slash_tag_name = {  my $HTML_NS = q<http://www.w3.org/1999/xhtml>;
29    base => 1,  my $MML_NS = q<http://www.w3.org/1998/Math/MathML>;
30    link => 1,  my $SVG_NS = q<http://www.w3.org/2000/svg>;
31    meta => 1,  my $XLINK_NS = q<http://www.w3.org/1999/xlink>;
32    hr => 1,  my $XML_NS = q<http://www.w3.org/XML/1998/namespace>;
33    br => 1,  my $XMLNS_NS = q<http://www.w3.org/2000/xmlns/>;
34    img => 1,  
35    embed => 1,  ## Element categories
36    param => 1,  
37    area => 1,  ## Bits 12-15
38    col => 1,  sub SPECIAL_EL () { 0b1_000000000000000 }
39    input => 1,  sub SCOPING_EL () { 0b1_00000000000000 }
40    sub FORMATTING_EL () { 0b1_0000000000000 }
41    sub PHRASING_EL () { 0b1_000000000000 }
42    
43    ## Bits 10-11
44    #sub FOREIGN_EL () { 0b1_00000000000 } # see Whatpm::HTML::Tokenizer
45    sub FOREIGN_FLOW_CONTENT_EL () { 0b1_0000000000 }
46    
47    ## Bits 6-9
48    sub TABLE_SCOPING_EL () { 0b1_000000000 }
49    sub TABLE_ROWS_SCOPING_EL () { 0b1_00000000 }
50    sub TABLE_ROW_SCOPING_EL () { 0b1_0000000 }
51    sub TABLE_ROWS_EL () { 0b1_000000 }
52    
53    ## Bit 5
54    sub ADDRESS_DIV_P_EL () { 0b1_00000 }
55    
56    ## NOTE: Used in </body> and EOF algorithms.
57    ## Bit 4
58    sub ALL_END_TAG_OPTIONAL_EL () { 0b1_0000 }
59    
60    ## NOTE: Used in "generate implied end tags" algorithm.
61    ## NOTE: There is a code where a modified version of
62    ## END_TAG_OPTIONAL_EL is used in "generate implied end tags"
63    ## implementation (search for the algorithm name).
64    ## Bit 3
65    sub END_TAG_OPTIONAL_EL () { 0b1_000 }
66    
67    ## Bits 0-2
68    
69    sub MISC_SPECIAL_EL () { SPECIAL_EL | 0b000 }
70    sub FORM_EL () { SPECIAL_EL | 0b001 }
71    sub FRAMESET_EL () { SPECIAL_EL | 0b010 }
72    sub HEADING_EL () { SPECIAL_EL | 0b011 }
73    sub SELECT_EL () { SPECIAL_EL | 0b100 }
74    sub SCRIPT_EL () { SPECIAL_EL | 0b101 }
75    
76    sub ADDRESS_DIV_EL () { SPECIAL_EL | ADDRESS_DIV_P_EL | 0b001 }
77    sub BODY_EL () { SPECIAL_EL | ALL_END_TAG_OPTIONAL_EL | 0b001 }
78    
79    sub DTDD_EL () {
80      SPECIAL_EL |
81      END_TAG_OPTIONAL_EL |
82      ALL_END_TAG_OPTIONAL_EL |
83      0b010
84    }
85    sub LI_EL () {
86      SPECIAL_EL |
87      END_TAG_OPTIONAL_EL |
88      ALL_END_TAG_OPTIONAL_EL |
89      0b100
90    }
91    sub P_EL () {
92      SPECIAL_EL |
93      ADDRESS_DIV_P_EL |
94      END_TAG_OPTIONAL_EL |
95      ALL_END_TAG_OPTIONAL_EL |
96      0b001
97    }
98    
99    sub TABLE_ROW_EL () {
100      SPECIAL_EL |
101      TABLE_ROWS_EL |
102      TABLE_ROW_SCOPING_EL |
103      ALL_END_TAG_OPTIONAL_EL |
104      0b001
105    }
106    sub TABLE_ROW_GROUP_EL () {
107      SPECIAL_EL |
108      TABLE_ROWS_EL |
109      TABLE_ROWS_SCOPING_EL |
110      ALL_END_TAG_OPTIONAL_EL |
111      0b001
112    }
113    
114    sub MISC_SCOPING_EL () { SCOPING_EL | 0b000 }
115    sub BUTTON_EL () { SCOPING_EL | 0b001 }
116    sub CAPTION_EL () { SCOPING_EL | 0b010 }
117    sub HTML_EL () {
118      SCOPING_EL |
119      TABLE_SCOPING_EL |
120      TABLE_ROWS_SCOPING_EL |
121      TABLE_ROW_SCOPING_EL |
122      ALL_END_TAG_OPTIONAL_EL |
123      0b001
124    }
125    sub TABLE_EL () {
126      SCOPING_EL |
127      TABLE_ROWS_EL |
128      TABLE_SCOPING_EL |
129      0b001
130    }
131    sub TABLE_CELL_EL () {
132      SCOPING_EL |
133      TABLE_ROW_SCOPING_EL |
134      ALL_END_TAG_OPTIONAL_EL |
135      0b001
136    }
137    
138    sub MISC_FORMATTING_EL () { FORMATTING_EL | 0b000 }
139    sub A_EL () { FORMATTING_EL | 0b001 }
140    sub NOBR_EL () { FORMATTING_EL | 0b010 }
141    
142    sub RUBY_EL () { PHRASING_EL | 0b001 }
143    
144    ## ISSUE: ALL_END_TAG_OPTIONAL_EL?
145    sub OPTGROUP_EL () { PHRASING_EL | END_TAG_OPTIONAL_EL | 0b001 }
146    sub OPTION_EL () { PHRASING_EL | END_TAG_OPTIONAL_EL | 0b010 }
147    sub RUBY_COMPONENT_EL () { PHRASING_EL | END_TAG_OPTIONAL_EL | 0b100 }
148    
149    sub MML_AXML_EL () { PHRASING_EL | FOREIGN_EL | 0b001 }
150    
151    my $el_category = {
152      a => A_EL,
153      address => ADDRESS_DIV_EL,
154      applet => MISC_SCOPING_EL,
155      area => MISC_SPECIAL_EL,
156      article => MISC_SPECIAL_EL,
157      aside => MISC_SPECIAL_EL,
158      b => FORMATTING_EL,
159      base => MISC_SPECIAL_EL,
160      basefont => MISC_SPECIAL_EL,
161      bgsound => MISC_SPECIAL_EL,
162      big => FORMATTING_EL,
163      blockquote => MISC_SPECIAL_EL,
164      body => BODY_EL,
165      br => MISC_SPECIAL_EL,
166      button => BUTTON_EL,
167      caption => CAPTION_EL,
168      center => MISC_SPECIAL_EL,
169      col => MISC_SPECIAL_EL,
170      colgroup => MISC_SPECIAL_EL,
171      command => MISC_SPECIAL_EL,
172      datagrid => MISC_SPECIAL_EL,
173      dd => DTDD_EL,
174      details => MISC_SPECIAL_EL,
175      dialog => MISC_SPECIAL_EL,
176      dir => MISC_SPECIAL_EL,
177      div => ADDRESS_DIV_EL,
178      dl => MISC_SPECIAL_EL,
179      dt => DTDD_EL,
180      em => FORMATTING_EL,
181      embed => MISC_SPECIAL_EL,
182      fieldset => MISC_SPECIAL_EL,
183      figure => MISC_SPECIAL_EL,
184      font => FORMATTING_EL,
185      footer => MISC_SPECIAL_EL,
186      form => FORM_EL,
187      frame => MISC_SPECIAL_EL,
188      frameset => FRAMESET_EL,
189      h1 => HEADING_EL,
190      h2 => HEADING_EL,
191      h3 => HEADING_EL,
192      h4 => HEADING_EL,
193      h5 => HEADING_EL,
194      h6 => HEADING_EL,
195      head => MISC_SPECIAL_EL,
196      header => MISC_SPECIAL_EL,
197      hgroup => MISC_SPECIAL_EL,
198      hr => MISC_SPECIAL_EL,
199      html => HTML_EL,
200      i => FORMATTING_EL,
201      iframe => MISC_SPECIAL_EL,
202      img => MISC_SPECIAL_EL,
203      #image => MISC_SPECIAL_EL, ## NOTE: Commented out in the spec.
204      input => MISC_SPECIAL_EL,
205      isindex => MISC_SPECIAL_EL,
206      ## XXX keygen? (Whether a void element is in Special or not does not
207      ## affect to the processing, however.)
208      li => LI_EL,
209      link => MISC_SPECIAL_EL,
210      listing => MISC_SPECIAL_EL,
211      marquee => MISC_SCOPING_EL,
212      menu => MISC_SPECIAL_EL,
213      meta => MISC_SPECIAL_EL,
214      nav => MISC_SPECIAL_EL,
215      nobr => NOBR_EL,
216      noembed => MISC_SPECIAL_EL,
217      noframes => MISC_SPECIAL_EL,
218      noscript => MISC_SPECIAL_EL,
219      object => MISC_SCOPING_EL,
220      ol => MISC_SPECIAL_EL,
221      optgroup => OPTGROUP_EL,
222      option => OPTION_EL,
223      p => P_EL,
224      param => MISC_SPECIAL_EL,
225      plaintext => MISC_SPECIAL_EL,
226      pre => MISC_SPECIAL_EL,
227      rp => RUBY_COMPONENT_EL,
228      rt => RUBY_COMPONENT_EL,
229      ruby => RUBY_EL,
230      s => FORMATTING_EL,
231      script => MISC_SPECIAL_EL,
232      select => SELECT_EL,
233      section => MISC_SPECIAL_EL,
234      small => FORMATTING_EL,
235      spacer => MISC_SPECIAL_EL,
236      strike => FORMATTING_EL,
237      strong => FORMATTING_EL,
238      style => MISC_SPECIAL_EL,
239      table => TABLE_EL,
240      tbody => TABLE_ROW_GROUP_EL,
241      td => TABLE_CELL_EL,
242      textarea => MISC_SPECIAL_EL,
243      tfoot => TABLE_ROW_GROUP_EL,
244      th => TABLE_CELL_EL,
245      thead => TABLE_ROW_GROUP_EL,
246      title => MISC_SPECIAL_EL,
247      tr => TABLE_ROW_EL,
248      tt => FORMATTING_EL,
249      u => FORMATTING_EL,
250      ul => MISC_SPECIAL_EL,
251      wbr => MISC_SPECIAL_EL,
252      xmp => MISC_SPECIAL_EL,
253  };  };
254    
255  my $c1_entity_char = {  my $el_category_f = {
256    0x80 => 0x20AC,    $MML_NS => {
257    0x81 => 0xFFFD,      'annotation-xml' => MML_AXML_EL,
258    0x82 => 0x201A,      mi => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
259    0x83 => 0x0192,      mo => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
260    0x84 => 0x201E,      mn => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
261    0x85 => 0x2026,      ms => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
262    0x86 => 0x2020,      mtext => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
263    0x87 => 0x2021,    },
264    0x88 => 0x02C6,    $SVG_NS => {
265    0x89 => 0x2030,      foreignObject => SCOPING_EL | FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
266    0x8A => 0x0160,      desc => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
267    0x8B => 0x2039,      title => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL,
268    0x8C => 0x0152,    },
269    0x8D => 0xFFFD,    ## NOTE: In addition, FOREIGN_EL is set to non-HTML elements.
   0x8E => 0x017D,  
   0x8F => 0xFFFD,  
   0x90 => 0xFFFD,  
   0x91 => 0x2018,  
   0x92 => 0x2019,  
   0x93 => 0x201C,  
   0x94 => 0x201D,  
   0x95 => 0x2022,  
   0x96 => 0x2013,  
   0x97 => 0x2014,  
   0x98 => 0x02DC,  
   0x99 => 0x2122,  
   0x9A => 0x0161,  
   0x9B => 0x203A,  
   0x9C => 0x0153,  
   0x9D => 0xFFFD,  
   0x9E => 0x017E,  
   0x9F => 0x0178,  
 }; # $c1_entity_char  
   
 my $special_category = {  
   address => 1, area => 1, base => 1, basefont => 1, bgsound => 1,  
   blockquote => 1, body => 1, br => 1, center => 1, col => 1, colgroup => 1,  
   dd => 1, dir => 1, div => 1, dl => 1, dt => 1, embed => 1, fieldset => 1,  
   form => 1, frame => 1, frameset => 1, h1 => 1, h2 => 1, h3 => 1,  
   h4 => 1, h5 => 1, h6 => 1, head => 1, hr => 1, iframe => 1, image => 1,  
   img => 1, input => 1, isindex => 1, li => 1, link => 1, listing => 1,  
   menu => 1, meta => 1, noembed => 1, noframes => 1, noscript => 1,  
   ol => 1, optgroup => 1, option => 1, p => 1, param => 1, plaintext => 1,  
   pre => 1, script => 1, select => 1, spacer => 1, style => 1, tbody => 1,  
   textarea => 1, tfoot => 1, thead => 1, title => 1, tr => 1, ul => 1, wbr => 1,  
270  };  };
271  my $scoping_category = {  
272    applet => 1, button => 1, caption => 1, html => 1, marquee => 1, object => 1,  my $svg_attr_name = {
273    table => 1, td => 1, th => 1,    attributename => 'attributeName',
274      attributetype => 'attributeType',
275      basefrequency => 'baseFrequency',
276      baseprofile => 'baseProfile',
277      calcmode => 'calcMode',
278      clippathunits => 'clipPathUnits',
279      contentscripttype => 'contentScriptType',
280      contentstyletype => 'contentStyleType',
281      diffuseconstant => 'diffuseConstant',
282      edgemode => 'edgeMode',
283      externalresourcesrequired => 'externalResourcesRequired',
284      filterres => 'filterRes',
285      filterunits => 'filterUnits',
286      glyphref => 'glyphRef',
287      gradienttransform => 'gradientTransform',
288      gradientunits => 'gradientUnits',
289      kernelmatrix => 'kernelMatrix',
290      kernelunitlength => 'kernelUnitLength',
291      keypoints => 'keyPoints',
292      keysplines => 'keySplines',
293      keytimes => 'keyTimes',
294      lengthadjust => 'lengthAdjust',
295      limitingconeangle => 'limitingConeAngle',
296      markerheight => 'markerHeight',
297      markerunits => 'markerUnits',
298      markerwidth => 'markerWidth',
299      maskcontentunits => 'maskContentUnits',
300      maskunits => 'maskUnits',
301      numoctaves => 'numOctaves',
302      pathlength => 'pathLength',
303      patterncontentunits => 'patternContentUnits',
304      patterntransform => 'patternTransform',
305      patternunits => 'patternUnits',
306      pointsatx => 'pointsAtX',
307      pointsaty => 'pointsAtY',
308      pointsatz => 'pointsAtZ',
309      preservealpha => 'preserveAlpha',
310      preserveaspectratio => 'preserveAspectRatio',
311      primitiveunits => 'primitiveUnits',
312      refx => 'refX',
313      refy => 'refY',
314      repeatcount => 'repeatCount',
315      repeatdur => 'repeatDur',
316      requiredextensions => 'requiredExtensions',
317      requiredfeatures => 'requiredFeatures',
318      specularconstant => 'specularConstant',
319      specularexponent => 'specularExponent',
320      spreadmethod => 'spreadMethod',
321      startoffset => 'startOffset',
322      stddeviation => 'stdDeviation',
323      stitchtiles => 'stitchTiles',
324      surfacescale => 'surfaceScale',
325      systemlanguage => 'systemLanguage',
326      tablevalues => 'tableValues',
327      targetx => 'targetX',
328      targety => 'targetY',
329      textlength => 'textLength',
330      viewbox => 'viewBox',
331      viewtarget => 'viewTarget',
332      xchannelselector => 'xChannelSelector',
333      ychannelselector => 'yChannelSelector',
334      zoomandpan => 'zoomAndPan',
335  };  };
336  my $formatting_category = {  
337    a => 1, b => 1, big => 1, em => 1, font => 1, i => 1, nobr => 1,  my $foreign_attr_xname = {
338    s => 1, small => 1, strile => 1, strong => 1, tt => 1, u => 1,    'xlink:actuate' => [$XLINK_NS, ['xlink', 'actuate']],
339      'xlink:arcrole' => [$XLINK_NS, ['xlink', 'arcrole']],
340      'xlink:href' => [$XLINK_NS, ['xlink', 'href']],
341      'xlink:role' => [$XLINK_NS, ['xlink', 'role']],
342      'xlink:show' => [$XLINK_NS, ['xlink', 'show']],
343      'xlink:title' => [$XLINK_NS, ['xlink', 'title']],
344      'xlink:type' => [$XLINK_NS, ['xlink', 'type']],
345      'xml:base' => [$XML_NS, ['xml', 'base']],
346      'xml:lang' => [$XML_NS, ['xml', 'lang']],
347      'xml:space' => [$XML_NS, ['xml', 'space']],
348      'xmlns' => [$XMLNS_NS, [undef, 'xmlns']],
349      'xmlns:xlink' => [$XMLNS_NS, ['xmlns', 'xlink']],
350  };  };
351  # $phrasing_category: all other elements  
352    ## ISSUE: xmlns:xlink="non-xlink-ns" is not an error.
353    
354    ## TODO: Invoke the reset algorithm when a resettable element is
355    ## created (cf. HTML5 revision 2259).
356    
357  sub parse_byte_string ($$$$;$) {  sub parse_byte_string ($$$$;$) {
358      my $self = shift;
359      my $charset_name = shift;
360      open my $input, '<', ref $_[0] ? $_[0] : \($_[0]);
361      return $self->parse_byte_stream ($charset_name, $input, @_[1..$#_]);
362    } # parse_byte_string
363    
364    sub parse_byte_stream ($$$$;$$) {
365      # my ($self, $charset_name, $byte_stream, $doc, $onerror, $get_wrapper) = @_;
366    my $self = ref $_[0] ? shift : shift->new;    my $self = ref $_[0] ? shift : shift->new;
367    my $charset = shift;    my $charset_name = shift;
368    my $bytes_s = ref $_[0] ? $_[0] : \($_[0]);    my $byte_stream = $_[0];
369    my $s;  
370        my $onerror = $_[2] || sub {
371    if (defined $charset) {      my (%opt) = @_;
372      require Encode; ## TODO: decode(utf8) don't delete BOM      warn "Parse error ($opt{type})\n";
373      $s = \ (Encode::decode ($charset, $$bytes_s));    };
374      $self->{input_encoding} = lc $charset; ## TODO: normalize name    $self->{parse_error} = $onerror; # updated later by parse_char_string
375      $self->{confident} = 1;  
376    } else {    my $get_wrapper = $_[3] || sub ($) {
377      ## TODO: Implement HTML5 detection algorithm      return $_[0]; # $_[0] = byte stream handle, returned = arg to char handle
378      };
379    
380      ## HTML5 encoding sniffing algorithm
381      require Message::Charset::Info;
382      my $charset;
383      my $buffer;
384      my ($char_stream, $e_status);
385    
386      SNIFFING: {
387        ## NOTE: By setting |allow_fallback| option true when the
388        ## |get_decode_handle| method is invoked, we ignore what the HTML5
389        ## spec requires, i.e. unsupported encoding should be ignored.
390          ## TODO: We should not do this unless the parser is invoked
391          ## in the conformance checking mode, in which this behavior
392          ## would be useful.
393    
394        ## Step 1
395        if (defined $charset_name) {
396          $charset = Message::Charset::Info->get_by_html_name ($charset_name);
397              ## TODO: Is this ok?  Transfer protocol's parameter should be
398              ## interpreted in its semantics?
399    
400          ($char_stream, $e_status) = $charset->get_decode_handle
401              ($byte_stream, allow_error_reporting => 1,
402               allow_fallback => 1);
403          if ($char_stream) {
404            $self->{confident} = 1;
405            last SNIFFING;
406          } else {
407            !!!parse-error (type => 'charset:not supported',
408                            layer => 'encode',
409                            line => 1, column => 1,
410                            value => $charset_name,
411                            level => $self->{level}->{uncertain});
412          }
413        }
414    
415        ## Step 2
416        my $byte_buffer = '';
417        for (1..1024) {
418          my $char = $byte_stream->getc;
419          last unless defined $char;
420          $byte_buffer .= $char;
421        } ## TODO: timeout
422    
423        ## Step 3
424        if ($byte_buffer =~ /^\xFE\xFF/) {
425          $charset = Message::Charset::Info->get_by_html_name ('utf-16be');
426          ($char_stream, $e_status) = $charset->get_decode_handle
427              ($byte_stream, allow_error_reporting => 1,
428               allow_fallback => 1, byte_buffer => \$byte_buffer);
429          $self->{confident} = 1;
430          last SNIFFING;
431        } elsif ($byte_buffer =~ /^\xFF\xFE/) {
432          $charset = Message::Charset::Info->get_by_html_name ('utf-16le');
433          ($char_stream, $e_status) = $charset->get_decode_handle
434              ($byte_stream, allow_error_reporting => 1,
435               allow_fallback => 1, byte_buffer => \$byte_buffer);
436          $self->{confident} = 1;
437          last SNIFFING;
438        } elsif ($byte_buffer =~ /^\xEF\xBB\xBF/) {
439          $charset = Message::Charset::Info->get_by_html_name ('utf-8');
440          ($char_stream, $e_status) = $charset->get_decode_handle
441              ($byte_stream, allow_error_reporting => 1,
442               allow_fallback => 1, byte_buffer => \$byte_buffer);
443          $self->{confident} = 1;
444          last SNIFFING;
445        }
446    
447        ## Step 4
448        ## TODO: <meta charset>
449    
450        ## Step 5
451        ## TODO: from history
452    
453        ## Step 6
454      require Whatpm::Charset::UniversalCharDet;      require Whatpm::Charset::UniversalCharDet;
455      $charset = Whatpm::Charset::UniversalCharDet->detect_byte_string      $charset_name = Whatpm::Charset::UniversalCharDet->detect_byte_string
456          (substr ($$bytes_s, 0, 1024));          ($byte_buffer);
457      $charset ||= 'windows-1252';      if (defined $charset_name) {
458      $s = \ (Encode::decode ($charset, $$bytes_s));        $charset = Message::Charset::Info->get_by_html_name ($charset_name);
459      $self->{input_encoding} = $charset;  
460          require Whatpm::Charset::DecodeHandle;
461          $buffer = Whatpm::Charset::DecodeHandle::ByteBuffer->new
462              ($byte_stream);
463          ($char_stream, $e_status) = $charset->get_decode_handle
464              ($buffer, allow_error_reporting => 1,
465               allow_fallback => 1, byte_buffer => \$byte_buffer);
466          if ($char_stream) {
467            $buffer->{buffer} = $byte_buffer;
468            !!!parse-error (type => 'sniffing:chardet',
469                            text => $charset_name,
470                            level => $self->{level}->{info},
471                            layer => 'encode',
472                            line => 1, column => 1);
473            $self->{confident} = 0;
474            last SNIFFING;
475          }
476        }
477    
478        ## Step 7: default
479        ## TODO: Make this configurable.
480        $charset = Message::Charset::Info->get_by_html_name ('windows-1252');
481            ## NOTE: We choose |windows-1252| here, since |utf-8| should be
482            ## detectable in the step 6.
483        require Whatpm::Charset::DecodeHandle;
484        $buffer = Whatpm::Charset::DecodeHandle::ByteBuffer->new
485            ($byte_stream);
486        ($char_stream, $e_status)
487            = $charset->get_decode_handle ($buffer,
488                                           allow_error_reporting => 1,
489                                           allow_fallback => 1,
490                                           byte_buffer => \$byte_buffer);
491        $buffer->{buffer} = $byte_buffer;
492        !!!parse-error (type => 'sniffing:default',
493                        text => 'windows-1252',
494                        level => $self->{level}->{info},
495                        line => 1, column => 1,
496                        layer => 'encode');
497      $self->{confident} = 0;      $self->{confident} = 0;
498      } # SNIFFING
499    
500      if ($e_status & Message::Charset::Info::FALLBACK_ENCODING_IMPL ()) {
501        $self->{input_encoding} = $charset->get_iana_name; ## TODO: Should we set actual charset decoder's encoding name?
502        !!!parse-error (type => 'chardecode:fallback',
503                        #text => $self->{input_encoding},
504                        level => $self->{level}->{uncertain},
505                        line => 1, column => 1,
506                        layer => 'encode');
507      } elsif (not ($e_status &
508                    Message::Charset::Info::ERROR_REPORTING_ENCODING_IMPL ())) {
509        $self->{input_encoding} = $charset->get_iana_name;
510        !!!parse-error (type => 'chardecode:no error',
511                        text => $self->{input_encoding},
512                        level => $self->{level}->{uncertain},
513                        line => 1, column => 1,
514                        layer => 'encode');
515      } else {
516        $self->{input_encoding} = $charset->get_iana_name;
517    }    }
518    
519    $self->{change_encoding} = sub {    $self->{change_encoding} = sub {
520      my $self = shift;      my $self = shift;
521      my $charset = lc shift;      $charset_name = shift;
522      my $token = shift;      my $token = shift;
     ## TODO: if $charset is supported  
     ## TODO: normalize charset name  
523    
524      ## "Change the encoding" algorithm:      $charset = Message::Charset::Info->get_by_html_name ($charset_name);
525        ($char_stream, $e_status) = $charset->get_decode_handle
526            ($byte_stream, allow_error_reporting => 1, allow_fallback => 1,
527             byte_buffer => \ $buffer->{buffer});
528        
529        if ($char_stream) { # if supported
530          ## "Change the encoding" algorithm:
531          
532          ## Step 1
533          if (defined $self->{input_encoding} and
534              $self->{input_encoding} eq $charset_name) {
535            !!!parse-error (type => 'charset label:matching',
536                            text => $charset_name,
537                            level => $self->{level}->{info});
538            $self->{confident} = 1;
539            return;
540          }
541    
542      ## Step 1            ## Step 2 (HTML5 revision 3205)
543      if ($charset eq 'utf-16') { ## ISSUE: UTF-16BE -> UTF-8? UTF-16LE -> UTF-8?        if (defined $self->{input_encoding} and
544        $charset = 'utf-8';            Message::Charset::Info->get_by_html_name ($self->{input_encoding})
545      }            ->{category} & Message::Charset::Info::CHARSET_CATEGORY_UTF16 ()) {
546            $self->{confident} = 1;
547            return;
548          }
549    
550      ## Step 2        ## Step 3
551      if (defined $self->{input_encoding} and        if ($charset->{category} &
552          $self->{input_encoding} eq $charset) {            Message::Charset::Info::CHARSET_CATEGORY_UTF16 ()) {
553        $self->{confident} = 1;          $charset = Message::Charset::Info->get_by_html_name ('utf-8');
554        return;          ($char_stream, $e_status) = $charset->get_decode_handle
555                ($byte_stream,
556                 byte_buffer => \ $buffer->{buffer});
557          }
558          $charset_name = $charset->get_iana_name;
559    
560          !!!parse-error (type => 'charset label detected',
561                          text => $self->{input_encoding},
562                          value => $charset_name,
563                          level => $self->{level}->{warn},
564                          token => $token);
565          
566          ## Step 4
567          # if (can) {
568            ## change the encoding on the fly.
569            #$self->{confident} = 1;
570            #return;
571          # }
572          
573          ## Step 5
574          throw Whatpm::HTML::RestartParser ();
575      }      }
576      }; # $self->{change_encoding}
577    
578      !!!parse-error (type => 'charset label detected:'.$self->{input_encoding}.    my $char_onerror = sub {
579          ':'.$charset, level => 'w', token => $token);      my (undef, $type, %opt) = @_;
580        !!!parse-error (layer => 'encode',
581                        line => $self->{line}, column => $self->{column} + 1,
582                        %opt, type => $type);
583        if ($opt{octets}) {
584          ${$opt{octets}} = "\x{FFFD}"; # relacement character
585        }
586      };
587    
588      ## Step 3    my $wrapped_char_stream = $get_wrapper->($char_stream);
589      # if (can) {    $wrapped_char_stream->onerror ($char_onerror);
       ## change the encoding on the fly.  
       #$self->{confident} = 1;  
       #return;  
     # }  
590    
591      ## Step 4    my @args = ($_[1], $_[2]); # $doc, $onerror - $get_wrapper = undef;
     throw Whatpm::HTML::RestartParser (charset => $charset);  
   }; # $self->{change_encoding}  
   
   my @args = @_; shift @args; # $s  
592    my $return;    my $return;
593    try {    try {
594      $return = $self->parse_char_string ($s, @args);        $return = $self->parse_char_stream ($wrapped_char_stream, @args);  
595    } catch Whatpm::HTML::RestartParser with {    } catch Whatpm::HTML::RestartParser with {
596      my $charset = shift->{charset};      ## NOTE: Invoked after {change_encoding}.
597      $s = \ (Encode::decode ($charset, $$bytes_s));      
598      $self->{input_encoding} = $charset; ## TODO: normalize      if ($e_status & Message::Charset::Info::FALLBACK_ENCODING_IMPL ()) {
599          $self->{input_encoding} = $charset->get_iana_name; ## TODO: Should we set actual charset decoder's encoding name?
600          !!!parse-error (type => 'chardecode:fallback',
601                          level => $self->{level}->{uncertain},
602                          #text => $self->{input_encoding},
603                          line => 1, column => 1,
604                          layer => 'encode');
605        } elsif (not ($e_status &
606                      Message::Charset::Info::ERROR_REPORTING_ENCODING_IMPL ())) {
607          $self->{input_encoding} = $charset->get_iana_name;
608          !!!parse-error (type => 'chardecode:no error',
609                          text => $self->{input_encoding},
610                          level => $self->{level}->{uncertain},
611                          line => 1, column => 1,
612                          layer => 'encode');
613        } else {
614          $self->{input_encoding} = $charset->get_iana_name;
615        }
616      $self->{confident} = 1;      $self->{confident} = 1;
617      $return = $self->parse_char_string ($s, @args);  
618        $wrapped_char_stream = $get_wrapper->($char_stream);
619        $wrapped_char_stream->onerror ($char_onerror);
620    
621        $return = $self->parse_char_stream ($wrapped_char_stream, @args);
622    };    };
623    return $return;    return $return;
624  } # parse_byte_string  } # parse_byte_stream
625    
626  ## NOTE: HTML5 spec says that the encoding layer MUST NOT strip BOM  ## NOTE: HTML5 spec says that the encoding layer MUST NOT strip BOM
627  ## and the HTML layer MUST ignore it.  However, we does strip BOM in  ## and the HTML layer MUST ignore it.  However, we does strip BOM in
# Line 163  sub parse_byte_string ($$$$;$) { Line 632  sub parse_byte_string ($$$$;$) {
632  ## such as |parse_byte_string| in this module, must ensure that it does  ## such as |parse_byte_string| in this module, must ensure that it does
633  ## strip the BOM and never strip any ZWNBSP.  ## strip the BOM and never strip any ZWNBSP.
634    
635  *parse_char_string = \&parse_string;  sub parse_char_string ($$$;$$) {
636      #my ($self, $s, $doc, $onerror, $get_wrapper) = @_;
637      my $self = shift;
638      my $s = ref $_[0] ? $_[0] : \($_[0]);
639      require Whatpm::Charset::DecodeHandle;
640      my $input = Whatpm::Charset::DecodeHandle::CharString->new ($s);
641      return $self->parse_char_stream ($input, @_[1..$#_]);
642    } # parse_char_string
643    *parse_string = \&parse_char_string; ## NOTE: Alias for backward compatibility.
644    
645  sub parse_string ($$$;$) {  sub parse_char_stream ($$$;$$) {
646    my $self = ref $_[0] ? shift : shift->new;    my $self = ref $_[0] ? shift : shift->new;
647    my $s = ref $_[0] ? $_[0] : \($_[0]);    my $input = $_[0];
648    $self->{document} = $_[1];    $self->{document} = $_[1];
649    @{$self->{document}->child_nodes} = ();    @{$self->{document}->child_nodes} = ();
650    
651    ## NOTE: |set_inner_html| copies most of this method's code    ## NOTE: |set_inner_html| copies most of this method's code
652    
653      ## Confidence: irrelevant.
654    $self->{confident} = 1 unless exists $self->{confident};    $self->{confident} = 1 unless exists $self->{confident};
655    
656    $self->{document}->input_encoding ($self->{input_encoding})    $self->{document}->input_encoding ($self->{input_encoding})
657        if defined $self->{input_encoding};        if defined $self->{input_encoding};
658    ## TODO: |{input_encoding}| is needless?
659    
   my $i = 0;  
660    $self->{line_prev} = $self->{line} = 1;    $self->{line_prev} = $self->{line} = 1;
661    $self->{column_prev} = $self->{column} = 0;    $self->{column_prev} = -1;
662    $self->{set_next_char} = sub {    $self->{column} = 0;
663      $self->{set_nc} = sub {
664      my $self = shift;      my $self = shift;
665    
666      pop @{$self->{prev_char}};      my $char = '';
667      unshift @{$self->{prev_char}}, $self->{next_char};      if (defined $self->{next_nc}) {
668          $char = $self->{next_nc};
669          delete $self->{next_nc};
670          $self->{nc} = ord $char;
671        } else {
672          $self->{char_buffer} = '';
673          $self->{char_buffer_pos} = 0;
674    
675          my $count = $input->manakai_read_until
676             ($self->{char_buffer}, qr/[^\x00\x0A\x0D]/, $self->{char_buffer_pos});
677          if ($count) {
678            $self->{line_prev} = $self->{line};
679            $self->{column_prev} = $self->{column};
680            $self->{column}++;
681            $self->{nc}
682                = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1);
683            return;
684          }
685    
686      $self->{next_char} = -1 and return if $i >= length $$s;        if ($input->read ($char, 1)) {
687      $self->{next_char} = ord substr $$s, $i++, 1;          $self->{nc} = ord $char;
688          } else {
689            $self->{nc} = -1;
690            return;
691          }
692        }
693    
694      ($self->{line_prev}, $self->{column_prev})      ($self->{line_prev}, $self->{column_prev})
695          = ($self->{line}, $self->{column});          = ($self->{line}, $self->{column});
696      $self->{column}++;      $self->{column}++;
697            
698      if ($self->{next_char} == 0x000A) { # LF      if ($self->{nc} == 0x000A) { # LF
699          !!!cp ('j1');
700        $self->{line}++;        $self->{line}++;
701        $self->{column} = 0;        $self->{column} = 0;
702      } elsif ($self->{next_char} == 0x000D) { # CR      } elsif ($self->{nc} == 0x000D) { # CR
703        $i++ if substr ($$s, $i, 1) eq "\x0A";        !!!cp ('j2');
704        $self->{next_char} = 0x000A; # LF # MUST  ## TODO: support for abort/streaming
705          my $next = '';
706          if ($input->read ($next, 1) and $next ne "\x0A") {
707            $self->{next_nc} = $next;
708          }
709          $self->{nc} = 0x000A; # LF # MUST
710        $self->{line}++;        $self->{line}++;
711        $self->{column} = 0;        $self->{column} = 0;
712      } elsif ($self->{next_char} > 0x10FFFF) {      } elsif ($self->{nc} == 0x0000) { # NULL
713        $self->{next_char} = 0xFFFD; # REPLACEMENT CHARACTER # MUST        !!!cp ('j4');
     } elsif ($self->{next_char} == 0x0000) { # NULL  
714        !!!parse-error (type => 'NULL');        !!!parse-error (type => 'NULL');
715        $self->{next_char} = 0xFFFD; # REPLACEMENT CHARACTER # MUST        $self->{nc} = 0xFFFD; # REPLACEMENT CHARACTER # MUST
716      }      }
717    };    };
718    $self->{prev_char} = [-1, -1, -1];  
719    $self->{next_char} = -1;    $self->{read_until} = sub {
720        #my ($scalar, $specials_range, $offset) = @_;
721        return 0 if defined $self->{next_nc};
722    
723        my $pattern = qr/[^$_[1]\x00\x0A\x0D]/;
724        my $offset = $_[2] || 0;
725    
726        if ($self->{char_buffer_pos} < length $self->{char_buffer}) {
727          pos ($self->{char_buffer}) = $self->{char_buffer_pos};
728          if ($self->{char_buffer} =~ /\G(?>$pattern)+/) {
729            substr ($_[0], $offset)
730                = substr ($self->{char_buffer}, $-[0], $+[0] - $-[0]);
731            my $count = $+[0] - $-[0];
732            if ($count) {
733              $self->{column} += $count;
734              $self->{char_buffer_pos} += $count;
735              $self->{line_prev} = $self->{line};
736              $self->{column_prev} = $self->{column} - 1;
737              $self->{nc} = -1;
738            }
739            return $count;
740          } else {
741            return 0;
742          }
743        } else {
744          my $count = $input->manakai_read_until ($_[0], $pattern, $_[2]);
745          if ($count) {
746            $self->{column} += $count;
747            $self->{line_prev} = $self->{line};
748            $self->{column_prev} = $self->{column} - 1;
749            $self->{nc} = -1;
750          }
751          return $count;
752        }
753      }; # $self->{read_until}
754    
755    my $onerror = $_[2] || sub {    my $onerror = $_[2] || sub {
756      my (%opt) = @_;      my (%opt) = @_;
# Line 221  sub parse_string ($$$;$) { Line 762  sub parse_string ($$$;$) {
762      $onerror->(line => $self->{line}, column => $self->{column}, @_);      $onerror->(line => $self->{line}, column => $self->{column}, @_);
763    };    };
764    
765      my $char_onerror = sub {
766        my (undef, $type, %opt) = @_;
767        !!!parse-error (layer => 'encode',
768                        line => $self->{line}, column => $self->{column} + 1,
769                        %opt, type => $type);
770      }; # $char_onerror
771    
772      if ($_[3]) {
773        $input = $_[3]->($input);
774        $input->onerror ($char_onerror);
775      } else {
776        $input->onerror ($char_onerror) unless defined $input->onerror;
777      }
778    
779    $self->_initialize_tokenizer;    $self->_initialize_tokenizer;
780    $self->_initialize_tree_constructor;    $self->_initialize_tree_constructor;
781    $self->_construct_tree;    $self->_construct_tree;
# Line 229  sub parse_string ($$$;$) { Line 784  sub parse_string ($$$;$) {
784    delete $self->{parse_error}; # remove loop    delete $self->{parse_error}; # remove loop
785    
786    return $self->{document};    return $self->{document};
787  } # parse_string  } # parse_char_stream
788    
789  sub new ($) {  sub new ($) {
790    my $class = shift;    my $class = shift;
791    my $self = bless {}, $class;    my $self = bless {
792    $self->{set_next_char} = sub {      level => {must => 'm',
793      $self->{next_char} = -1;                should => 's',
794                  warn => 'w',
795                  info => 'i',
796                  uncertain => 'u'},
797      }, $class;
798      $self->{set_nc} = sub {
799        $self->{nc} = -1;
800    };    };
801    $self->{parse_error} = sub {    $self->{parse_error} = sub {
802      #      #
# Line 252  sub new ($) { Line 813  sub new ($) {
813    return $self;    return $self;
814  } # new  } # new
815    
816  sub CM_ENTITY () { 0b001 } # & markup in data  ## Insertion modes
 sub CM_LIMITED_MARKUP () { 0b010 } # < markup in data (limited)  
 sub CM_FULL_MARKUP () { 0b100 } # < markup in data (any)  
   
 sub PLAINTEXT_CONTENT_MODEL () { 0 }  
 sub CDATA_CONTENT_MODEL () { CM_LIMITED_MARKUP }  
 sub RCDATA_CONTENT_MODEL () { CM_ENTITY | CM_LIMITED_MARKUP }  
 sub PCDATA_CONTENT_MODEL () { CM_ENTITY | CM_FULL_MARKUP }  
   
 sub DATA_STATE () { 0 }  
 sub ENTITY_DATA_STATE () { 1 }  
 sub TAG_OPEN_STATE () { 2 }  
 sub CLOSE_TAG_OPEN_STATE () { 3 }  
 sub TAG_NAME_STATE () { 4 }  
 sub BEFORE_ATTRIBUTE_NAME_STATE () { 5 }  
 sub ATTRIBUTE_NAME_STATE () { 6 }  
 sub AFTER_ATTRIBUTE_NAME_STATE () { 7 }  
 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 MARKUP_DECLARATION_OPEN_STATE () { 13 }  
 sub COMMENT_START_STATE () { 14 }  
 sub COMMENT_START_DASH_STATE () { 15 }  
 sub COMMENT_STATE () { 16 }  
 sub COMMENT_END_STATE () { 17 }  
 sub COMMENT_END_DASH_STATE () { 18 }  
 sub BOGUS_COMMENT_STATE () { 19 }  
 sub DOCTYPE_STATE () { 20 }  
 sub BEFORE_DOCTYPE_NAME_STATE () { 21 }  
 sub DOCTYPE_NAME_STATE () { 22 }  
 sub AFTER_DOCTYPE_NAME_STATE () { 23 }  
 sub BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE () { 24 }  
 sub DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE () { 25 }  
 sub DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE () { 26 }  
 sub AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE () { 27 }  
 sub BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE () { 28 }  
 sub DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE () { 29 }  
 sub DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE () { 30 }  
 sub AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE () { 31 }  
 sub BOGUS_DOCTYPE_STATE () { 32 }  
 sub AFTER_ATTRIBUTE_VALUE_QUOTED_STATE () { 33 }  
   
 sub DOCTYPE_TOKEN () { 1 }  
 sub COMMENT_TOKEN () { 2 }  
 sub START_TAG_TOKEN () { 3 }  
 sub END_TAG_TOKEN () { 4 }  
 sub END_OF_FILE_TOKEN () { 5 }  
 sub CHARACTER_TOKEN () { 6 }  
817    
818  sub AFTER_HTML_IMS () { 0b100 }  sub AFTER_HTML_IMS () { 0b100 }
819  sub HEAD_IMS ()       { 0b1000 }  sub HEAD_IMS ()       { 0b1000 }
# Line 312  sub ROW_IMS ()        { 0b10000000 } Line 824  sub ROW_IMS ()        { 0b10000000 }
824  sub BODY_AFTER_IMS () { 0b100000000 }  sub BODY_AFTER_IMS () { 0b100000000 }
825  sub FRAME_IMS ()      { 0b1000000000 }  sub FRAME_IMS ()      { 0b1000000000 }
826  sub SELECT_IMS ()     { 0b10000000000 }  sub SELECT_IMS ()     { 0b10000000000 }
827    #sub IN_FOREIGN_CONTENT_IM () { 0b100000000000 } # see Whatpm::HTML::Tokenizer
828        ## NOTE: "in foreign content" insertion mode is special; it is combined
829        ## with the secondary insertion mode.  In this parser, they are stored
830        ## together in the bit-or'ed form.
831    sub IN_CDATA_RCDATA_IM () { 0b1000000000000 }
832        ## NOTE: "in CDATA/RCDATA" insertion mode is also special; it is
833        ## combined with the original insertion mode.  In thie parser,
834        ## they are stored together in the bit-or'ed form.
835    
836    sub IM_MASK () { 0b11111111111 }
837    
838  ## NOTE: "initial" and "before html" insertion modes have no constants.  ## NOTE: "initial" and "before html" insertion modes have no constants.
839    
# Line 338  sub IN_SELECT_IM () { SELECT_IMS | 0b01 Line 860  sub IN_SELECT_IM () { SELECT_IMS | 0b01
860  sub IN_SELECT_IN_TABLE_IM () { SELECT_IMS | 0b10 }  sub IN_SELECT_IN_TABLE_IM () { SELECT_IMS | 0b10 }
861  sub IN_COLUMN_GROUP_IM () { 0b10 }  sub IN_COLUMN_GROUP_IM () { 0b10 }
862    
 ## Implementations MUST act as if state machine in the spec  
   
 sub _initialize_tokenizer ($) {  
   my $self = shift;  
   $self->{state} = DATA_STATE; # MUST  
   $self->{content_model} = PCDATA_CONTENT_MODEL; # be  
   undef $self->{current_token}; # start tag, end tag, comment, or DOCTYPE  
   undef $self->{current_attribute};  
   undef $self->{last_emitted_start_tag_name};  
   undef $self->{last_attribute_value_state};  
   $self->{char} = [];  
   # $self->{next_char}  
   !!!next-input-character;  
   $self->{token} = [];  
   # $self->{escape}  
 } # _initialize_tokenizer  
   
 ## A token has:  
 ##   ->{type} == DOCTYPE_TOKEN, START_TAG_TOKEN, END_TAG_TOKEN, COMMENT_TOKEN,  
 ##       CHARACTER_TOKEN, or END_OF_FILE_TOKEN  
 ##   ->{name} (DOCTYPE_TOKEN)  
 ##   ->{tag_name} (START_TAG_TOKEN, END_TAG_TOKEN)  
 ##   ->{public_identifier} (DOCTYPE_TOKEN)  
 ##   ->{system_identifier} (DOCTYPE_TOKEN)  
 ##   ->{quirks} == 1 or 0 (DOCTYPE_TOKEN): "force-quirks" flag  
 ##   ->{attributes} isa HASH (START_TAG_TOKEN, END_TAG_TOKEN)  
 ##        ->{name}  
 ##        ->{value}  
 ##        ->{has_reference} == 1 or 0  
 ##   ->{data} (COMMENT_TOKEN, CHARACTER_TOKEN)  
   
 ## Emitted token MUST immediately be handled by the tree construction state.  
   
 ## Before each step, UA MAY check to see if either one of the scripts in  
 ## "list of scripts that will execute as soon as possible" or the first  
 ## script in the "list of scripts that will execute asynchronously",  
 ## has completed loading.  If one has, then it MUST be executed  
 ## and removed from the list.  
   
 ## NOTE: HTML5 "Writing HTML documents" section, applied to  
 ## documents and not to user agents and conformance checkers,  
 ## 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;  
   if (@{$self->{token}}) {  
     return shift @{$self->{token}};  
   }  
   
   A: {  
     if ($self->{state} == DATA_STATE) {  
       if ($self->{next_char} == 0x0026) { # &  
         if ($self->{content_model} & CM_ENTITY and # PCDATA | RCDATA  
             not $self->{escape}) {  
           !!!cp (1);  
           $self->{state} = ENTITY_DATA_STATE;  
           !!!next-input-character;  
           redo A;  
         } else {  
           !!!cp (2);  
           #  
         }  
       } elsif ($self->{next_char} == 0x002D) { # -  
         if ($self->{content_model} & CM_LIMITED_MARKUP) { # RCDATA | CDATA  
           unless ($self->{escape}) {  
             if ($self->{prev_char}->[0] == 0x002D and # -  
                 $self->{prev_char}->[1] == 0x0021 and # !  
                 $self->{prev_char}->[2] == 0x003C) { # <  
               !!!cp (3);  
               $self->{escape} = 1;  
             } else {  
               !!!cp (4);  
             }  
           } else {  
             !!!cp (5);  
           }  
         }  
           
         #  
       } elsif ($self->{next_char} == 0x003C) { # <  
         if ($self->{content_model} & CM_FULL_MARKUP or # PCDATA  
             (($self->{content_model} & CM_LIMITED_MARKUP) and # CDATA | RCDATA  
              not $self->{escape})) {  
           !!!cp (6);  
           $self->{state} = TAG_OPEN_STATE;  
           !!!next-input-character;  
           redo A;  
         } else {  
           !!!cp (7);  
           #  
         }  
       } elsif ($self->{next_char} == 0x003E) { # >  
         if ($self->{escape} and  
             ($self->{content_model} & CM_LIMITED_MARKUP)) { # RCDATA | CDATA  
           if ($self->{prev_char}->[0] == 0x002D and # -  
               $self->{prev_char}->[1] == 0x002D) { # -  
             !!!cp (8);  
             delete $self->{escape};  
           } else {  
             !!!cp (9);  
           }  
         } else {  
           !!!cp (10);  
         }  
           
         #  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (11);  
         !!!emit ({type => END_OF_FILE_TOKEN,  
                   line => $self->{line}, column => $self->{column}});  
         last A; ## TODO: ok?  
       } else {  
         !!!cp (12);  
       }  
       # Anything else  
       my $token = {type => CHARACTER_TOKEN,  
                    data => chr $self->{next_char},  
                    line => $self->{line}, column => $self->{column},  
                   };  
       ## 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) { # /  
           !!!cp (15);  
           !!!next-input-character;  
           $self->{state} = CLOSE_TAG_OPEN_STATE;  
           redo A;  
         } else {  
           !!!cp (16);  
           ## reconsume  
           $self->{state} = DATA_STATE;  
   
           !!!emit ({type => CHARACTER_TOKEN, data => '<',  
                     line => $self->{line_prev},  
                     column => $self->{column_prev},  
                    });  
   
           redo A;  
         }  
       } elsif ($self->{content_model} & CM_FULL_MARKUP) { # PCDATA  
         if ($self->{next_char} == 0x0021) { # !  
           !!!cp (17);  
           $self->{state} = MARKUP_DECLARATION_OPEN_STATE;  
           !!!next-input-character;  
           redo A;  
         } elsif ($self->{next_char} == 0x002F) { # /  
           !!!cp (18);  
           $self->{state} = CLOSE_TAG_OPEN_STATE;  
           !!!next-input-character;  
           redo A;  
         } elsif (0x0041 <= $self->{next_char} and  
                  $self->{next_char} <= 0x005A) { # A..Z  
           !!!cp (19);  
           $self->{current_token}  
             = {type => START_TAG_TOKEN,  
                tag_name => chr ($self->{next_char} + 0x0020),  
                line => $self->{line_prev},  
                column => $self->{column_prev}};  
           $self->{state} = TAG_NAME_STATE;  
           !!!next-input-character;  
           redo A;  
         } elsif (0x0061 <= $self->{next_char} and  
                  $self->{next_char} <= 0x007A) { # a..z  
           !!!cp (20);  
           $self->{current_token} = {type => START_TAG_TOKEN,  
                                     tag_name => chr ($self->{next_char}),  
                                     line => $self->{line_prev},  
                                     column => $self->{column_prev}};  
           $self->{state} = TAG_NAME_STATE;  
           !!!next-input-character;  
           redo A;  
         } elsif ($self->{next_char} == 0x003E) { # >  
           !!!cp (21);  
           !!!parse-error (type => 'empty start tag',  
                           line => $self->{line_prev},  
                           column => $self->{column_prev});  
           $self->{state} = DATA_STATE;  
           !!!next-input-character;  
   
           !!!emit ({type => CHARACTER_TOKEN, data => '<>',  
                     line => $self->{line_prev},  
                     column => $self->{column_prev},  
                    });  
   
           redo A;  
         } elsif ($self->{next_char} == 0x003F) { # ?  
           !!!cp (22);  
           !!!parse-error (type => 'pio',  
                           line => $self->{line_prev},  
                           column => $self->{column_prev});  
           $self->{state} = BOGUS_COMMENT_STATE;  
           $self->{current_token} = {type => COMMENT_TOKEN, data => '',  
                                     line => $self->{line_prev},  
                                     column => $self->{column_prev},  
                                    };  
           ## $self->{next_char} is intentionally left as is  
           redo A;  
         } else {  
           !!!cp (23);  
           !!!parse-error (type => 'bare stago');  
           $self->{state} = DATA_STATE;  
           ## reconsume  
   
           !!!emit ({type => CHARACTER_TOKEN, data => '<',  
                     line => $self->{line_prev},  
                     column => $self->{column_prev},  
                    });  
   
           redo A;  
         }  
       } else {  
         die "$0: $self->{content_model} in tag open";  
       }  
     } elsif ($self->{state} == CLOSE_TAG_OPEN_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}) {  
   
           ## NOTE: <http://krijnhoetmer.nl/irc-logs/whatwg/20070626#l-564>  
           my @next_char;  
           TAGNAME: for (my $i = 0; $i < length $self->{last_emitted_start_tag_name}; $i++) {  
             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  
           !!!cp (28);  
           # next-input-character is already done  
           $self->{state} = DATA_STATE;  
           !!!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);  
         $self->{current_token}  
             = {type => END_TAG_TOKEN,  
                tag_name => chr ($self->{next_char} + 0x0020),  
                line => $l, column => $c};  
         $self->{state} = TAG_NAME_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif (0x0061 <= $self->{next_char} and  
                $self->{next_char} <= 0x007A) { # a..z  
         !!!cp (30);  
         $self->{current_token} = {type => END_TAG_TOKEN,  
                                   tag_name => chr ($self->{next_char}),  
                                   line => $l, column => $c};  
         $self->{state} = TAG_NAME_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         !!!cp (31);  
         !!!parse-error (type => 'empty end tag',  
                         line => $self->{line_prev}, ## "<" in "</>"  
                         column => $self->{column_prev} - 1);  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (32);  
         !!!parse-error (type => 'bare etago');  
         $self->{state} = DATA_STATE;  
         # reconsume  
   
         !!!emit ({type => CHARACTER_TOKEN, data => '</',  
                   line => $l, column => $c,  
                  });  
   
         redo A;  
       } else {  
         !!!cp (33);  
         !!!parse-error (type => 'bogus end tag');  
         $self->{state} = BOGUS_COMMENT_STATE;  
         $self->{current_token} = {type => COMMENT_TOKEN, data => '',  
                                   line => $self->{line_prev}, # "<" of "</"  
                                   column => $self->{column_prev} - 1,  
                                  };  
         ## $self->{next_char} is intentionally left as is  
         redo A;  
       }  
     } elsif ($self->{state} == TAG_NAME_STATE) {  
       if ($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) { # SP  
         !!!cp (34);  
         $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (35);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           #if ($self->{current_token}->{attributes}) {  
           #  ## NOTE: This should never be reached.  
           #  !!! cp (36);  
           #  !!! parse-error (type => 'end tag attribute');  
           #} else {  
             !!!cp (37);  
           #}  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } elsif (0x0041 <= $self->{next_char} and  
                $self->{next_char} <= 0x005A) { # A..Z  
         !!!cp (38);  
         $self->{current_token}->{tag_name} .= chr ($self->{next_char} + 0x0020);  
           # start tag or end tag  
         ## Stay in this state  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!parse-error (type => 'unclosed tag');  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (39);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           #if ($self->{current_token}->{attributes}) {  
           #  ## NOTE: This state should never be reached.  
           #  !!! cp (40);  
           #  !!! parse-error (type => 'end tag attribute');  
           #} else {  
             !!!cp (41);  
           #}  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         # reconsume  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } elsif ($self->{next_char} == 0x002F) { # /  
         !!!next-input-character;  
         if ($self->{next_char} == 0x003E and # >  
             $self->{current_token}->{type} == START_TAG_TOKEN and  
             $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {  
           # permitted slash  
           !!!cp (42);  
           #  
         } else {  
           !!!cp (43);  
           !!!parse-error (type => 'nestc');  
         }  
         $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;  
         # next-input-character is already done  
         redo A;  
       } else {  
         !!!cp (44);  
         $self->{current_token}->{tag_name} .= chr $self->{next_char};  
           # start tag or end tag  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == BEFORE_ATTRIBUTE_NAME_STATE) {  
       if ($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) { # SP  
         !!!cp (45);  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (46);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           if ($self->{current_token}->{attributes}) {  
             !!!cp (47);  
             !!!parse-error (type => 'end tag attribute');  
           } else {  
             !!!cp (48);  
           }  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } elsif (0x0041 <= $self->{next_char} and  
                $self->{next_char} <= 0x005A) { # A..Z  
         !!!cp (49);  
         $self->{current_attribute}  
             = {name => chr ($self->{next_char} + 0x0020),  
                value => '',  
                line => $self->{line}, column => $self->{column}};  
         $self->{state} = ATTRIBUTE_NAME_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x002F) { # /  
         !!!next-input-character;  
         if ($self->{next_char} == 0x003E and # >  
             $self->{current_token}->{type} == START_TAG_TOKEN and  
             $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {  
           # permitted slash  
           !!!cp (50);  
           #  
         } else {  
           !!!cp (51);  
           !!!parse-error (type => 'nestc');  
         }  
         ## Stay in the state  
         # next-input-character is already done  
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!parse-error (type => 'unclosed tag');  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (52);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           if ($self->{current_token}->{attributes}) {  
             !!!cp (53);  
             !!!parse-error (type => 'end tag attribute');  
           } else {  
             !!!cp (54);  
           }  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         # reconsume  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } else {  
         if ({  
              0x0022 => 1, # "  
              0x0027 => 1, # '  
              0x003D => 1, # =  
             }->{$self->{next_char}}) {  
           !!!cp (55);  
           !!!parse-error (type => 'bad attribute name');  
         } else {  
           !!!cp (56);  
         }  
         $self->{current_attribute}  
             = {name => chr ($self->{next_char}),  
                value => '',  
                line => $self->{line}, column => $self->{column}};  
         $self->{state} = ATTRIBUTE_NAME_STATE;  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == ATTRIBUTE_NAME_STATE) {  
       my $before_leave = sub {  
         if (exists $self->{current_token}->{attributes} # start tag or end tag  
             ->{$self->{current_attribute}->{name}}) { # MUST  
           !!!cp (57);  
           !!!parse-error (type => 'duplicate attribute:'.$self->{current_attribute}->{name}, line => $self->{current_attribute}->{line}, column => $self->{current_attribute}->{column});  
           ## Discard $self->{current_attribute} # MUST  
         } else {  
           !!!cp (58);  
           $self->{current_token}->{attributes}->{$self->{current_attribute}->{name}}  
             = $self->{current_attribute};  
         }  
       }; # $before_leave  
   
       if ($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) { # SP  
         !!!cp (59);  
         $before_leave->();  
         $self->{state} = AFTER_ATTRIBUTE_NAME_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003D) { # =  
         !!!cp (60);  
         $before_leave->();  
         $self->{state} = BEFORE_ATTRIBUTE_VALUE_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         $before_leave->();  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (61);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           !!!cp (62);  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           if ($self->{current_token}->{attributes}) {  
             !!!parse-error (type => 'end tag attribute');  
           }  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } elsif (0x0041 <= $self->{next_char} and  
                $self->{next_char} <= 0x005A) { # A..Z  
         !!!cp (63);  
         $self->{current_attribute}->{name} .= chr ($self->{next_char} + 0x0020);  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x002F) { # /  
         $before_leave->();  
         !!!next-input-character;  
         if ($self->{next_char} == 0x003E and # >  
             $self->{current_token}->{type} == START_TAG_TOKEN and  
             $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {  
           # permitted slash  
           !!!cp (64);  
           #  
         } else {  
           !!!cp (65);  
           !!!parse-error (type => 'nestc');  
         }  
         $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;  
         # next-input-character is already done  
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!parse-error (type => 'unclosed tag');  
         $before_leave->();  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (66);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           if ($self->{current_token}->{attributes}) {  
             !!!cp (67);  
             !!!parse-error (type => 'end tag attribute');  
           } else {  
             ## NOTE: This state should never be reached.  
             !!!cp (68);  
           }  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         # reconsume  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } else {  
         if ($self->{next_char} == 0x0022 or # "  
             $self->{next_char} == 0x0027) { # '  
           !!!cp (69);  
           !!!parse-error (type => 'bad attribute name');  
         } else {  
           !!!cp (70);  
         }  
         $self->{current_attribute}->{name} .= chr ($self->{next_char});  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == AFTER_ATTRIBUTE_NAME_STATE) {  
       if ($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) { # SP  
         !!!cp (71);  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003D) { # =  
         !!!cp (72);  
         $self->{state} = BEFORE_ATTRIBUTE_VALUE_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (73);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           if ($self->{current_token}->{attributes}) {  
             !!!cp (74);  
             !!!parse-error (type => 'end tag attribute');  
           } else {  
             ## NOTE: This state should never be reached.  
             !!!cp (75);  
           }  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } elsif (0x0041 <= $self->{next_char} and  
                $self->{next_char} <= 0x005A) { # A..Z  
         !!!cp (76);  
         $self->{current_attribute}  
             = {name => chr ($self->{next_char} + 0x0020),  
                value => '',  
                line => $self->{line}, column => $self->{column}};  
         $self->{state} = ATTRIBUTE_NAME_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x002F) { # /  
         !!!next-input-character;  
         if ($self->{next_char} == 0x003E and # >  
             $self->{current_token}->{type} == START_TAG_TOKEN and  
             $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {  
           # permitted slash  
           !!!cp (77);  
           #  
         } else {  
           !!!cp (78);  
           !!!parse-error (type => 'nestc');  
           ## TODO: Different error type for <aa / bb> than <aa/>  
         }  
         $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;  
         # next-input-character is already done  
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!parse-error (type => 'unclosed tag');  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (79);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           if ($self->{current_token}->{attributes}) {  
             !!!cp (80);  
             !!!parse-error (type => 'end tag attribute');  
           } else {  
             ## NOTE: This state should never be reached.  
             !!!cp (81);  
           }  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         # reconsume  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } else {  
         !!!cp (82);  
         $self->{current_attribute}  
             = {name => chr ($self->{next_char}),  
                value => '',  
                line => $self->{line}, column => $self->{column}};  
         $self->{state} = ATTRIBUTE_NAME_STATE;  
         !!!next-input-character;  
         redo A;          
       }  
     } elsif ($self->{state} == BEFORE_ATTRIBUTE_VALUE_STATE) {  
       if ($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) { # SP        
         !!!cp (83);  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x0022) { # "  
         !!!cp (84);  
         $self->{state} = ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x0026) { # &  
         !!!cp (85);  
         $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;  
         ## reconsume  
         redo A;  
       } elsif ($self->{next_char} == 0x0027) { # '  
         !!!cp (86);  
         $self->{state} = ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (87);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           if ($self->{current_token}->{attributes}) {  
             !!!cp (88);  
             !!!parse-error (type => 'end tag attribute');  
           } else {  
             ## NOTE: This state should never be reached.  
             !!!cp (89);  
           }  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!parse-error (type => 'unclosed tag');  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (90);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           if ($self->{current_token}->{attributes}) {  
             !!!cp (91);  
             !!!parse-error (type => 'end tag attribute');  
           } else {  
             ## NOTE: This state should never be reached.  
             !!!cp (92);  
           }  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } else {  
         if ($self->{next_char} == 0x003D) { # =  
           !!!cp (93);  
           !!!parse-error (type => 'bad attribute value');  
         } else {  
           !!!cp (94);  
         }  
         $self->{current_attribute}->{value} .= chr ($self->{next_char});  
         $self->{state} = ATTRIBUTE_VALUE_UNQUOTED_STATE;  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == ATTRIBUTE_VALUE_DOUBLE_QUOTED_STATE) {  
       if ($self->{next_char} == 0x0022) { # "  
         !!!cp (95);  
         $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x0026) { # &  
         !!!cp (96);  
         $self->{last_attribute_value_state} = $self->{state};  
         $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!parse-error (type => 'unclosed attribute value');  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (97);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           if ($self->{current_token}->{attributes}) {  
             !!!cp (98);  
             !!!parse-error (type => 'end tag attribute');  
           } else {  
             ## NOTE: This state should never be reached.  
             !!!cp (99);  
           }  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } else {  
         !!!cp (100);  
         $self->{current_attribute}->{value} .= chr ($self->{next_char});  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == ATTRIBUTE_VALUE_SINGLE_QUOTED_STATE) {  
       if ($self->{next_char} == 0x0027) { # '  
         !!!cp (101);  
         $self->{state} = AFTER_ATTRIBUTE_VALUE_QUOTED_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x0026) { # &  
         !!!cp (102);  
         $self->{last_attribute_value_state} = $self->{state};  
         $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!parse-error (type => 'unclosed attribute value');  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (103);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           if ($self->{current_token}->{attributes}) {  
             !!!cp (104);  
             !!!parse-error (type => 'end tag attribute');  
           } else {  
             ## NOTE: This state should never be reached.  
             !!!cp (105);  
           }  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } else {  
         !!!cp (106);  
         $self->{current_attribute}->{value} .= chr ($self->{next_char});  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == ATTRIBUTE_VALUE_UNQUOTED_STATE) {  
       if ($self->{next_char} == 0x0009 or # HT  
           $self->{next_char} == 0x000A or # LF  
           $self->{next_char} == 0x000B or # HT  
           $self->{next_char} == 0x000C or # FF  
           $self->{next_char} == 0x0020) { # SP  
         !!!cp (107);  
         $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x0026) { # &  
         !!!cp (108);  
         $self->{last_attribute_value_state} = $self->{state};  
         $self->{state} = ENTITY_IN_ATTRIBUTE_VALUE_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (109);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           if ($self->{current_token}->{attributes}) {  
             !!!cp (110);  
             !!!parse-error (type => 'end tag attribute');  
           } else {  
             ## NOTE: This state should never be reached.  
             !!!cp (111);  
           }  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!parse-error (type => 'unclosed tag');  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (112);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           if ($self->{current_token}->{attributes}) {  
             !!!cp (113);  
             !!!parse-error (type => 'end tag attribute');  
           } else {  
             ## NOTE: This state should never be reached.  
             !!!cp (114);  
           }  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } else {  
         if ({  
              0x0022 => 1, # "  
              0x0027 => 1, # '  
              0x003D => 1, # =  
             }->{$self->{next_char}}) {  
           !!!cp (115);  
           !!!parse-error (type => 'bad attribute value');  
         } else {  
           !!!cp (116);  
         }  
         $self->{current_attribute}->{value} .= chr ($self->{next_char});  
         ## Stay in the state  
         !!!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  
           $self->{next_char} == 0x000B or # VT  
           $self->{next_char} == 0x000C or # FF  
           $self->{next_char} == 0x0020) { # SP  
         !!!cp (118);  
         $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         if ($self->{current_token}->{type} == START_TAG_TOKEN) {  
           !!!cp (119);  
           $self->{last_emitted_start_tag_name} = $self->{current_token}->{tag_name};  
         } elsif ($self->{current_token}->{type} == END_TAG_TOKEN) {  
           $self->{content_model} = PCDATA_CONTENT_MODEL; # MUST  
           if ($self->{current_token}->{attributes}) {  
             !!!cp (120);  
             !!!parse-error (type => 'end tag attribute');  
           } else {  
             ## NOTE: This state should never be reached.  
             !!!cp (121);  
           }  
         } else {  
           die "$0: $self->{current_token}->{type}: Unknown token type";  
         }  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # start tag or end tag  
   
         redo A;  
       } elsif ($self->{next_char} == 0x002F) { # /  
         !!!next-input-character;  
         if ($self->{next_char} == 0x003E and # >  
             $self->{current_token}->{type} == START_TAG_TOKEN and  
             $permitted_slash_tag_name->{$self->{current_token}->{tag_name}}) {  
           # permitted slash  
           !!!cp (122);  
           #  
         } else {  
           !!!cp (123);  
           !!!parse-error (type => 'nestc');  
         }  
         $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;  
         # next-input-character is already done  
         redo A;  
       } else {  
         !!!cp (124);  
         !!!parse-error (type => 'no space between attributes');  
         $self->{state} = BEFORE_ATTRIBUTE_NAME_STATE;  
         ## reconsume  
         redo A;  
       }  
     } elsif ($self->{state} == BOGUS_COMMENT_STATE) {  
       ## (only happen if PCDATA state)  
         
       ## NOTE: Set by the previous state  
       #my $token = {type => COMMENT_TOKEN, data => ''};  
   
       BC: {  
         if ($self->{next_char} == 0x003E) { # >  
           !!!cp (124);  
           $self->{state} = DATA_STATE;  
           !!!next-input-character;  
   
           !!!emit ($self->{current_token}); # comment  
   
           redo A;  
         } elsif ($self->{next_char} == -1) {  
           !!!cp (125);  
           $self->{state} = DATA_STATE;  
           ## reconsume  
   
           !!!emit ($self->{current_token}); # comment  
   
           redo A;  
         } else {  
           !!!cp (126);  
           $self->{current_token}->{data} .= chr ($self->{next_char}); # comment  
           !!!next-input-character;  
           redo BC;  
         }  
       } # BC  
   
       die "$0: _get_next_token: unexpected case [BC]";  
     } 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) { # -  
         !!!next-input-character;  
         push @next_char, $self->{next_char};  
         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  
         !!!next-input-character;  
         push @next_char, $self->{next_char};  
         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);  
         }  
       } else {  
         !!!cp (136);  
       }  
   
       !!!parse-error (type => 'bogus comment');  
       $self->{next_char} = shift @next_char;  
       !!!back-next-input-character (@next_char);  
       $self->{state} = BOGUS_COMMENT_STATE;  
       $self->{current_token} = {type => COMMENT_TOKEN, data => '',  
                                 line => $l, column => $c,  
                                };  
       redo A;  
         
       ## ISSUE: typos in spec: chacacters, is is a parse error  
       ## 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?  
     } elsif ($self->{state} == COMMENT_START_STATE) {  
       if ($self->{next_char} == 0x002D) { # -  
         !!!cp (137);  
         $self->{state} = COMMENT_START_DASH_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         !!!cp (138);  
         !!!parse-error (type => 'bogus comment');  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # comment  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (139);  
         !!!parse-error (type => 'unclosed comment');  
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         !!!emit ($self->{current_token}); # comment  
   
         redo A;  
       } else {  
         !!!cp (140);  
         $self->{current_token}->{data} # comment  
             .= chr ($self->{next_char});  
         $self->{state} = COMMENT_STATE;  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == COMMENT_START_DASH_STATE) {  
       if ($self->{next_char} == 0x002D) { # -  
         !!!cp (141);  
         $self->{state} = COMMENT_END_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         !!!cp (142);  
         !!!parse-error (type => 'bogus comment');  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # comment  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (143);  
         !!!parse-error (type => 'unclosed comment');  
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         !!!emit ($self->{current_token}); # comment  
   
         redo A;  
       } else {  
         !!!cp (144);  
         $self->{current_token}->{data} # comment  
             .= '-' . chr ($self->{next_char});  
         $self->{state} = COMMENT_STATE;  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == COMMENT_STATE) {  
       if ($self->{next_char} == 0x002D) { # -  
         !!!cp (145);  
         $self->{state} = COMMENT_END_DASH_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (146);  
         !!!parse-error (type => 'unclosed comment');  
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         !!!emit ($self->{current_token}); # comment  
   
         redo A;  
       } else {  
         !!!cp (147);  
         $self->{current_token}->{data} .= chr ($self->{next_char}); # comment  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == COMMENT_END_DASH_STATE) {  
       if ($self->{next_char} == 0x002D) { # -  
         !!!cp (148);  
         $self->{state} = COMMENT_END_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (149);  
         !!!parse-error (type => 'unclosed comment');  
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         !!!emit ($self->{current_token}); # comment  
   
         redo A;  
       } else {  
         !!!cp (150);  
         $self->{current_token}->{data} .= '-' . chr ($self->{next_char}); # comment  
         $self->{state} = COMMENT_STATE;  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == COMMENT_END_STATE) {  
       if ($self->{next_char} == 0x003E) { # >  
         !!!cp (151);  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # comment  
   
         redo A;  
       } elsif ($self->{next_char} == 0x002D) { # -  
         !!!cp (152);  
         !!!parse-error (type => 'dash in comment',  
                         line => $self->{line_prev},  
                         column => $self->{column_prev});  
         $self->{current_token}->{data} .= '-'; # comment  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (153);  
         !!!parse-error (type => 'unclosed comment');  
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         !!!emit ($self->{current_token}); # comment  
   
         redo A;  
       } else {  
         !!!cp (154);  
         !!!parse-error (type => 'dash in comment',  
                         line => $self->{line_prev},  
                         column => $self->{column_prev});  
         $self->{current_token}->{data} .= '--' . chr ($self->{next_char}); # comment  
         $self->{state} = COMMENT_STATE;  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == DOCTYPE_STATE) {  
       if ($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) { # SP  
         !!!cp (155);  
         $self->{state} = BEFORE_DOCTYPE_NAME_STATE;  
         !!!next-input-character;  
         redo A;  
       } else {  
         !!!cp (156);  
         !!!parse-error (type => 'no space before DOCTYPE name');  
         $self->{state} = BEFORE_DOCTYPE_NAME_STATE;  
         ## reconsume  
         redo A;  
       }  
     } elsif ($self->{state} == BEFORE_DOCTYPE_NAME_STATE) {  
       if ($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) { # SP  
         !!!cp (157);  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         !!!cp (158);  
         !!!parse-error (type => 'no DOCTYPE name');  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # DOCTYPE (quirks)  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (159);  
         !!!parse-error (type => 'no DOCTYPE name');  
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         !!!emit ($self->{current_token}); # DOCTYPE (quirks)  
   
         redo A;  
       } else {  
         !!!cp (160);  
         $self->{current_token}->{name} = chr $self->{next_char};  
         delete $self->{current_token}->{quirks};  
 ## ISSUE: "Set the token's name name to the" in the spec  
         $self->{state} = DOCTYPE_NAME_STATE;  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == DOCTYPE_NAME_STATE) {  
 ## ISSUE: Redundant "First," in the spec.  
       if ($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) { # SP  
         !!!cp (161);  
         $self->{state} = AFTER_DOCTYPE_NAME_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         !!!cp (162);  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (163);  
         !!!parse-error (type => 'unclosed DOCTYPE');  
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } else {  
         !!!cp (164);  
         $self->{current_token}->{name}  
           .= chr ($self->{next_char}); # DOCTYPE  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == AFTER_DOCTYPE_NAME_STATE) {  
       if ($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) { # SP  
         !!!cp (165);  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         !!!cp (166);  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (167);  
         !!!parse-error (type => 'unclosed DOCTYPE');  
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } elsif ($self->{next_char} == 0x0050 or # P  
                $self->{next_char} == 0x0070) { # p  
         !!!next-input-character;  
         if ($self->{next_char} == 0x0055 or # U  
             $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  
         !!!next-input-character;  
         if ($self->{next_char} == 0x0059 or # Y  
             $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);  
         !!!next-input-character;  
         #  
       }  
   
       !!!parse-error (type => 'string after DOCTYPE name');  
       $self->{current_token}->{quirks} = 1;  
   
       $self->{state} = BOGUS_DOCTYPE_STATE;  
       # next-input-character is already done  
       redo A;  
     } elsif ($self->{state} == BEFORE_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {  
       if ({  
             0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,  
             #0x000D => 1, # HT, LF, VT, FF, SP, CR  
           }->{$self->{next_char}}) {  
         !!!cp (181);  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} eq 0x0022) { # "  
         !!!cp (182);  
         $self->{current_token}->{public_identifier} = ''; # DOCTYPE  
         $self->{state} = DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} eq 0x0027) { # '  
         !!!cp (183);  
         $self->{current_token}->{public_identifier} = ''; # DOCTYPE  
         $self->{state} = DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} eq 0x003E) { # >  
         !!!cp (184);  
         !!!parse-error (type => 'no PUBLIC literal');  
   
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (185);  
         !!!parse-error (type => 'unclosed DOCTYPE');  
   
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } else {  
         !!!cp (186);  
         !!!parse-error (type => 'string after PUBLIC');  
         $self->{current_token}->{quirks} = 1;  
   
         $self->{state} = BOGUS_DOCTYPE_STATE;  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED_STATE) {  
       if ($self->{next_char} == 0x0022) { # "  
         !!!cp (187);  
         $self->{state} = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         !!!cp (188);  
         !!!parse-error (type => 'unclosed PUBLIC literal');  
   
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (189);  
         !!!parse-error (type => 'unclosed PUBLIC literal');  
   
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } else {  
         !!!cp (190);  
         $self->{current_token}->{public_identifier} # DOCTYPE  
             .= chr $self->{next_char};  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED_STATE) {  
       if ($self->{next_char} == 0x0027) { # '  
         !!!cp (191);  
         $self->{state} = AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         !!!cp (192);  
         !!!parse-error (type => 'unclosed PUBLIC literal');  
   
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (193);  
         !!!parse-error (type => 'unclosed PUBLIC literal');  
   
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } else {  
         !!!cp (194);  
         $self->{current_token}->{public_identifier} # DOCTYPE  
             .= chr $self->{next_char};  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == AFTER_DOCTYPE_PUBLIC_IDENTIFIER_STATE) {  
       if ({  
             0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,  
             #0x000D => 1, # HT, LF, VT, FF, SP, CR  
           }->{$self->{next_char}}) {  
         !!!cp (195);  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x0022) { # "  
         !!!cp (196);  
         $self->{current_token}->{system_identifier} = ''; # DOCTYPE  
         $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x0027) { # '  
         !!!cp (197);  
         $self->{current_token}->{system_identifier} = ''; # DOCTYPE  
         $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         !!!cp (198);  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (199);  
         !!!parse-error (type => 'unclosed DOCTYPE');  
   
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } else {  
         !!!cp (200);  
         !!!parse-error (type => 'string after PUBLIC literal');  
         $self->{current_token}->{quirks} = 1;  
   
         $self->{state} = BOGUS_DOCTYPE_STATE;  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == BEFORE_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {  
       if ({  
             0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,  
             #0x000D => 1, # HT, LF, VT, FF, SP, CR  
           }->{$self->{next_char}}) {  
         !!!cp (201);  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x0022) { # "  
         !!!cp (202);  
         $self->{current_token}->{system_identifier} = ''; # DOCTYPE  
         $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x0027) { # '  
         !!!cp (203);  
         $self->{current_token}->{system_identifier} = ''; # DOCTYPE  
         $self->{state} = DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         !!!cp (204);  
         !!!parse-error (type => 'no SYSTEM literal');  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (205);  
         !!!parse-error (type => 'unclosed DOCTYPE');  
   
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } else {  
         !!!cp (206);  
         !!!parse-error (type => 'string after SYSTEM');  
         $self->{current_token}->{quirks} = 1;  
   
         $self->{state} = BOGUS_DOCTYPE_STATE;  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED_STATE) {  
       if ($self->{next_char} == 0x0022) { # "  
         !!!cp (207);  
         $self->{state} = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         !!!cp (208);  
         !!!parse-error (type => 'unclosed PUBLIC literal');  
   
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (209);  
         !!!parse-error (type => 'unclosed SYSTEM literal');  
   
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } else {  
         !!!cp (210);  
         $self->{current_token}->{system_identifier} # DOCTYPE  
             .= chr $self->{next_char};  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED_STATE) {  
       if ($self->{next_char} == 0x0027) { # '  
         !!!cp (211);  
         $self->{state} = AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE;  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         !!!cp (212);  
         !!!parse-error (type => 'unclosed PUBLIC literal');  
   
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (213);  
         !!!parse-error (type => 'unclosed SYSTEM literal');  
   
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } else {  
         !!!cp (214);  
         $self->{current_token}->{system_identifier} # DOCTYPE  
             .= chr $self->{next_char};  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == AFTER_DOCTYPE_SYSTEM_IDENTIFIER_STATE) {  
       if ({  
             0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, 0x0020 => 1,  
             #0x000D => 1, # HT, LF, VT, FF, SP, CR  
           }->{$self->{next_char}}) {  
         !!!cp (215);  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       } elsif ($self->{next_char} == 0x003E) { # >  
         !!!cp (216);  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (217);  
         !!!parse-error (type => 'unclosed DOCTYPE');  
   
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         $self->{current_token}->{quirks} = 1;  
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } else {  
         !!!cp (218);  
         !!!parse-error (type => 'string after SYSTEM literal');  
         #$self->{current_token}->{quirks} = 1;  
   
         $self->{state} = BOGUS_DOCTYPE_STATE;  
         !!!next-input-character;  
         redo A;  
       }  
     } elsif ($self->{state} == BOGUS_DOCTYPE_STATE) {  
       if ($self->{next_char} == 0x003E) { # >  
         !!!cp (219);  
         $self->{state} = DATA_STATE;  
         !!!next-input-character;  
   
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } elsif ($self->{next_char} == -1) {  
         !!!cp (220);  
         !!!parse-error (type => 'unclosed DOCTYPE');  
         $self->{state} = DATA_STATE;  
         ## reconsume  
   
         !!!emit ($self->{current_token}); # DOCTYPE  
   
         redo A;  
       } else {  
         !!!cp (221);  
         ## Stay in the state  
         !!!next-input-character;  
         redo A;  
       }  
     } else {  
       die "$0: $self->{state}: Unknown state";  
     }  
   } # A    
   
   die "$0: _get_next_token: unexpected case";  
 } # _get_next_token  
   
 sub _tokenize_attempt_to_consume_an_entity ($$$) {  
   my ($self, $in_attr, $additional) = @_;  
   
   my ($l, $c) = ($self->{line_prev}, $self->{column_prev});  
   
   if ({  
        0x0009 => 1, 0x000A => 1, 0x000B => 1, 0x000C => 1, # HT, LF, VT, FF,  
        0x0020 => 1, 0x003C => 1, 0x0026 => 1, -1 => 1, # SP, <, & # 0x000D # CR  
        $additional => 1,  
       }->{$self->{next_char}}) {  
     !!!cp (1001);  
     ## Don't consume  
     ## No error  
     return undef;  
   } elsif ($self->{next_char} == 0x0023) { # #  
     !!!next-input-character;  
     if ($self->{next_char} == 0x0078 or # x  
         $self->{next_char} == 0x0058) { # X  
       my $code;  
       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);  
           !!!parse-error (type => 'no refc', line => $l, column => $c);  
         }  
   
         if ($code == 0 or (0xD800 <= $code and $code <= 0xDFFF)) {  
           !!!cp (1008);  
           !!!parse-error (type => (sprintf 'invalid character reference:U+%04X', $code), line => $l, column => $c);  
           $code = 0xFFFD;  
         } elsif ($code > 0x10FFFF) {  
           !!!cp (1009);  
           !!!parse-error (type => (sprintf 'invalid character reference: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 => (sprintf 'C1 character reference: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;  
         $code += $self->{next_char} - 0x0030;  
           
         !!!next-input-character;  
       }  
   
       if ($self->{next_char} == 0x003B) { # ;  
         !!!cp (1013);  
         !!!next-input-character;  
       } else {  
         !!!cp (1014);  
         !!!parse-error (type => 'no refc', line => $l, column => $c);  
       }  
   
       if ($code == 0 or (0xD800 <= $code and $code <= 0xDFFF)) {  
         !!!cp (1015);  
         !!!parse-error (type => (sprintf 'invalid character reference:U+%04X', $code), line => $l, column => $c);  
         $code = 0xFFFD;  
       } elsif ($code > 0x10FFFF) {  
         !!!cp (1016);  
         !!!parse-error (type => (sprintf 'invalid character reference:U-%08X', $code), line => $l, column => $c);  
         $code = 0xFFFD;  
       } elsif ($code == 0x000D) {  
         !!!cp (1017);  
         !!!parse-error (type => 'CR character reference', line => $l, column => $c);  
         $code = 0x000A;  
       } elsif (0x80 <= $code and $code <= 0x9F) {  
         !!!cp (1018);  
         !!!parse-error (type => (sprintf 'C1 character reference: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,  
              };  
     } else {  
       !!!cp (1019);  
       !!!parse-error (type => 'bare nero', line => $l, column => $c);  
       !!!back-next-input-character ($self->{next_char});  
       $self->{next_char} = 0x0023; # #  
       return undef;  
     }  
   } elsif ((0x0041 <= $self->{next_char} and  
             $self->{next_char} <= 0x005A) or  
            (0x0061 <= $self->{next_char} and  
             $self->{next_char} <= 0x007A)) {  
     my $entity_name = chr $self->{next_char};  
     !!!next-input-character;  
   
     my $value = $entity_name;  
     my $match = 0;  
     require Whatpm::_NamedEntityList;  
     our $EntityChar;  
   
     while (length $entity_name < 10 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)) { # ;  
       $entity_name .= chr $self->{next_char};  
       if (defined $EntityChar->{$entity_name}) {  
         if ($self->{next_char} == 0x003B) { # ;  
           !!!cp (1020);  
           $value = $EntityChar->{$entity_name};  
           $match = 1;  
           !!!next-input-character;  
           last;  
         } else {  
           !!!cp (1021);  
           $value = $EntityChar->{$entity_name};  
           $match = -1;  
           !!!next-input-character;  
         }  
       } else {  
         !!!cp (1022);  
         $value .= chr $self->{next_char};  
         $match *= 2;  
         !!!next-input-character;  
       }  
     }  
       
     if ($match > 0) {  
       !!!cp (1023);  
       return {type => CHARACTER_TOKEN, data => $value, has_reference => 1,  
               line => $l, column => $c,  
              };  
     } elsif ($match < 0) {  
       !!!parse-error (type => 'no refc', line => $l, column => $c);  
       if ($in_attr and $match < -1) {  
         !!!cp (1024);  
         return {type => CHARACTER_TOKEN, data => '&'.$entity_name,  
                 line => $l, column => $c,  
                };  
       } else {  
         !!!cp (1025);  
         return {type => CHARACTER_TOKEN, data => $value, has_reference => 1,  
                 line => $l, column => $c,  
                };  
       }  
     } else {  
       !!!cp (1026);  
       !!!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 {  
     !!!cp (1027);  
     ## no characters are consumed  
     !!!parse-error (type => 'bare ero', line => $l, column => $c);  
     return undef;  
   }  
 } # _tokenize_attempt_to_consume_an_entity  
   
863  sub _initialize_tree_constructor ($) {  sub _initialize_tree_constructor ($) {
864    my $self = shift;    my $self = shift;
865    ## NOTE: $self->{document} MUST be specified before this method is called    ## NOTE: $self->{document} MUST be specified before this method is called
# Line 2462  sub _initialize_tree_constructor ($) { Line 867  sub _initialize_tree_constructor ($) {
867    ## TODO: Turn mutation events off # MUST    ## TODO: Turn mutation events off # MUST
868    ## TODO: Turn loose Document option (manakai extension) on    ## TODO: Turn loose Document option (manakai extension) on
869    $self->{document}->manakai_is_html (1); # MUST    $self->{document}->manakai_is_html (1); # MUST
870      $self->{document}->set_user_data (manakai_source_line => 1);
871      $self->{document}->set_user_data (manakai_source_column => 1);
872    
873      $self->{frameset_ok} = 1;
874  } # _initialize_tree_constructor  } # _initialize_tree_constructor
875    
876  sub _terminate_tree_constructor ($) {  sub _terminate_tree_constructor ($) {
# Line 2481  sub _construct_tree ($) { Line 890  sub _construct_tree ($) {
890    ## When an interactive UA render the $self->{document} available    ## When an interactive UA render the $self->{document} available
891    ## to the user, or when it begin accepting user input, are    ## to the user, or when it begin accepting user input, are
892    ## not defined.    ## not defined.
   
   ## Append a character: collect it and all subsequent consecutive  
   ## characters and insert one Text node whose data is concatenation  
   ## of all those characters. # MUST  
893        
894    !!!next-token;    !!!next-token;
895    
896    undef $self->{form_element};    undef $self->{form_element};
897    undef $self->{head_element};    undef $self->{head_element};
898      undef $self->{head_element_inserted};
899    $self->{open_elements} = [];    $self->{open_elements} = [];
900    undef $self->{inner_html_node};    undef $self->{inner_html_node};
901      undef $self->{ignore_newline};
902    
903    ## NOTE: The "initial" insertion mode.    ## NOTE: The "initial" insertion mode.
904    $self->_tree_construction_initial; # MUST    $self->_tree_construction_initial; # MUST
# Line 2511  sub _tree_construction_initial ($) { Line 918  sub _tree_construction_initial ($) {
918    
919    INITIAL: {    INITIAL: {
920      if ($token->{type} == DOCTYPE_TOKEN) {      if ($token->{type} == DOCTYPE_TOKEN) {
921        ## NOTE: Conformance checkers MAY, instead of reporting "not HTML5"        ## NOTE: Conformance checkers MAY, instead of reporting "not
922        ## error, switch to a conformance checking mode for another        ## HTML5" error, switch to a conformance checking mode for
923        ## language.        ## another language.  (We don't support such mode switchings; it
924          ## is nonsense to do anything different from what browsers do.)
925        my $doctype_name = $token->{name};        my $doctype_name = $token->{name};
926        $doctype_name = '' unless defined $doctype_name;        $doctype_name = '' unless defined $doctype_name;
927        $doctype_name =~ tr/a-z/A-Z/;        my $doctype = $self->{document}->create_document_type_definition
928        if (not defined $token->{name} or # <!DOCTYPE>            ($doctype_name);
929            defined $token->{public_identifier} or  
930            defined $token->{system_identifier}) {        $doctype_name =~ tr/A-Z/a-z/; # ASCII case-insensitive
931          if ($doctype_name ne 'html') {
932          !!!cp ('t1');          !!!cp ('t1');
933          !!!parse-error (type => 'not HTML5', token => $token);          !!!parse-error (type => 'not HTML5', token => $token);
934        } elsif ($doctype_name ne 'HTML') {        } elsif (defined $token->{pubid}) {
935          !!!cp ('t2');          !!!cp ('t2');
936          ## ISSUE: ASCII case-insensitive? (in fact it does not matter)          ## XXX Obsolete permitted DOCTYPEs
937          !!!parse-error (type => 'not HTML5', token => $token);          !!!parse-error (type => 'not HTML5', token => $token);
938        } else {        } elsif (defined $token->{sysid}) {
939            if ($token->{sysid} eq 'about:legacy-compat') {
940              !!!cp ('t1.2'); ## <!DOCTYPE HTML SYSTEM "about:legacy-compat">
941              !!!parse-error (type => 'XSLT-compat', token => $token,
942                              level => $self->{level}->{should});
943            } else {
944              !!!parse-error (type => 'not HTML5', token => $token);
945            }
946          } else { ## <!DOCTYPE HTML>
947          !!!cp ('t3');          !!!cp ('t3');
948            #
949        }        }
950                
951        my $doctype = $self->{document}->create_document_type_definition        ## NOTE: Default value for both |public_id| and |system_id| attributes
952          ($token->{name}); ## ISSUE: If name is missing (e.g. <!DOCTYPE>)?        ## are empty strings, so that we don't set any value in missing cases.
953        $doctype->public_id ($token->{public_identifier})        $doctype->public_id ($token->{pubid}) if defined $token->{pubid};
954            if defined $token->{public_identifier};        $doctype->system_id ($token->{sysid}) if defined $token->{sysid};
955        $doctype->system_id ($token->{system_identifier})  
           if defined $token->{system_identifier};  
956        ## NOTE: Other DocumentType attributes are null or empty lists.        ## NOTE: Other DocumentType attributes are null or empty lists.
957        ## ISSUE: internalSubset = null??        ## In Firefox3, |internalSubset| attribute is set to the empty
958          ## string, while |null| is an allowed value for the attribute
959          ## according to DOM3 Core.
960        $self->{document}->append_child ($doctype);        $self->{document}->append_child ($doctype);
961                
962        if ($token->{quirks} or $doctype_name ne 'HTML') {        if ($token->{quirks} or $doctype_name ne 'html') {
963          !!!cp ('t4');          !!!cp ('t4');
964          $self->{document}->manakai_compat_mode ('quirks');          $self->{document}->manakai_compat_mode ('quirks');
965        } elsif (defined $token->{public_identifier}) {        } elsif (defined $token->{pubid}) {
966          my $pubid = $token->{public_identifier};          my $pubid = $token->{pubid};
967          $pubid =~ tr/a-z/A-z/;          $pubid =~ tr/a-z/A-z/;
968          if ({          my $prefix = [
969            "+//SILMARIL//DTD HTML PRO V0R11 19970101//EN" => 1,            "+//SILMARIL//DTD HTML PRO V0R11 19970101//",
970            "-//ADVASOFT LTD//DTD HTML 3.0 ASWEDIT + EXTENSIONS//EN" => 1,            "-//ADVASOFT LTD//DTD HTML 3.0 ASWEDIT + EXTENSIONS//",
971            "-//AS//DTD HTML 3.0 ASWEDIT + EXTENSIONS//EN" => 1,            "-//AS//DTD HTML 3.0 ASWEDIT + EXTENSIONS//",
972            "-//IETF//DTD HTML 2.0 LEVEL 1//EN" => 1,            "-//IETF//DTD HTML 2.0 LEVEL 1//",
973            "-//IETF//DTD HTML 2.0 LEVEL 2//EN" => 1,            "-//IETF//DTD HTML 2.0 LEVEL 2//",
974            "-//IETF//DTD HTML 2.0 STRICT LEVEL 1//EN" => 1,            "-//IETF//DTD HTML 2.0 STRICT LEVEL 1//",
975            "-//IETF//DTD HTML 2.0 STRICT LEVEL 2//EN" => 1,            "-//IETF//DTD HTML 2.0 STRICT LEVEL 2//",
976            "-//IETF//DTD HTML 2.0 STRICT//EN" => 1,            "-//IETF//DTD HTML 2.0 STRICT//",
977            "-//IETF//DTD HTML 2.0//EN" => 1,            "-//IETF//DTD HTML 2.0//",
978            "-//IETF//DTD HTML 2.1E//EN" => 1,            "-//IETF//DTD HTML 2.1E//",
979            "-//IETF//DTD HTML 3.0//EN" => 1,            "-//IETF//DTD HTML 3.0//",
980            "-//IETF//DTD HTML 3.0//EN//" => 1,            "-//IETF//DTD HTML 3.2 FINAL//",
981            "-//IETF//DTD HTML 3.2 FINAL//EN" => 1,            "-//IETF//DTD HTML 3.2//",
982            "-//IETF//DTD HTML 3.2//EN" => 1,            "-//IETF//DTD HTML 3//",
983            "-//IETF//DTD HTML 3//EN" => 1,            "-//IETF//DTD HTML LEVEL 0//",
984            "-//IETF//DTD HTML LEVEL 0//EN" => 1,            "-//IETF//DTD HTML LEVEL 1//",
985            "-//IETF//DTD HTML LEVEL 0//EN//2.0" => 1,            "-//IETF//DTD HTML LEVEL 2//",
986            "-//IETF//DTD HTML LEVEL 1//EN" => 1,            "-//IETF//DTD HTML LEVEL 3//",
987            "-//IETF//DTD HTML LEVEL 1//EN//2.0" => 1,            "-//IETF//DTD HTML STRICT LEVEL 0//",
988            "-//IETF//DTD HTML LEVEL 2//EN" => 1,            "-//IETF//DTD HTML STRICT LEVEL 1//",
989            "-//IETF//DTD HTML LEVEL 2//EN//2.0" => 1,            "-//IETF//DTD HTML STRICT LEVEL 2//",
990            "-//IETF//DTD HTML LEVEL 3//EN" => 1,            "-//IETF//DTD HTML STRICT LEVEL 3//",
991            "-//IETF//DTD HTML LEVEL 3//EN//3.0" => 1,            "-//IETF//DTD HTML STRICT//",
992            "-//IETF//DTD HTML STRICT LEVEL 0//EN" => 1,            "-//IETF//DTD HTML//",
993            "-//IETF//DTD HTML STRICT LEVEL 0//EN//2.0" => 1,            "-//METRIUS//DTD METRIUS PRESENTATIONAL//",
994            "-//IETF//DTD HTML STRICT LEVEL 1//EN" => 1,            "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML STRICT//",
995            "-//IETF//DTD HTML STRICT LEVEL 1//EN//2.0" => 1,            "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML//",
996            "-//IETF//DTD HTML STRICT LEVEL 2//EN" => 1,            "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 TABLES//",
997            "-//IETF//DTD HTML STRICT LEVEL 2//EN//2.0" => 1,            "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML STRICT//",
998            "-//IETF//DTD HTML STRICT LEVEL 3//EN" => 1,            "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML//",
999            "-//IETF//DTD HTML STRICT LEVEL 3//EN//3.0" => 1,            "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 TABLES//",
1000            "-//IETF//DTD HTML STRICT//EN" => 1,            "-//NETSCAPE COMM. CORP.//DTD HTML//",
1001            "-//IETF//DTD HTML STRICT//EN//2.0" => 1,            "-//NETSCAPE COMM. CORP.//DTD STRICT HTML//",
1002            "-//IETF//DTD HTML STRICT//EN//3.0" => 1,            "-//O'REILLY AND ASSOCIATES//DTD HTML 2.0//",
1003            "-//IETF//DTD HTML//EN" => 1,            "-//O'REILLY AND ASSOCIATES//DTD HTML EXTENDED 1.0//",
1004            "-//IETF//DTD HTML//EN//2.0" => 1,            "-//O'REILLY AND ASSOCIATES//DTD HTML EXTENDED RELAXED 1.0//",
1005            "-//IETF//DTD HTML//EN//3.0" => 1,            "-//SOFTQUAD SOFTWARE//DTD HOTMETAL PRO 6.0::19990601::EXTENSIONS TO HTML 4.0//",
1006            "-//METRIUS//DTD METRIUS PRESENTATIONAL//EN" => 1,            "-//SOFTQUAD//DTD HOTMETAL PRO 4.0::19971010::EXTENSIONS TO HTML 4.0//",
1007            "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML STRICT//EN" => 1,            "-//SPYGLASS//DTD HTML 2.0 EXTENDED//",
1008            "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML//EN" => 1,            "-//SQ//DTD HTML 2.0 HOTMETAL + EXTENSIONS//",
1009            "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 TABLES//EN" => 1,            "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA HTML//",
1010            "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML STRICT//EN" => 1,            "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA STRICT HTML//",
1011            "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML//EN" => 1,            "-//W3C//DTD HTML 3 1995-03-24//",
1012            "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 TABLES//EN" => 1,            "-//W3C//DTD HTML 3.2 DRAFT//",
1013            "-//NETSCAPE COMM. CORP.//DTD HTML//EN" => 1,            "-//W3C//DTD HTML 3.2 FINAL//",
1014            "-//NETSCAPE COMM. CORP.//DTD STRICT HTML//EN" => 1,            "-//W3C//DTD HTML 3.2//",
1015            "-//O'REILLY AND ASSOCIATES//DTD HTML 2.0//EN" => 1,            "-//W3C//DTD HTML 3.2S DRAFT//",
1016            "-//O'REILLY AND ASSOCIATES//DTD HTML EXTENDED 1.0//EN" => 1,            "-//W3C//DTD HTML 4.0 FRAMESET//",
1017            "-//O'REILLY AND ASSOCIATES//DTD HTML EXTENDED RELAXED 1.0//EN" => 1,            "-//W3C//DTD HTML 4.0 TRANSITIONAL//",
1018            "-//SOFTQUAD SOFTWARE//DTD HOTMETAL PRO 6.0::19990601::EXTENSIONS TO HTML 4.0//EN" => 1,            "-//W3C//DTD HTML EXPERIMETNAL 19960712//",
1019            "-//SOFTQUAD//DTD HOTMETAL PRO 4.0::19971010::EXTENSIONS TO HTML 4.0//EN" => 1,            "-//W3C//DTD HTML EXPERIMENTAL 970421//",
1020            "-//SPYGLASS//DTD HTML 2.0 EXTENDED//EN" => 1,            "-//W3C//DTD W3 HTML//",
1021            "-//SQ//DTD HTML 2.0 HOTMETAL + EXTENSIONS//EN" => 1,            "-//W3O//DTD W3 HTML 3.0//",
1022            "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA HTML//EN" => 1,            "-//WEBTECHS//DTD MOZILLA HTML 2.0//",
1023            "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA STRICT HTML//EN" => 1,            "-//WEBTECHS//DTD MOZILLA HTML//",
1024            "-//W3C//DTD HTML 3 1995-03-24//EN" => 1,          ]; # $prefix
1025            "-//W3C//DTD HTML 3.2 DRAFT//EN" => 1,          my $match;
1026            "-//W3C//DTD HTML 3.2 FINAL//EN" => 1,          for (@$prefix) {
1027            "-//W3C//DTD HTML 3.2//EN" => 1,            if (substr ($prefix, 0, length $_) eq $_) {
1028            "-//W3C//DTD HTML 3.2S DRAFT//EN" => 1,              $match = 1;
1029            "-//W3C//DTD HTML 4.0 FRAMESET//EN" => 1,              last;
1030            "-//W3C//DTD HTML 4.0 TRANSITIONAL//EN" => 1,            }
1031            "-//W3C//DTD HTML EXPERIMETNAL 19960712//EN" => 1,          }
1032            "-//W3C//DTD HTML EXPERIMENTAL 970421//EN" => 1,          if ($match or
1033            "-//W3C//DTD W3 HTML//EN" => 1,              $pubid eq "-//W3O//DTD W3 HTML STRICT 3.0//EN//" or
1034            "-//W3O//DTD W3 HTML 3.0//EN" => 1,              $pubid eq "-/W3C/DTD HTML 4.0 TRANSITIONAL/EN" or
1035            "-//W3O//DTD W3 HTML 3.0//EN//" => 1,              $pubid eq "HTML") {
           "-//W3O//DTD W3 HTML STRICT 3.0//EN//" => 1,  
           "-//WEBTECHS//DTD MOZILLA HTML 2.0//EN" => 1,  
           "-//WEBTECHS//DTD MOZILLA HTML//EN" => 1,  
           "-/W3C/DTD HTML 4.0 TRANSITIONAL/EN" => 1,  
           "HTML" => 1,  
         }->{$pubid}) {  
1036            !!!cp ('t5');            !!!cp ('t5');
1037            $self->{document}->manakai_compat_mode ('quirks');            $self->{document}->manakai_compat_mode ('quirks');
1038          } elsif ($pubid eq "-//W3C//DTD HTML 4.01 FRAMESET//EN" or          } elsif ($pubid =~ m[^-//W3C//DTD HTML 4.01 FRAMESET//] or
1039                   $pubid eq "-//W3C//DTD HTML 4.01 TRANSITIONAL//EN") {                   $pubid =~ m[^-//W3C//DTD HTML 4.01 TRANSITIONAL//]) {
1040            if (defined $token->{system_identifier}) {            if (defined $token->{sysid}) {
1041              !!!cp ('t6');              !!!cp ('t6');
1042              $self->{document}->manakai_compat_mode ('quirks');              $self->{document}->manakai_compat_mode ('quirks');
1043            } else {            } else {
1044              !!!cp ('t7');              !!!cp ('t7');
1045              $self->{document}->manakai_compat_mode ('limited quirks');              $self->{document}->manakai_compat_mode ('limited quirks');
1046            }            }
1047          } elsif ($pubid eq "-//W3C//DTD XHTML 1.0 FRAMESET//EN" or          } elsif ($pubid =~ m[^-//W3C//DTD XHTML 1.0 FRAMESET//] or
1048                   $pubid eq "-//W3C//DTD XHTML 1.0 TRANSITIONAL//EN") {                   $pubid =~ m[^-//W3C//DTD XHTML 1.0 TRANSITIONAL//]) {
1049            !!!cp ('t8');            !!!cp ('t8');
1050            $self->{document}->manakai_compat_mode ('limited quirks');            $self->{document}->manakai_compat_mode ('limited quirks');
1051          } else {          } else {
# Line 2641  sub _tree_construction_initial ($) { Line 1054  sub _tree_construction_initial ($) {
1054        } else {        } else {
1055          !!!cp ('t10');          !!!cp ('t10');
1056        }        }
1057        if (defined $token->{system_identifier}) {        if (defined $token->{sysid}) {
1058          my $sysid = $token->{system_identifier};          my $sysid = $token->{sysid};
1059          $sysid =~ tr/A-Z/a-z/;          $sysid =~ tr/A-Z/a-z/;
1060          if ($sysid eq "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd") {          if ($sysid eq "http://www.ibm.com/data/dtd/v11/ibmxhtml1-transitional.dtd") {
1061            ## TODO: Check the spec: PUBLIC "(limited quirks)" "(quirks)"            ## NOTE: Ensure that |PUBLIC "(limited quirks)" "(quirks)"| is
1062              ## marked as quirks.
1063            $self->{document}->manakai_compat_mode ('quirks');            $self->{document}->manakai_compat_mode ('quirks');
1064            !!!cp ('t11');            !!!cp ('t11');
1065          } else {          } else {
# Line 2668  sub _tree_construction_initial ($) { Line 1082  sub _tree_construction_initial ($) {
1082        $self->{document}->manakai_compat_mode ('quirks');        $self->{document}->manakai_compat_mode ('quirks');
1083        ## Go to the "before html" insertion mode.        ## Go to the "before html" insertion mode.
1084        ## reprocess        ## reprocess
1085          !!!ack-later;
1086        return;        return;
1087      } elsif ($token->{type} == CHARACTER_TOKEN) {      } elsif ($token->{type} == CHARACTER_TOKEN) {
1088        if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D        if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
1089          ## Ignore the token          ## Ignore the token
1090    
1091          unless (length $token->{data}) {          unless (length $token->{data}) {
# Line 2727  sub _tree_construction_root_element ($) Line 1142  sub _tree_construction_root_element ($)
1142          !!!next-token;          !!!next-token;
1143          redo B;          redo B;
1144        } elsif ($token->{type} == CHARACTER_TOKEN) {        } elsif ($token->{type} == CHARACTER_TOKEN) {
1145          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D          if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
1146            ## Ignore the token.            ## Ignore the token.
1147    
1148            unless (length $token->{data}) {            unless (length $token->{data}) {
# Line 2748  sub _tree_construction_root_element ($) Line 1163  sub _tree_construction_root_element ($)
1163        } elsif ($token->{type} == START_TAG_TOKEN) {        } elsif ($token->{type} == START_TAG_TOKEN) {
1164          if ($token->{tag_name} eq 'html') {          if ($token->{tag_name} eq 'html') {
1165            my $root_element;            my $root_element;
1166            !!!create-element ($root_element, $token->{tag_name}, $token->{attributes}, $token);            !!!create-element ($root_element, $HTML_NS, $token->{tag_name}, $token->{attributes}, $token);
1167            $self->{document}->append_child ($root_element);            $self->{document}->append_child ($root_element);
1168            push @{$self->{open_elements}}, [$root_element, 'html'];            push @{$self->{open_elements}},
1169                  [$root_element, $el_category->{html}];
1170    
1171            if ($token->{attributes}->{manifest}) {            if ($token->{attributes}->{manifest}) {
1172              !!!cp ('t24');              !!!cp ('t24');
# Line 2765  sub _tree_construction_root_element ($) Line 1181  sub _tree_construction_root_element ($)
1181              $self->{application_cache_selection}->(undef);              $self->{application_cache_selection}->(undef);
1182            }            }
1183    
1184              !!!nack ('t25c');
1185    
1186            !!!next-token;            !!!next-token;
1187            return; ## Go to the "before head" insertion mode.            return; ## Go to the "before head" insertion mode.
1188          } else {          } else {
# Line 2781  sub _tree_construction_root_element ($) Line 1199  sub _tree_construction_root_element ($)
1199          die "$0: $token->{type}: Unknown token type";          die "$0: $token->{type}: Unknown token type";
1200        }        }
1201    
1202      my $root_element; !!!create-element ($root_element, 'html',, $token);      my $root_element;
1203        !!!create-element ($root_element, $HTML_NS, 'html',, $token);
1204      $self->{document}->append_child ($root_element);      $self->{document}->append_child ($root_element);
1205      push @{$self->{open_elements}}, [$root_element, 'html'];      push @{$self->{open_elements}}, [$root_element, $el_category->{html}];
1206    
1207      $self->{application_cache_selection}->(undef);      $self->{application_cache_selection}->(undef);
1208    
1209      ## NOTE: Reprocess the token.      ## NOTE: Reprocess the token.
1210        !!!ack-later;
1211      return; ## Go to the "before head" insertion mode.      return; ## Go to the "before head" insertion mode.
   
     ## ISSUE: There is an issue in the spec  
1212    } # B    } # B
1213    
1214    die "$0: _tree_construction_root_element: This should never be reached";    die "$0: _tree_construction_root_element: This should never be reached";
# Line 2811  sub _reset_insertion_mode ($) { Line 1229  sub _reset_insertion_mode ($) {
1229        if ($self->{open_elements}->[0]->[0] eq $node->[0]) {        if ($self->{open_elements}->[0]->[0] eq $node->[0]) {
1230          $last = 1;          $last = 1;
1231          if (defined $self->{inner_html_node}) {          if (defined $self->{inner_html_node}) {
1232            if ($self->{inner_html_node}->[1] eq 'td' or            !!!cp ('t28');
1233                $self->{inner_html_node}->[1] eq 'th') {            $node = $self->{inner_html_node};
1234              !!!cp ('t27');          } else {
1235              #            die "_reset_insertion_mode: t27";
           } else {  
             !!!cp ('t28');  
             $node = $self->{inner_html_node};  
           }  
1236          }          }
1237        }        }
1238              
1239        ## Step 4..13        ## Step 4..14
1240        my $new_mode = {        my $new_mode;
1241          if ($node->[1] & FOREIGN_EL) {
1242            !!!cp ('t28.1');
1243            ## NOTE: Strictly spaking, the line below only applies to MathML and
1244            ## SVG elements.  Currently the HTML syntax supports only MathML and
1245            ## SVG elements as foreigners.
1246            $new_mode = IN_BODY_IM | IN_FOREIGN_CONTENT_IM;
1247          } elsif ($node->[1] == TABLE_CELL_EL) {
1248            if ($last) {
1249              !!!cp ('t28.2');
1250              #
1251            } else {
1252              !!!cp ('t28.3');
1253              $new_mode = IN_CELL_IM;
1254            }
1255          } else {
1256            !!!cp ('t28.4');
1257            $new_mode = {
1258                        select => IN_SELECT_IM,                        select => IN_SELECT_IM,
1259                        ## NOTE: |option| and |optgroup| do not set                        ## NOTE: |option| and |optgroup| do not set
1260                        ## insertion mode to "in select" by themselves.                        ## insertion mode to "in select" by themselves.
                       td => IN_CELL_IM,  
                       th => IN_CELL_IM,  
1261                        tr => IN_ROW_IM,                        tr => IN_ROW_IM,
1262                        tbody => IN_TABLE_BODY_IM,                        tbody => IN_TABLE_BODY_IM,
1263                        thead => IN_TABLE_BODY_IM,                        thead => IN_TABLE_BODY_IM,
# Line 2839  sub _reset_insertion_mode ($) { Line 1268  sub _reset_insertion_mode ($) {
1268                        head => IN_BODY_IM, # not in head!                        head => IN_BODY_IM, # not in head!
1269                        body => IN_BODY_IM,                        body => IN_BODY_IM,
1270                        frameset => IN_FRAMESET_IM,                        frameset => IN_FRAMESET_IM,
1271                       }->{$node->[1]};                       }->{$node->[0]->manakai_local_name};
1272          }
1273        $self->{insertion_mode} = $new_mode and return if defined $new_mode;        $self->{insertion_mode} = $new_mode and return if defined $new_mode;
1274                
1275        ## Step 14        ## Step 15
1276        if ($node->[1] eq 'html') {        if ($node->[1] == HTML_EL) {
1277          unless (defined $self->{head_element}) {          unless (defined $self->{head_element}) {
1278            !!!cp ('t29');            !!!cp ('t29');
1279            $self->{insertion_mode} = BEFORE_HEAD_IM;            $self->{insertion_mode} = BEFORE_HEAD_IM;
# Line 2857  sub _reset_insertion_mode ($) { Line 1287  sub _reset_insertion_mode ($) {
1287          !!!cp ('t31');          !!!cp ('t31');
1288        }        }
1289                
1290        ## Step 15        ## Step 16
1291        $self->{insertion_mode} = IN_BODY_IM and return if $last;        $self->{insertion_mode} = IN_BODY_IM and return if $last;
1292                
1293        ## Step 16        ## Step 17
1294        $i--;        $i--;
1295        $node = $self->{open_elements}->[$i];        $node = $self->{open_elements}->[$i];
1296                
1297        ## Step 17        ## Step 18
1298        redo S3;        redo S3;
1299      } # S3      } # S3
1300    
# Line 2975  sub _tree_construction_main ($) { Line 1405  sub _tree_construction_main ($) {
1405    
1406      ## Step 1      ## Step 1
1407      my $start_tag_name = $token->{tag_name};      my $start_tag_name = $token->{tag_name};
1408      my $el;      !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
     !!!create-element ($el, $start_tag_name, $token->{attributes}, $token);  
1409    
1410      ## Step 2      ## Step 2
     $insert->($el);  
   
     ## Step 3  
1411      $self->{content_model} = $content_model_flag; # CDATA or RCDATA      $self->{content_model} = $content_model_flag; # CDATA or RCDATA
1412      delete $self->{escape}; # MUST      delete $self->{escape}; # MUST
1413    
1414      ## Step 4      ## Step 3, 4
1415      my $text = '';      $self->{insertion_mode} |= IN_CDATA_RCDATA_IM;
     !!!next-token;  
     while ($token->{type} == CHARACTER_TOKEN) { # or until stop tokenizing  
       !!!cp ('t40');  
       $text .= $token->{data};  
       !!!next-token;  
     }  
1416    
1417      ## Step 5      !!!nack ('t40.1');
     if (length $text) {  
       !!!cp ('t41');  
       my $text = $self->{document}->create_text_node ($text);  
       $el->append_child ($text);  
     }  
   
     ## Step 6  
     $self->{content_model} = PCDATA_CONTENT_MODEL;  
   
     ## Step 7  
     if ($token->{type} == END_TAG_TOKEN and  
         $token->{tag_name} eq $start_tag_name) {  
       !!!cp ('t42');  
       ## Ignore the token  
     } else {  
       ## NOTE: An end-of-file token.  
       if ($content_model_flag == CDATA_CONTENT_MODEL) {  
         !!!cp ('t43');  
         !!!parse-error (type => 'in CDATA:#'.$token->{type}, token => $token);  
       } elsif ($content_model_flag == RCDATA_CONTENT_MODEL) {  
         !!!cp ('t44');  
         !!!parse-error (type => 'in RCDATA:#'.$token->{type}, token => $token);  
       } else {  
         die "$0: $content_model_flag in parse_rcdata";  
       }  
     }  
1418      !!!next-token;      !!!next-token;
1419    }; # $parse_rcdata    }; # $parse_rcdata
1420    
1421    my $script_start_tag = sub () {    my $script_start_tag = sub () {
1422        ## Step 1
1423      my $script_el;      my $script_el;
1424      !!!create-element ($script_el, 'script', $token->{attributes}, $token);      !!!create-element ($script_el, $HTML_NS, 'script', $token->{attributes}, $token);
1425    
1426        ## Step 2
1427      ## TODO: mark as "parser-inserted"      ## TODO: mark as "parser-inserted"
1428    
1429        ## Step 3
1430        ## TODO: Mark as "already executed", if ...
1431    
1432        ## Step 4 (HTML5 revision 2702)
1433        $insert->($script_el);
1434        push @{$self->{open_elements}}, [$script_el, $el_category->{script}];
1435    
1436        ## Step 5
1437      $self->{content_model} = CDATA_CONTENT_MODEL;      $self->{content_model} = CDATA_CONTENT_MODEL;
1438      delete $self->{escape}; # MUST      delete $self->{escape}; # MUST
       
     my $text = '';  
     !!!next-token;  
     while ($token->{type} == CHARACTER_TOKEN) {  
       !!!cp ('t45');  
       $text .= $token->{data};  
       !!!next-token;  
     } # stop if non-character token or tokenizer stops tokenising  
     if (length $text) {  
       !!!cp ('t46');  
       $script_el->manakai_append_text ($text);  
     }  
                 
     $self->{content_model} = PCDATA_CONTENT_MODEL;  
1439    
1440      if ($token->{type} == END_TAG_TOKEN and      ## Step 6-7
1441          $token->{tag_name} eq 'script') {      $self->{insertion_mode} |= IN_CDATA_RCDATA_IM;
       !!!cp ('t47');  
       ## Ignore the token  
     } else {  
       !!!cp ('t48');  
       !!!parse-error (type => 'in CDATA:#'.$token->{type}, token => $token);  
       ## ISSUE: And ignore?  
       ## TODO: mark as "already executed"  
     }  
       
     if (defined $self->{inner_html_node}) {  
       !!!cp ('t49');  
       ## TODO: mark as "already executed"  
     } else {  
       !!!cp ('t50');  
       ## TODO: $old_insertion_point = current insertion point  
       ## TODO: insertion point = just before the next input character  
1442    
1443        $insert->($script_el);      !!!nack ('t40.2');
         
       ## TODO: insertion point = $old_insertion_point (might be "undefined")  
         
       ## TODO: if there is a script that will execute as soon as the parser resume, then...  
     }  
       
1444      !!!next-token;      !!!next-token;
1445    }; # $script_start_tag    }; # $script_start_tag
1446    
1447    ## NOTE: $open_tables->[-1]->[0] is the "current table" element node.    ## NOTE: $open_tables->[-1]->[0] is the "current table" element node.
1448    ## NOTE: $open_tables->[-1]->[1] is the "tainted" flag.    ## NOTE: $open_tables->[-1]->[1] is the "tainted" flag (OBSOLETE; unused).
1449      ## NOTE: $open_tables->[-1]->[2] is set false when non-Text node inserted.
1450    my $open_tables = [[$self->{open_elements}->[0]->[0]]];    my $open_tables = [[$self->{open_elements}->[0]->[0]]];
1451    
1452    my $formatting_end_tag = sub {    my $formatting_end_tag = sub {
# Line 3090  sub _tree_construction_main ($) { Line 1460  sub _tree_construction_main ($) {
1460        my $formatting_element;        my $formatting_element;
1461        my $formatting_element_i_in_active;        my $formatting_element_i_in_active;
1462        AFE: for (reverse 0..$#$active_formatting_elements) {        AFE: for (reverse 0..$#$active_formatting_elements) {
1463          if ($active_formatting_elements->[$_]->[1] eq $tag_name) {          if ($active_formatting_elements->[$_]->[0] eq '#marker') {
1464              !!!cp ('t52');
1465              last AFE;
1466            } elsif ($active_formatting_elements->[$_]->[0]->manakai_local_name
1467                         eq $tag_name) {
1468            !!!cp ('t51');            !!!cp ('t51');
1469            $formatting_element = $active_formatting_elements->[$_];            $formatting_element = $active_formatting_elements->[$_];
1470            $formatting_element_i_in_active = $_;            $formatting_element_i_in_active = $_;
1471            last AFE;            last AFE;
         } elsif ($active_formatting_elements->[$_]->[0] eq '#marker') {  
           !!!cp ('t52');  
           last AFE;  
1472          }          }
1473        } # AFE        } # AFE
1474        unless (defined $formatting_element) {        unless (defined $formatting_element) {
1475          !!!cp ('t53');          !!!cp ('t53');
1476          !!!parse-error (type => 'unmatched end tag:'.$tag_name, token => $end_tag_token);          !!!parse-error (type => 'unmatched end tag', text => $tag_name, token => $end_tag_token);
1477          ## Ignore the token          ## Ignore the token
1478          !!!next-token;          !!!next-token;
1479          return;          return;
# Line 3119  sub _tree_construction_main ($) { Line 1490  sub _tree_construction_main ($) {
1490              last INSCOPE;              last INSCOPE;
1491            } else { # in open elements but not in scope            } else { # in open elements but not in scope
1492              !!!cp ('t55');              !!!cp ('t55');
1493              !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name},              !!!parse-error (type => 'unmatched end tag',
1494                                text => $token->{tag_name},
1495                              token => $end_tag_token);                              token => $end_tag_token);
1496              ## Ignore the token              ## Ignore the token
1497              !!!next-token;              !!!next-token;
1498              return;              return;
1499            }            }
1500          } elsif ({          } elsif ($node->[1] & SCOPING_EL) {
                   applet => 1, table => 1, caption => 1, td => 1, th => 1,  
                   button => 1, marquee => 1, object => 1, html => 1,  
                  }->{$node->[1]}) {  
1501            !!!cp ('t56');            !!!cp ('t56');
1502            $in_scope = 0;            $in_scope = 0;
1503          }          }
1504        } # INSCOPE        } # INSCOPE
1505        unless (defined $formatting_element_i_in_open) {        unless (defined $formatting_element_i_in_open) {
1506          !!!cp ('t57');          !!!cp ('t57');
1507          !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name},          !!!parse-error (type => 'unmatched end tag',
1508                            text => $token->{tag_name},
1509                          token => $end_tag_token);                          token => $end_tag_token);
1510          pop @$active_formatting_elements; # $formatting_element          pop @$active_formatting_elements; # $formatting_element
1511          !!!next-token; ## TODO: ok?          !!!next-token; ## TODO: ok?
# Line 3143  sub _tree_construction_main ($) { Line 1513  sub _tree_construction_main ($) {
1513        }        }
1514        if (not $self->{open_elements}->[-1]->[0] eq $formatting_element->[0]) {        if (not $self->{open_elements}->[-1]->[0] eq $formatting_element->[0]) {
1515          !!!cp ('t58');          !!!cp ('t58');
1516          !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1],          !!!parse-error (type => 'not closed',
1517                            text => $self->{open_elements}->[-1]->[0]
1518                                ->manakai_local_name,
1519                          token => $end_tag_token);                          token => $end_tag_token);
1520        }        }
1521                
# Line 3152  sub _tree_construction_main ($) { Line 1524  sub _tree_construction_main ($) {
1524        my $furthest_block_i_in_open;        my $furthest_block_i_in_open;
1525        OE: for (reverse 0..$#{$self->{open_elements}}) {        OE: for (reverse 0..$#{$self->{open_elements}}) {
1526          my $node = $self->{open_elements}->[$_];          my $node = $self->{open_elements}->[$_];
1527          if (not $formatting_category->{$node->[1]} and          if (not ($node->[1] & FORMATTING_EL) and
1528              #not $phrasing_category->{$node->[1]} and              #not $phrasing_category->{$node->[1]} and
1529              ($special_category->{$node->[1]} or              ($node->[1] & SPECIAL_EL or
1530               $scoping_category->{$node->[1]})) { ## Scoping is redundant, maybe               $node->[1] & SCOPING_EL)) { ## Scoping is redundant, maybe
1531            !!!cp ('t59');            !!!cp ('t59');
1532            $furthest_block = $node;            $furthest_block = $node;
1533            $furthest_block_i_in_open = $_;            $furthest_block_i_in_open = $_;
1534              ## NOTE: The topmost (eldest) node.
1535          } elsif ($node->[0] eq $formatting_element->[0]) {          } elsif ($node->[0] eq $formatting_element->[0]) {
1536            !!!cp ('t60');            !!!cp ('t60');
1537            last OE;            last OE;
# Line 3241  sub _tree_construction_main ($) { Line 1614  sub _tree_construction_main ($) {
1614        } # S7          } # S7  
1615                
1616        ## Step 8        ## Step 8
1617        if ({        if ($common_ancestor_node->[1] & TABLE_ROWS_EL) {
1618             table => 1, tbody => 1, tfoot => 1, thead => 1, tr => 1,          ## Foster parenting.
           }->{$common_ancestor_node->[1]}) {  
1619          my $foster_parent_element;          my $foster_parent_element;
1620          my $next_sibling;          my $next_sibling;
1621                           OE: for (reverse 0..$#{$self->{open_elements}}) {          OE: for (reverse 0..$#{$self->{open_elements}}) {
1622                             if ($self->{open_elements}->[$_]->[1] eq 'table') {            if ($self->{open_elements}->[$_]->[1] == TABLE_EL) {
1623                               my $parent = $self->{open_elements}->[$_]->[0]->parent_node;              !!!cp ('t65.2');
1624                               if (defined $parent and $parent->node_type == 1) {              $foster_parent_element = $self->{open_elements}->[$_ - 1]->[0];
1625                                 !!!cp ('t65.1');              $next_sibling = $self->{open_elements}->[$_]->[0];
1626                                 $foster_parent_element = $parent;              undef $next_sibling
1627                                 $next_sibling = $self->{open_elements}->[$_]->[0];                  unless $next_sibling->parent_node eq $foster_parent_element;
1628                               } else {              last OE;
1629                                 !!!cp ('t65.2');            }
1630                                 $foster_parent_element          } # OE
1631                                   = $self->{open_elements}->[$_ - 1]->[0];          $foster_parent_element ||= $self->{open_elements}->[0]->[0];
1632                               }  
                              last OE;  
                            }  
                          } # OE  
                          $foster_parent_element = $self->{open_elements}->[0]->[0]  
                            unless defined $foster_parent_element;  
1633          $foster_parent_element->insert_before ($last_node->[0], $next_sibling);          $foster_parent_element->insert_before ($last_node->[0], $next_sibling);
1634          $open_tables->[-1]->[1] = 1; # tainted          $open_tables->[-1]->[1] = 1; # tainted
1635        } else {        } else {
# Line 3307  sub _tree_construction_main ($) { Line 1674  sub _tree_construction_main ($) {
1674            $i = $_;            $i = $_;
1675          }          }
1676        } # OE        } # OE
1677        splice @{$self->{open_elements}}, $i + 1, 1, $clone;        splice @{$self->{open_elements}}, $i + 1, 0, $clone;
1678                
1679        ## Step 14        ## Step 14
1680        redo FET;        redo FET;
# Line 3318  sub _tree_construction_main ($) { Line 1685  sub _tree_construction_main ($) {
1685      $self->{open_elements}->[-1]->[0]->append_child ($_[0]);      $self->{open_elements}->[-1]->[0]->append_child ($_[0]);
1686    }; # $insert_to_current    }; # $insert_to_current
1687    
1688      ## Foster parenting.  Note that there are three "foster parenting"
1689      ## code in the parser: for elements (this one), for texts, and for
1690      ## elements in the AAA code.
1691    my $insert_to_foster = sub {    my $insert_to_foster = sub {
1692      my $child = shift;      my $child = shift;
1693      if ({      if ($self->{open_elements}->[-1]->[1] & TABLE_ROWS_EL) {
          table => 1, tbody => 1, tfoot => 1, thead => 1, tr => 1,  
         }->{$self->{open_elements}->[-1]->[1]}) {  
1694        # MUST        # MUST
1695        my $foster_parent_element;        my $foster_parent_element;
1696        my $next_sibling;        my $next_sibling;
1697                           OE: for (reverse 0..$#{$self->{open_elements}}) {        OE: for (reverse 0..$#{$self->{open_elements}}) {
1698                             if ($self->{open_elements}->[$_]->[1] eq 'table') {          if ($self->{open_elements}->[$_]->[1] == TABLE_EL) {
1699                               my $parent = $self->{open_elements}->[$_]->[0]->parent_node;            !!!cp ('t71');
1700                               if (defined $parent and $parent->node_type == 1) {            $foster_parent_element = $self->{open_elements}->[$_ - 1]->[0];
1701                                 !!!cp ('t70');            $next_sibling = $self->{open_elements}->[$_]->[0];
1702                                 $foster_parent_element = $parent;            undef $next_sibling
1703                                 $next_sibling = $self->{open_elements}->[$_]->[0];                unless $next_sibling->parent_node eq $foster_parent_element;
1704                               } else {            last OE;
1705                                 !!!cp ('t71');          }
1706                                 $foster_parent_element        } # OE
1707                                   = $self->{open_elements}->[$_ - 1]->[0];        $foster_parent_element ||= $self->{open_elements}->[0]->[0];
1708                               }  
1709                               last OE;        $foster_parent_element->insert_before ($child, $next_sibling);
                            }  
                          } # OE  
                          $foster_parent_element = $self->{open_elements}->[0]->[0]  
                            unless defined $foster_parent_element;  
                          $foster_parent_element->insert_before  
                            ($child, $next_sibling);  
1710        $open_tables->[-1]->[1] = 1; # tainted        $open_tables->[-1]->[1] = 1; # tainted
1711      } else {      } else {
1712        !!!cp ('t72');        !!!cp ('t72');
# Line 3352  sub _tree_construction_main ($) { Line 1714  sub _tree_construction_main ($) {
1714      }      }
1715    }; # $insert_to_foster    }; # $insert_to_foster
1716    
1717    B: {    ## NOTE: Insert a character (MUST): When a character is inserted, if
1718      ## the last node that was inserted by the parser is a Text node and
1719      ## the character has to be inserted after that node, then the
1720      ## character is appended to the Text node.  However, if any other
1721      ## node is inserted by the parser, then a new Text node is created
1722      ## and the character is appended as that Text node.  If I'm not
1723      ## wrong, for a parser with scripting disabled, there are only two
1724      ## cases where this occurs.  One is the case where an element node
1725      ## is inserted to the |head| element.  This is covered by using the
1726      ## |$self->{head_element_inserted}| flag.  Another is the case where
1727      ## an element or comment is inserted into the |table| subtree while
1728      ## foster parenting happens.  This is covered by using the [2] flag
1729      ## of the |$open_tables| structure.  All other cases are handled
1730      ## simply by calling |manakai_append_text| method.
1731    
1732      ## TODO: |<body><script>document.write("a<br>");
1733      ## document.body.removeChild (document.body.lastChild);
1734      ## document.write ("b")</script>|
1735    
1736      B: while (1) {
1737    
1738        ## The "in table text" insertion mode.
1739        if ($self->{insertion_mode} & TABLE_IMS and
1740            not $self->{insertion_mode} & IN_FOREIGN_CONTENT_IM and
1741            not $self->{insertion_mode} & IN_CDATA_RCDATA_IM) {
1742          C: {
1743            my $s;
1744            if ($token->{type} == CHARACTER_TOKEN) {
1745              !!!cp ('t194');
1746              $self->{pending_chars} ||= [];
1747              push @{$self->{pending_chars}}, $token;
1748              !!!next-token;
1749              next B;
1750            } else {
1751              if ($self->{pending_chars}) {
1752                $s = join '', map { $_->{data} } @{$self->{pending_chars}};
1753                delete $self->{pending_chars};
1754                if ($s =~ /[^\x09\x0A\x0C\x0D\x20]/) {
1755                  !!!cp ('t195');
1756                  #
1757                } else {
1758                  !!!cp ('t195.1');
1759                  #$self->{open_elements}->[-1]->[0]->manakai_append_text ($s);
1760                  $self->{open_elements}->[-1]->[0]->append_child
1761                      ($self->{document}->create_text_node ($s));
1762                  last C;
1763                }
1764              } else {
1765                !!!cp ('t195.2');
1766                last C;
1767              }
1768            }
1769    
1770            ## Foster parenting.
1771            !!!parse-error (type => 'in table:#text', token => $token);
1772    
1773            ## NOTE: As if in body, but insert into the foster parent element.
1774            $reconstruct_active_formatting_elements->($insert_to_foster);
1775                
1776            if ($self->{open_elements}->[-1]->[1] & TABLE_ROWS_EL) {
1777              # MUST
1778              my $foster_parent_element;
1779              my $next_sibling;
1780              OE: for (reverse 0..$#{$self->{open_elements}}) {
1781                if ($self->{open_elements}->[$_]->[1] == TABLE_EL) {
1782                  !!!cp ('t197');
1783                  $foster_parent_element = $self->{open_elements}->[$_ - 1]->[0];
1784                  $next_sibling = $self->{open_elements}->[$_]->[0];
1785                  undef $next_sibling
1786                    unless $next_sibling->parent_node eq $foster_parent_element;
1787                  last OE;
1788                }
1789              } # OE
1790              $foster_parent_element ||= $self->{open_elements}->[0]->[0];
1791    
1792              !!!cp ('t199');
1793              $foster_parent_element->insert_before
1794                  ($self->{document}->create_text_node ($s), $next_sibling);
1795    
1796              $open_tables->[-1]->[1] = 1; # tainted
1797              $open_tables->[-1]->[2] = 1; # ~node inserted
1798            } else {
1799              ## NOTE: Fragment case or in a foster parent'ed element
1800              ## (e.g. |<table><span>a|).  In fragment case, whether the
1801              ## character is appended to existing node or a new node is
1802              ## created is irrelevant, since the foster parent'ed nodes
1803              ## are discarded and fragment parsing does not invoke any
1804              ## script.
1805              !!!cp ('t200');
1806              $self->{open_elements}->[-1]->[0]->manakai_append_text ($s);
1807            }
1808          } # C
1809        } # TABLE_IMS
1810    
1811      if ($token->{type} == DOCTYPE_TOKEN) {      if ($token->{type} == DOCTYPE_TOKEN) {
1812        !!!cp ('t73');        !!!cp ('t73');
1813        !!!parse-error (type => 'DOCTYPE in the middle', token => $token);        !!!parse-error (type => 'in html:#DOCTYPE', token => $token);
1814        ## Ignore the token        ## Ignore the token
1815        ## Stay in the phase        ## Stay in the phase
1816        !!!next-token;        !!!next-token;
1817        redo B;        next B;
1818      } elsif ($token->{type} == START_TAG_TOKEN and      } elsif ($token->{type} == START_TAG_TOKEN and
1819               $token->{tag_name} eq 'html') {               $token->{tag_name} eq 'html') {
1820        if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {        if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
1821          !!!cp ('t79');          !!!cp ('t79');
1822          !!!parse-error (type => 'after html:html', token => $token);          !!!parse-error (type => 'after html', text => 'html', token => $token);
1823          $self->{insertion_mode} = AFTER_BODY_IM;          $self->{insertion_mode} = AFTER_BODY_IM;
1824        } elsif ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {        } elsif ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {
1825          !!!cp ('t80');          !!!cp ('t80');
1826          !!!parse-error (type => 'after html:html', token => $token);          !!!parse-error (type => 'after html', text => 'html', token => $token);
1827          $self->{insertion_mode} = AFTER_FRAMESET_IM;          $self->{insertion_mode} = AFTER_FRAMESET_IM;
1828        } else {        } else {
1829          !!!cp ('t81');          !!!cp ('t81');
# Line 3385  sub _tree_construction_main ($) { Line 1840  sub _tree_construction_main ($) {
1840               $token->{attributes}->{$attr_name}->{value});               $token->{attributes}->{$attr_name}->{value});
1841          }          }
1842        }        }
1843          !!!nack ('t84.1');
1844        !!!next-token;        !!!next-token;
1845        redo B;        next B;
1846      } elsif ($token->{type} == COMMENT_TOKEN) {      } elsif ($token->{type} == COMMENT_TOKEN) {
1847        my $comment = $self->{document}->create_comment ($token->{data});        my $comment = $self->{document}->create_comment ($token->{data});
1848        if ($self->{insertion_mode} & AFTER_HTML_IMS) {        if ($self->{insertion_mode} & AFTER_HTML_IMS) {
# Line 3398  sub _tree_construction_main ($) { Line 1854  sub _tree_construction_main ($) {
1854        } else {        } else {
1855          !!!cp ('t87');          !!!cp ('t87');
1856          $self->{open_elements}->[-1]->[0]->append_child ($comment);          $self->{open_elements}->[-1]->[0]->append_child ($comment);
1857            $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
1858        }        }
1859        !!!next-token;        !!!next-token;
1860        redo B;        next B;
1861      } elsif ($self->{insertion_mode} & HEAD_IMS) {      } elsif ($self->{insertion_mode} & IN_CDATA_RCDATA_IM) {
1862        if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == CHARACTER_TOKEN) {
1863          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          $token->{data} =~ s/^\x0A// if $self->{ignore_newline};
1864            delete $self->{ignore_newline};
1865    
1866            if (length $token->{data}) {
1867              !!!cp ('t43');
1868              $self->{open_elements}->[-1]->[0]->manakai_append_text
1869                  ($token->{data});
1870            } else {
1871              !!!cp ('t43.1');
1872            }
1873            !!!next-token;
1874            next B;
1875          } elsif ($token->{type} == END_TAG_TOKEN) {
1876            delete $self->{ignore_newline};
1877    
1878            if ($token->{tag_name} eq 'script') {
1879              !!!cp ('t50');
1880              
1881              ## Para 1-2
1882              my $script = pop @{$self->{open_elements}};
1883              
1884              ## Para 3
1885              $self->{insertion_mode} &= ~ IN_CDATA_RCDATA_IM;
1886    
1887              ## Para 4
1888              ## TODO: $old_insertion_point = $current_insertion_point;
1889              ## TODO: $current_insertion_point = just before $self->{nc};
1890    
1891              ## Para 5
1892              ## TODO: Run the $script->[0].
1893    
1894              ## Para 6
1895              ## TODO: $current_insertion_point = $old_insertion_point;
1896    
1897              ## Para 7
1898              ## TODO: if ($pending_external_script) {
1899                ## TODO: ...
1900              ## TODO: }
1901    
1902              !!!next-token;
1903              next B;
1904            } else {
1905              !!!cp ('t42');
1906    
1907              pop @{$self->{open_elements}};
1908    
1909              $self->{insertion_mode} &= ~ IN_CDATA_RCDATA_IM;
1910              !!!next-token;
1911              next B;
1912            }
1913          } elsif ($token->{type} == END_OF_FILE_TOKEN) {
1914            delete $self->{ignore_newline};
1915    
1916            !!!cp ('t44');
1917            !!!parse-error (type => 'not closed',
1918                            text => $self->{open_elements}->[-1]->[0]
1919                                ->manakai_local_name,
1920                            token => $token);
1921    
1922            #if ($self->{open_elements}->[-1]->[1] == SCRIPT_EL) {
1923            #  ## TODO: Mark as "already executed"
1924            #}
1925    
1926            pop @{$self->{open_elements}};
1927    
1928            $self->{insertion_mode} &= ~ IN_CDATA_RCDATA_IM;
1929            ## Reprocess.
1930            next B;
1931          } else {
1932            die "$0: $token->{type}: In CDATA/RCDATA: Unknown token type";        
1933          }
1934        } elsif ($self->{insertion_mode} & IN_FOREIGN_CONTENT_IM) {
1935          if ($token->{type} == CHARACTER_TOKEN) {
1936            !!!cp ('t87.1');
1937    
1938            $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});
1939    
1940            if ($token->{data} =~ /[^\x09\x0A\x0C\x0D\x20]/) {
1941              delete $self->{frameset_ok};
1942            }
1943    
1944            !!!next-token;
1945            next B;
1946          } elsif ($token->{type} == START_TAG_TOKEN) {
1947            if ((not {mglyph => 1, malignmark => 1}->{$token->{tag_name}} and
1948                 $self->{open_elements}->[-1]->[1] & FOREIGN_FLOW_CONTENT_EL) or
1949                not ($self->{open_elements}->[-1]->[1] & FOREIGN_EL) or
1950                ($token->{tag_name} eq 'svg' and
1951                 $self->{open_elements}->[-1]->[1] == MML_AXML_EL)) {
1952              ## NOTE: "using the rules for secondary insertion mode"then"continue"
1953              !!!cp ('t87.2');
1954              #
1955            } elsif ({
1956                      b => 1, big => 1, blockquote => 1, body => 1, br => 1,
1957                      center => 1, code => 1, dd => 1, div => 1, dl => 1, dt => 1,
1958                      em => 1, embed => 1, h1 => 1, h2 => 1, h3 => 1,
1959                      h4 => 1, h5 => 1, h6 => 1, head => 1, hr => 1, i => 1,
1960                      img => 1, li => 1, listing => 1, menu => 1, meta => 1,
1961                      nobr => 1, ol => 1, p => 1, pre => 1, ruby => 1, s => 1,
1962                      small => 1, span => 1, strong => 1, strike => 1, sub => 1,
1963                      sup => 1, table => 1, tt => 1, u => 1, ul => 1, var => 1,
1964                     }->{$token->{tag_name}} or
1965                     ($token->{tag_name} eq 'font' and
1966                      ($token->{attributes}->{color} or
1967                       $token->{attributes}->{face} or
1968                       $token->{attributes}->{size}))) {
1969              !!!cp ('t87.2');
1970              !!!parse-error (type => 'not closed',
1971                              text => $self->{open_elements}->[-1]->[0]
1972                                  ->manakai_local_name,
1973                              token => $token);
1974    
1975              pop @{$self->{open_elements}}
1976                  while $self->{open_elements}->[-1]->[1] & FOREIGN_EL;
1977    
1978              $self->{insertion_mode} &= ~ IN_FOREIGN_CONTENT_IM;
1979              ## Reprocess.
1980              next B;
1981            } else {
1982              my $nsuri = $self->{open_elements}->[-1]->[0]->namespace_uri;
1983              my $tag_name = $token->{tag_name};
1984              if ($nsuri eq $SVG_NS) {
1985                $tag_name = {
1986                   altglyph => 'altGlyph',
1987                   altglyphdef => 'altGlyphDef',
1988                   altglyphitem => 'altGlyphItem',
1989                   animatecolor => 'animateColor',
1990                   animatemotion => 'animateMotion',
1991                   animatetransform => 'animateTransform',
1992                   clippath => 'clipPath',
1993                   feblend => 'feBlend',
1994                   fecolormatrix => 'feColorMatrix',
1995                   fecomponenttransfer => 'feComponentTransfer',
1996                   fecomposite => 'feComposite',
1997                   feconvolvematrix => 'feConvolveMatrix',
1998                   fediffuselighting => 'feDiffuseLighting',
1999                   fedisplacementmap => 'feDisplacementMap',
2000                   fedistantlight => 'feDistantLight',
2001                   feflood => 'feFlood',
2002                   fefunca => 'feFuncA',
2003                   fefuncb => 'feFuncB',
2004                   fefuncg => 'feFuncG',
2005                   fefuncr => 'feFuncR',
2006                   fegaussianblur => 'feGaussianBlur',
2007                   feimage => 'feImage',
2008                   femerge => 'feMerge',
2009                   femergenode => 'feMergeNode',
2010                   femorphology => 'feMorphology',
2011                   feoffset => 'feOffset',
2012                   fepointlight => 'fePointLight',
2013                   fespecularlighting => 'feSpecularLighting',
2014                   fespotlight => 'feSpotLight',
2015                   fetile => 'feTile',
2016                   feturbulence => 'feTurbulence',
2017                   foreignobject => 'foreignObject',
2018                   glyphref => 'glyphRef',
2019                   lineargradient => 'linearGradient',
2020                   radialgradient => 'radialGradient',
2021                   #solidcolor => 'solidColor', ## NOTE: Commented in spec (SVG1.2)
2022                   textpath => 'textPath',  
2023                }->{$tag_name} || $tag_name;
2024              }
2025    
2026              ## "adjust SVG attributes" (SVG only) - done in insert-element-f
2027    
2028              ## "adjust foreign attributes" - done in insert-element-f
2029    
2030              !!!insert-element-f ($nsuri, $tag_name, $token->{attributes}, $token);
2031    
2032              if ($self->{self_closing}) {
2033                pop @{$self->{open_elements}};
2034                !!!ack ('t87.3');
2035              } else {
2036                !!!cp ('t87.4');
2037              }
2038    
2039              !!!next-token;
2040              next B;
2041            }
2042          } elsif ($token->{type} == END_TAG_TOKEN) {
2043            ## NOTE: "using the rules for secondary insertion mode" then "continue"
2044            if ($token->{tag_name} eq 'script') {
2045              !!!cp ('t87.41');
2046              #
2047              ## XXXscript: Execute script here.
2048            } else {
2049              !!!cp ('t87.5');
2050              #
2051            }
2052          } elsif ($token->{type} == END_OF_FILE_TOKEN) {
2053            !!!cp ('t87.6');
2054            !!!parse-error (type => 'not closed',
2055                            text => $self->{open_elements}->[-1]->[0]
2056                                ->manakai_local_name,
2057                            token => $token);
2058    
2059            pop @{$self->{open_elements}}
2060                while $self->{open_elements}->[-1]->[1] & FOREIGN_EL;
2061    
2062            ## NOTE: |<span><svg>| ... two parse errors, |<svg>| ... a parse error.
2063    
2064            $self->{insertion_mode} &= ~ IN_FOREIGN_CONTENT_IM;
2065            ## Reprocess.
2066            next B;
2067          } else {
2068            die "$0: $token->{type}: Unknown token type";        
2069          }
2070        }
2071    
2072        if ($self->{insertion_mode} & HEAD_IMS) {
2073          if ($token->{type} == CHARACTER_TOKEN) {
2074            if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
2075            unless ($self->{insertion_mode} == BEFORE_HEAD_IM) {            unless ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2076              !!!cp ('t88.2');              if ($self->{head_element_inserted}) {
2077              $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);                !!!cp ('t88.3');
2078                  $self->{open_elements}->[-1]->[0]->append_child
2079                    ($self->{document}->create_text_node ($1));
2080                  delete $self->{head_element_inserted};
2081                  ## NOTE: |</head> <link> |
2082                  #
2083                } else {
2084                  !!!cp ('t88.2');
2085                  $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
2086                  ## NOTE: |</head> &#x20;|
2087                  #
2088                }
2089            } else {            } else {
2090              !!!cp ('t88.1');              !!!cp ('t88.1');
2091              ## Ignore the token.              ## Ignore the token.
2092              !!!next-token;              #
             redo B;  
2093            }            }
2094            unless (length $token->{data}) {            unless (length $token->{data}) {
2095              !!!cp ('t88');              !!!cp ('t88');
2096              !!!next-token;              !!!next-token;
2097              redo B;              next B;
2098            }            }
2099    ## TODO: set $token->{column} appropriately
2100          }          }
2101    
2102          if ($self->{insertion_mode} == BEFORE_HEAD_IM) {          if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2103            !!!cp ('t89');            !!!cp ('t89');
2104            ## As if <head>            ## As if <head>
2105            !!!create-element ($self->{head_element}, 'head',, $token);            !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token);
2106            $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});            $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2107            push @{$self->{open_elements}}, [$self->{head_element}, 'head'];            push @{$self->{open_elements}},
2108                  [$self->{head_element}, $el_category->{head}];
2109    
2110            ## Reprocess in the "in head" insertion mode...            ## Reprocess in the "in head" insertion mode...
2111            pop @{$self->{open_elements}};            pop @{$self->{open_elements}};
# Line 3435  sub _tree_construction_main ($) { Line 2115  sub _tree_construction_main ($) {
2115            !!!cp ('t90');            !!!cp ('t90');
2116            ## As if </noscript>            ## As if </noscript>
2117            pop @{$self->{open_elements}};            pop @{$self->{open_elements}};
2118            !!!parse-error (type => 'in noscript:#character', token => $token);            !!!parse-error (type => 'in noscript:#text', token => $token);
2119                        
2120            ## Reprocess in the "in head" insertion mode...            ## Reprocess in the "in head" insertion mode...
2121            ## As if </head>            ## As if </head>
# Line 3451  sub _tree_construction_main ($) { Line 2131  sub _tree_construction_main ($) {
2131            !!!cp ('t92');            !!!cp ('t92');
2132          }          }
2133    
2134              ## "after head" insertion mode          ## "after head" insertion mode
2135              ## As if <body>          ## As if <body>
2136              !!!insert-element ('body',, $token);          !!!insert-element ('body',, $token);
2137              $self->{insertion_mode} = IN_BODY_IM;          $self->{insertion_mode} = IN_BODY_IM;
2138              ## reprocess          ## The "frameset-ok" flag is left unchanged in this case.
2139              redo B;          ## Reporcess the token.
2140            } elsif ($token->{type} == START_TAG_TOKEN) {          next B;
2141              if ($token->{tag_name} eq 'head') {        } elsif ($token->{type} == START_TAG_TOKEN) {
2142                if ($self->{insertion_mode} == BEFORE_HEAD_IM) {          if ($token->{tag_name} eq 'head') {
2143                  !!!cp ('t93');            if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2144                  !!!create-element ($self->{head_element}, $token->{tag_name}, $token->{attributes}, $token);              !!!cp ('t93');
2145                  $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});              !!!create-element ($self->{head_element}, $HTML_NS, $token->{tag_name}, $token->{attributes}, $token);
2146                  push @{$self->{open_elements}}, [$self->{head_element}, $token->{tag_name}];              $self->{open_elements}->[-1]->[0]->append_child
2147                  $self->{insertion_mode} = IN_HEAD_IM;                  ($self->{head_element});
2148                  !!!next-token;              push @{$self->{open_elements}},
2149                  redo B;                  [$self->{head_element}, $el_category->{head}];
2150                } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {              $self->{insertion_mode} = IN_HEAD_IM;
2151                  !!!cp ('t94');              !!!nack ('t93.1');
2152                  #              !!!next-token;
2153                } else {              next B;
2154                  !!!cp ('t95');            } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2155                  !!!parse-error (type => 'in head:head', token => $token); # or in head noscript              !!!cp ('t93.2');
2156                  ## Ignore the token              !!!parse-error (type => 'after head', text => 'head',
2157                  !!!next-token;                              token => $token);
2158                  redo B;              ## Ignore the token
2159                }              !!!nack ('t93.3');
2160              } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {              !!!next-token;
2161                !!!cp ('t96');              next B;
2162                ## As if <head>            } else {
2163                !!!create-element ($self->{head_element}, 'head',, $token);              !!!cp ('t95');
2164                $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});              !!!parse-error (type => 'in head:head',
2165                push @{$self->{open_elements}}, [$self->{head_element}, 'head'];                              token => $token); # or in head noscript
2166                ## Ignore the token
2167                !!!nack ('t95.1');
2168                !!!next-token;
2169                next B;
2170              }
2171            } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2172              !!!cp ('t96');
2173              ## As if <head>
2174              !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token);
2175              $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2176              push @{$self->{open_elements}},
2177                  [$self->{head_element}, $el_category->{head}];
2178    
2179                $self->{insertion_mode} = IN_HEAD_IM;            $self->{insertion_mode} = IN_HEAD_IM;
2180                ## Reprocess in the "in head" insertion mode...            ## Reprocess in the "in head" insertion mode...
2181              } else {          } else {
2182                !!!cp ('t97');            !!!cp ('t97');
2183              }          }
2184    
2185              if ($token->{tag_name} eq 'base') {          if ($token->{tag_name} eq 'base') {
2186                if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {            if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2187                  !!!cp ('t98');              !!!cp ('t98');
2188                  ## As if </noscript>              ## As if </noscript>
2189                  pop @{$self->{open_elements}};              pop @{$self->{open_elements}};
2190                  !!!parse-error (type => 'in noscript:base', token => $token);              !!!parse-error (type => 'in noscript', text => 'base',
2191                                              token => $token);
2192                  $self->{insertion_mode} = IN_HEAD_IM;            
2193                  ## Reprocess in the "in head" insertion mode...              $self->{insertion_mode} = IN_HEAD_IM;
2194                } else {              ## Reprocess in the "in head" insertion mode...
2195                  !!!cp ('t99');            } else {
2196                }              !!!cp ('t99');
2197              }
2198    
2199                ## NOTE: There is a "as if in head" code clone.            ## NOTE: There is a "as if in head" code clone.
2200                if ($self->{insertion_mode} == AFTER_HEAD_IM) {            if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2201                  !!!cp ('t100');              !!!cp ('t100');
2202                  !!!parse-error (type => 'after head:'.$token->{tag_name}, token => $token);              !!!parse-error (type => 'after head',
2203                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];                              text => $token->{tag_name}, token => $token);
2204                } else {              push @{$self->{open_elements}},
2205                  !!!cp ('t101');                  [$self->{head_element}, $el_category->{head}];
2206                }              $self->{head_element_inserted} = 1;
2207                !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);            } else {
2208                pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.              !!!cp ('t101');
2209                pop @{$self->{open_elements}} # <head>            }
2210                    if $self->{insertion_mode} == AFTER_HEAD_IM;            !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
2211                !!!next-token;            pop @{$self->{open_elements}};
2212                redo B;            pop @{$self->{open_elements}} # <head>
2213              } elsif ($token->{tag_name} eq 'link') {                if $self->{insertion_mode} == AFTER_HEAD_IM;
2214                ## NOTE: There is a "as if in head" code clone.            !!!nack ('t101.1');
2215                if ($self->{insertion_mode} == AFTER_HEAD_IM) {            !!!next-token;
2216                  !!!cp ('t102');            next B;
2217                  !!!parse-error (type => 'after head:'.$token->{tag_name}, token => $token);          } elsif ($token->{tag_name} eq 'link') {
2218                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];            ## NOTE: There is a "as if in head" code clone.
2219                } else {            if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2220                  !!!cp ('t103');              !!!cp ('t102');
2221                }              !!!parse-error (type => 'after head',
2222                !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);                              text => $token->{tag_name}, token => $token);
2223                pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.              push @{$self->{open_elements}},
2224                pop @{$self->{open_elements}} # <head>                  [$self->{head_element}, $el_category->{head}];
2225                    if $self->{insertion_mode} == AFTER_HEAD_IM;              $self->{head_element_inserted} = 1;
2226                !!!next-token;            } else {
2227                redo B;              !!!cp ('t103');
2228              } elsif ($token->{tag_name} eq 'meta') {            }
2229                ## NOTE: There is a "as if in head" code clone.            !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
2230                if ($self->{insertion_mode} == AFTER_HEAD_IM) {            pop @{$self->{open_elements}};
2231                  !!!cp ('t104');            pop @{$self->{open_elements}} # <head>
2232                  !!!parse-error (type => 'after head:'.$token->{tag_name}, token => $token);                if $self->{insertion_mode} == AFTER_HEAD_IM;
2233                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];            !!!ack ('t103.1');
2234                } else {            !!!next-token;
2235                  !!!cp ('t105');            next B;
2236                }          } elsif ($token->{tag_name} eq 'command') {
2237                !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);            if ($self->{insertion_mode} == IN_HEAD_IM) {
2238                my $meta_el = pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.              ## NOTE: If the insertion mode at the time of the emission
2239                ## of the token was "before head", $self->{insertion_mode}
2240                ## is already changed to |IN_HEAD_IM|.
2241    
2242                ## NOTE: There is a "as if in head" code clone.
2243                !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
2244                pop @{$self->{open_elements}};
2245                pop @{$self->{open_elements}} # <head>
2246                    if $self->{insertion_mode} == AFTER_HEAD_IM;
2247                !!!ack ('t103.2');
2248                !!!next-token;
2249                next B;
2250              } else {
2251                ## NOTE: "in head noscript" or "after head" insertion mode
2252                ## - in these cases, these tags are treated as same as
2253                ## normal in-body tags.
2254                !!!cp ('t103.3');
2255                #
2256              }
2257            } elsif ($token->{tag_name} eq 'meta') {
2258              ## NOTE: There is a "as if in head" code clone.
2259              if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2260                !!!cp ('t104');
2261                !!!parse-error (type => 'after head',
2262                                text => $token->{tag_name}, token => $token);
2263                push @{$self->{open_elements}},
2264                    [$self->{head_element}, $el_category->{head}];
2265                $self->{head_element_inserted} = 1;
2266              } else {
2267                !!!cp ('t105');
2268              }
2269              !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
2270              my $meta_el = pop @{$self->{open_elements}};
2271    
2272                unless ($self->{confident}) {                unless ($self->{confident}) {
2273                  if ($token->{attributes}->{charset}) { ## TODO: And if supported                  if ($token->{attributes}->{charset}) {
2274                    !!!cp ('t106');                    !!!cp ('t106');
2275                      ## NOTE: Whether the encoding is supported or not is handled
2276                      ## in the {change_encoding} callback.
2277                    $self->{change_encoding}                    $self->{change_encoding}
2278                        ->($self, $token->{attributes}->{charset}->{value},                        ->($self, $token->{attributes}->{charset}->{value},
2279                           $token);                           $token);
# Line 3556  sub _tree_construction_main ($) { Line 2283  sub _tree_construction_main ($) {
2283                                             $token->{attributes}->{charset}                                             $token->{attributes}->{charset}
2284                                                 ->{has_reference});                                                 ->{has_reference});
2285                  } elsif ($token->{attributes}->{content}) {                  } elsif ($token->{attributes}->{content}) {
                   ## ISSUE: Algorithm name in the spec was incorrect so that not linked to the definition.  
2286                    if ($token->{attributes}->{content}->{value}                    if ($token->{attributes}->{content}->{value}
2287                        =~ /\A[^;]*;[\x09-\x0D\x20]*[Cc][Hh][Aa][Rr][Ss][Ee][Tt]                        =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt]
2288                            [\x09-\x0D\x20]*=                            [\x09\x0A\x0C\x0D\x20]*=
2289                            [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'|                            [\x09\x0A\x0C\x0D\x20]*(?>"([^"]*)"|'([^']*)'|
2290                            ([^"'\x09-\x0D\x20][^\x09-\x0D\x20]*))/x) {                            ([^"'\x09\x0A\x0C\x0D\x20]
2291                               [^\x09\x0A\x0C\x0D\x20\x3B]*))/x) {
2292                      !!!cp ('t107');                      !!!cp ('t107');
2293                        ## NOTE: Whether the encoding is supported or not is handled
2294                        ## in the {change_encoding} callback.
2295                      $self->{change_encoding}                      $self->{change_encoding}
2296                          ->($self, defined $1 ? $1 : defined $2 ? $2 : $3,                          ->($self, defined $1 ? $1 : defined $2 ? $2 : $3,
2297                             $token);                             $token);
# Line 3593  sub _tree_construction_main ($) { Line 2322  sub _tree_construction_main ($) {
2322    
2323                pop @{$self->{open_elements}} # <head>                pop @{$self->{open_elements}} # <head>
2324                    if $self->{insertion_mode} == AFTER_HEAD_IM;                    if $self->{insertion_mode} == AFTER_HEAD_IM;
2325                  !!!ack ('t110.1');
2326                !!!next-token;                !!!next-token;
2327                redo B;                next B;
2328              } elsif ($token->{tag_name} eq 'title') {          } elsif ($token->{tag_name} eq 'title') {
2329                if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {            if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2330                  !!!cp ('t111');              !!!cp ('t111');
2331                  ## As if </noscript>              ## As if </noscript>
2332                  pop @{$self->{open_elements}};              pop @{$self->{open_elements}};
2333                  !!!parse-error (type => 'in noscript:title', token => $token);              !!!parse-error (type => 'in noscript', text => 'title',
2334                                              token => $token);
2335                  $self->{insertion_mode} = IN_HEAD_IM;            
2336                  ## Reprocess in the "in head" insertion mode...              $self->{insertion_mode} = IN_HEAD_IM;
2337                } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {              ## Reprocess in the "in head" insertion mode...
2338                  !!!cp ('t112');            } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2339                  !!!parse-error (type => 'after head:'.$token->{tag_name}, token => $token);              !!!cp ('t112');
2340                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];              !!!parse-error (type => 'after head',
2341                } else {                              text => $token->{tag_name}, token => $token);
2342                  !!!cp ('t113');              push @{$self->{open_elements}},
2343                }                  [$self->{head_element}, $el_category->{head}];
2344                $self->{head_element_inserted} = 1;
2345                ## NOTE: There is a "as if in head" code clone.            } else {
2346                my $parent = defined $self->{head_element} ? $self->{head_element}              !!!cp ('t113');
2347                    : $self->{open_elements}->[-1]->[0];            }
2348                $parse_rcdata->(RCDATA_CONTENT_MODEL);  
2349                pop @{$self->{open_elements}} # <head>            ## NOTE: There is a "as if in head" code clone.
2350                    if $self->{insertion_mode} == AFTER_HEAD_IM;            $parse_rcdata->(RCDATA_CONTENT_MODEL);
2351                redo B;  
2352              } elsif ($token->{tag_name} eq 'style') {            ## NOTE: At this point the stack of open elements contain
2353                ## NOTE: Or (scripting is enabled and tag_name eq 'noscript' and            ## the |head| element (index == -2) and the |script| element
2354                ## insertion mode IN_HEAD_IM)            ## (index == -1).  In the "after head" insertion mode the
2355                ## NOTE: There is a "as if in head" code clone.            ## |head| element is inserted only for the purpose of
2356                if ($self->{insertion_mode} == AFTER_HEAD_IM) {            ## providing the context for the |script| element, and
2357                  !!!cp ('t114');            ## therefore we can now and have to remove the element from
2358                  !!!parse-error (type => 'after head:'.$token->{tag_name}, token => $token);            ## the stack.
2359                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];            splice @{$self->{open_elements}}, -2, 1, () # <head>
2360                } else {                if ($self->{insertion_mode} & IM_MASK) == AFTER_HEAD_IM;
2361                  !!!cp ('t115');            next B;
2362                }          } elsif ($token->{tag_name} eq 'style' or
2363                $parse_rcdata->(CDATA_CONTENT_MODEL);                   $token->{tag_name} eq 'noframes') {
2364                pop @{$self->{open_elements}} # <head>            ## NOTE: Or (scripting is enabled and tag_name eq 'noscript' and
2365                    if $self->{insertion_mode} == AFTER_HEAD_IM;            ## insertion mode IN_HEAD_IM)
2366                redo B;            ## NOTE: There is a "as if in head" code clone.
2367              } elsif ($token->{tag_name} eq 'noscript') {            if ($self->{insertion_mode} == AFTER_HEAD_IM) {
2368                !!!cp ('t114');
2369                !!!parse-error (type => 'after head',
2370                                text => $token->{tag_name}, token => $token);
2371                push @{$self->{open_elements}},
2372                    [$self->{head_element}, $el_category->{head}];
2373                $self->{head_element_inserted} = 1;
2374              } else {
2375                !!!cp ('t115');
2376              }
2377              $parse_rcdata->(CDATA_CONTENT_MODEL);
2378              ## ISSUE: A spec bug [Bug 6038]
2379              splice @{$self->{open_elements}}, -2, 1, () # <head>
2380                  if ($self->{insertion_mode} & IM_MASK) == AFTER_HEAD_IM;
2381              next B;
2382            } elsif ($token->{tag_name} eq 'noscript') {
2383                if ($self->{insertion_mode} == IN_HEAD_IM) {                if ($self->{insertion_mode} == IN_HEAD_IM) {
2384                  !!!cp ('t116');                  !!!cp ('t116');
2385                  ## NOTE: and scripting is disalbed                  ## NOTE: and scripting is disalbed
2386                  !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);                  !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
2387                  $self->{insertion_mode} = IN_HEAD_NOSCRIPT_IM;                  $self->{insertion_mode} = IN_HEAD_NOSCRIPT_IM;
2388                    !!!nack ('t116.1');
2389                  !!!next-token;                  !!!next-token;
2390                  redo B;                  next B;
2391                } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {                } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2392                  !!!cp ('t117');                  !!!cp ('t117');
2393                  !!!parse-error (type => 'in noscript:noscript', token => $token);                  !!!parse-error (type => 'in noscript', text => 'noscript',
2394                                    token => $token);
2395                  ## Ignore the token                  ## Ignore the token
2396                    !!!nack ('t117.1');
2397                  !!!next-token;                  !!!next-token;
2398                  redo B;                  next B;
2399                } else {                } else {
2400                  !!!cp ('t118');                  !!!cp ('t118');
2401                  #                  #
2402                }                }
2403              } elsif ($token->{tag_name} eq 'script') {          } elsif ($token->{tag_name} eq 'script') {
2404                if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {            if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2405                  !!!cp ('t119');              !!!cp ('t119');
2406                  ## As if </noscript>              ## As if </noscript>
2407                  pop @{$self->{open_elements}};              pop @{$self->{open_elements}};
2408                  !!!parse-error (type => 'in noscript:script', token => $token);              !!!parse-error (type => 'in noscript', text => 'script',
2409                                              token => $token);
2410                  $self->{insertion_mode} = IN_HEAD_IM;            
2411                  ## Reprocess in the "in head" insertion mode...              $self->{insertion_mode} = IN_HEAD_IM;
2412                } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {              ## Reprocess in the "in head" insertion mode...
2413                  !!!cp ('t120');            } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2414                  !!!parse-error (type => 'after head:'.$token->{tag_name}, token => $token);              !!!cp ('t120');
2415                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];              !!!parse-error (type => 'after head',
2416                } else {                              text => $token->{tag_name}, token => $token);
2417                  !!!cp ('t121');              push @{$self->{open_elements}},
2418                }                  [$self->{head_element}, $el_category->{head}];
2419                $self->{head_element_inserted} = 1;
2420                ## NOTE: There is a "as if in head" code clone.            } else {
2421                $script_start_tag->();              !!!cp ('t121');
2422                pop @{$self->{open_elements}} # <head>            }
2423                    if $self->{insertion_mode} == AFTER_HEAD_IM;  
2424                redo B;            ## NOTE: There is a "as if in head" code clone.
2425              } elsif ($token->{tag_name} eq 'body' or            $script_start_tag->();
2426                       $token->{tag_name} eq 'frameset') {            ## ISSUE: A spec bug  [Bug 6038]
2427                if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {            splice @{$self->{open_elements}}, -2, 1 # <head>
2428                  !!!cp ('t122');                if ($self->{insertion_mode} & IM_MASK) == AFTER_HEAD_IM;
2429                  ## As if </noscript>            next B;
2430                  pop @{$self->{open_elements}};          } elsif ($token->{tag_name} eq 'body' or
2431                  !!!parse-error (type => 'in noscript:'.$token->{tag_name}, token => $token);                   $token->{tag_name} eq 'frameset') {
2432                              if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2433                  ## Reprocess in the "in head" insertion mode...              !!!cp ('t122');
2434                  ## As if </head>              ## As if </noscript>
2435                  pop @{$self->{open_elements}};              pop @{$self->{open_elements}};
2436                                !!!parse-error (type => 'in noscript',
2437                  ## Reprocess in the "after head" insertion mode...                              text => $token->{tag_name}, token => $token);
2438                } elsif ($self->{insertion_mode} == IN_HEAD_IM) {              
2439                  !!!cp ('t124');              ## Reprocess in the "in head" insertion mode...
2440                  pop @{$self->{open_elements}};              ## As if </head>
2441                                pop @{$self->{open_elements}};
2442                  ## Reprocess in the "after head" insertion mode...              
2443                } else {              ## Reprocess in the "after head" insertion mode...
2444                  !!!cp ('t125');            } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2445                }              !!!cp ('t124');
2446                pop @{$self->{open_elements}};
2447                
2448                ## Reprocess in the "after head" insertion mode...
2449              } else {
2450                !!!cp ('t125');
2451              }
2452    
2453                ## "after head" insertion mode            ## "after head" insertion mode
2454                !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);            !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
2455                if ($token->{tag_name} eq 'body') {            if ($token->{tag_name} eq 'body') {
2456                  !!!cp ('t126');              !!!cp ('t126');
2457                  $self->{insertion_mode} = IN_BODY_IM;              delete $self->{frameset_ok};
2458                } elsif ($token->{tag_name} eq 'frameset') {              $self->{insertion_mode} = IN_BODY_IM;
2459                  !!!cp ('t127');            } elsif ($token->{tag_name} eq 'frameset') {
2460                  $self->{insertion_mode} = IN_FRAMESET_IM;              !!!cp ('t127');
2461                } else {              $self->{insertion_mode} = IN_FRAMESET_IM;
2462                  die "$0: tag name: $self->{tag_name}";            } else {
2463                }              die "$0: tag name: $self->{tag_name}";
2464                !!!next-token;            }
2465                redo B;            !!!nack ('t127.1');
2466              } else {            !!!next-token;
2467                !!!cp ('t128');            next B;
2468                #          } else {
2469              }            !!!cp ('t128');
2470              #
2471            }
2472    
2473              if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {              if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2474                !!!cp ('t129');                !!!cp ('t129');
2475                ## As if </noscript>                ## As if </noscript>
2476                pop @{$self->{open_elements}};                pop @{$self->{open_elements}};
2477                !!!parse-error (type => 'in noscript:/'.$token->{tag_name}, token => $token);                !!!parse-error (type => 'in noscript:/',
2478                                  text => $token->{tag_name}, token => $token);
2479                                
2480                ## Reprocess in the "in head" insertion mode...                ## Reprocess in the "in head" insertion mode...
2481                ## As if </head>                ## As if </head>
# Line 3735  sub _tree_construction_main ($) { Line 2492  sub _tree_construction_main ($) {
2492                !!!cp ('t131');                !!!cp ('t131');
2493              }              }
2494    
2495              ## "after head" insertion mode          ## "after head" insertion mode
2496              ## As if <body>          ## As if <body>
2497              !!!insert-element ('body',, $token);          !!!insert-element ('body',, $token);
2498              $self->{insertion_mode} = IN_BODY_IM;          $self->{insertion_mode} = IN_BODY_IM;
2499              ## reprocess          ## The "frameset-ok" flag is not changed in this case.
2500              redo B;          ## Reprocess the token.
2501            } elsif ($token->{type} == END_TAG_TOKEN) {          !!!ack-later;
2502              if ($token->{tag_name} eq 'head') {          next B;
2503                if ($self->{insertion_mode} == BEFORE_HEAD_IM) {        } elsif ($token->{type} == END_TAG_TOKEN) {
2504                  !!!cp ('t132');          ## "Before head", "in head", and "after head" insertion modes
2505                  ## As if <head>          ## ignore most of end tags.  Exceptions are "body", "html",
2506                  !!!create-element ($self->{head_element}, 'head',, $token);          ## and "br" end tags.  "Before head" and "in head" insertion
2507                  $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});          ## modes also recognize "head" end tag.  "In head noscript"
2508                  push @{$self->{open_elements}}, [$self->{head_element}, 'head'];          ## insertion modes ignore end tags except for "noscript" and
2509            ## "br".
2510                  ## Reprocess in the "in head" insertion mode...  
2511                  pop @{$self->{open_elements}};          if ($token->{tag_name} eq 'head') {
2512                  $self->{insertion_mode} = AFTER_HEAD_IM;            if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2513                  !!!next-token;              !!!cp ('t132');
2514                  redo B;              ## As if <head>
2515                } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {              !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token);
2516                  !!!cp ('t133');              $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2517                  ## As if </noscript>              push @{$self->{open_elements}},
2518                  pop @{$self->{open_elements}};                  [$self->{head_element}, $el_category->{head}];
                 !!!parse-error (type => 'in noscript:/head', token => $token);  
                   
                 ## Reprocess in the "in head" insertion mode...  
                 pop @{$self->{open_elements}};  
                 $self->{insertion_mode} = AFTER_HEAD_IM;  
                 !!!next-token;  
                 redo B;  
               } elsif ($self->{insertion_mode} == IN_HEAD_IM) {  
                 !!!cp ('t134');  
                 pop @{$self->{open_elements}};  
                 $self->{insertion_mode} = AFTER_HEAD_IM;  
                 !!!next-token;  
                 redo B;  
               } else {  
                 !!!cp ('t135');  
                 #  
               }  
             } elsif ($token->{tag_name} eq 'noscript') {  
               if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {  
                 !!!cp ('t136');  
                 pop @{$self->{open_elements}};  
                 $self->{insertion_mode} = IN_HEAD_IM;  
                 !!!next-token;  
                 redo B;  
               } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {  
                 !!!cp ('t137');  
                 !!!parse-error (type => 'unmatched end tag:noscript', token => $token);  
                 ## Ignore the token ## ISSUE: An issue in the spec.  
                 !!!next-token;  
                 redo B;  
               } else {  
                 !!!cp ('t138');  
                 #  
               }  
             } elsif ({  
                       body => 1, html => 1,  
                      }->{$token->{tag_name}}) {  
               if ($self->{insertion_mode} == BEFORE_HEAD_IM) {  
                 !!!cp ('t139');  
                 ## As if <head>  
                 !!!create-element ($self->{head_element}, 'head',, $token);  
                 $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});  
                 push @{$self->{open_elements}}, [$self->{head_element}, 'head'];  
   
                 $self->{insertion_mode} = IN_HEAD_IM;  
                 ## Reprocess in the "in head" insertion mode...  
               } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {  
                 !!!cp ('t140');  
                 !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);  
                 ## Ignore the token  
                 !!!next-token;  
                 redo B;  
               } else {  
                 !!!cp ('t141');  
               }  
                 
               #  
             } elsif ({  
                       p => 1, br => 1,  
                      }->{$token->{tag_name}}) {  
               if ($self->{insertion_mode} == BEFORE_HEAD_IM) {  
                 !!!cp ('t142');  
                 ## As if <head>  
                 !!!create-element ($self->{head_element}, 'head',, $token);  
                 $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});  
                 push @{$self->{open_elements}}, [$self->{head_element}, 'head'];  
   
                 $self->{insertion_mode} = IN_HEAD_IM;  
                 ## Reprocess in the "in head" insertion mode...  
               } else {  
                 !!!cp ('t143');  
               }  
2519    
2520                #              ## Reprocess in the "in head" insertion mode...
2521              } else {              pop @{$self->{open_elements}};
2522                if ($self->{insertion_mode} == AFTER_HEAD_IM) {              $self->{insertion_mode} = AFTER_HEAD_IM;
2523                  !!!cp ('t144');              !!!next-token;
2524                  #              next B;
2525                } else {            } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2526                  !!!cp ('t145');              !!!cp ('t133');
2527                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);              #
2528                  ## Ignore the token            } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2529                  !!!next-token;              !!!cp ('t134');
2530                  redo B;              pop @{$self->{open_elements}};
2531                }              $self->{insertion_mode} = AFTER_HEAD_IM;
2532              }              !!!next-token;
2533                next B;
2534              } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2535                !!!cp ('t134.1');
2536                #
2537              } else {
2538                die "$0: $self->{insertion_mode}: Unknown insertion mode";
2539              }
2540            } elsif ($token->{tag_name} eq 'noscript') {
2541              if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2542                !!!cp ('t136');
2543                pop @{$self->{open_elements}};
2544                $self->{insertion_mode} = IN_HEAD_IM;
2545                !!!next-token;
2546                next B;
2547              } else {
2548                !!!cp ('t138');
2549                #
2550              }
2551            } elsif ({
2552                body => ($self->{insertion_mode} != IN_HEAD_NOSCRIPT_IM),
2553                html => ($self->{insertion_mode} != IN_HEAD_NOSCRIPT_IM),
2554                br => 1,
2555            }->{$token->{tag_name}}) {
2556              if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2557                !!!cp ('t142.2');
2558                ## (before head) as if <head>, (in head) as if </head>
2559                !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token);
2560                $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element});
2561                $self->{insertion_mode} = AFTER_HEAD_IM;
2562      
2563                ## Reprocess in the "after head" insertion mode...
2564              } elsif ($self->{insertion_mode} == IN_HEAD_IM) {
2565                !!!cp ('t143.2');
2566                ## As if </head>
2567                pop @{$self->{open_elements}};
2568                $self->{insertion_mode} = AFTER_HEAD_IM;
2569      
2570                ## Reprocess in the "after head" insertion mode...
2571              } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {
2572                !!!cp ('t143.3');
2573                ## NOTE: Two parse errors for <head><noscript></br>
2574                !!!parse-error (type => 'unmatched end tag',
2575                                text => $token->{tag_name}, token => $token);
2576                ## As if </noscript>
2577                pop @{$self->{open_elements}};
2578                $self->{insertion_mode} = IN_HEAD_IM;
2579    
2580              if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) {              ## Reprocess in the "in head" insertion mode...
2581                !!!cp ('t146');              ## As if </head>
2582                ## As if </noscript>              pop @{$self->{open_elements}};
2583                pop @{$self->{open_elements}};              $self->{insertion_mode} = AFTER_HEAD_IM;
               !!!parse-error (type => 'in noscript:/'.$token->{tag_name}, token => $token);  
                 
               ## Reprocess in the "in head" insertion mode...  
               ## As if </head>  
               pop @{$self->{open_elements}};  
2584    
2585                ## Reprocess in the "after head" insertion mode...              ## Reprocess in the "after head" insertion mode...
2586              } elsif ($self->{insertion_mode} == IN_HEAD_IM) {            } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) {
2587                !!!cp ('t147');              !!!cp ('t143.4');
2588                ## As if </head>              #
2589                pop @{$self->{open_elements}};            } else {
2590                die "$0: $self->{insertion_mode}: Unknown insertion mode";
2591              }
2592    
2593                ## Reprocess in the "after head" insertion mode...            ## "after head" insertion mode
2594              } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) {            ## As if <body>
2595  ## ISSUE: This case cannot be reached?            !!!insert-element ('body',, $token);
2596                !!!cp ('t148');            $self->{insertion_mode} = IN_BODY_IM;
2597                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);            ## The "frameset-ok" flag is left unchanged in this case.
2598                ## Ignore the token ## ISSUE: An issue in the spec.            ## Reprocess the token.
2599                !!!next-token;            next B;
2600                redo B;          }
             } else {  
               !!!cp ('t149');  
             }  
2601    
2602              ## "after head" insertion mode          ## End tags are ignored by default.
2603              ## As if <body>          !!!cp ('t145');
2604              !!!insert-element ('body',, $token);          !!!parse-error (type => 'unmatched end tag',
2605              $self->{insertion_mode} = IN_BODY_IM;                          text => $token->{tag_name}, token => $token);
2606              ## reprocess          ## Ignore the token.
2607              redo B;          !!!next-token;
2608            next B;
2609        } elsif ($token->{type} == END_OF_FILE_TOKEN) {        } elsif ($token->{type} == END_OF_FILE_TOKEN) {
2610          if ($self->{insertion_mode} == BEFORE_HEAD_IM) {          if ($self->{insertion_mode} == BEFORE_HEAD_IM) {
2611            !!!cp ('t149.1');            !!!cp ('t149.1');
2612    
2613            ## NOTE: As if <head>            ## NOTE: As if <head>
2614            !!!create-element ($self->{head_element}, 'head',, $token);            !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token);
2615            $self->{open_elements}->[-1]->[0]->append_child            $self->{open_elements}->[-1]->[0]->append_child
2616                ($self->{head_element});                ($self->{head_element});
2617            #push @{$self->{open_elements}}, [$self->{head_element}, 'head'];            #push @{$self->{open_elements}},
2618              #    [$self->{head_element}, $el_category->{head}];
2619            #$self->{insertion_mode} = IN_HEAD_IM;            #$self->{insertion_mode} = IN_HEAD_IM;
2620            ## NOTE: Reprocess.            ## NOTE: Reprocess.
2621    
# Line 3931  sub _tree_construction_main ($) { Line 2658  sub _tree_construction_main ($) {
2658          ## NOTE: As if <body>          ## NOTE: As if <body>
2659          !!!insert-element ('body',, $token);          !!!insert-element ('body',, $token);
2660          $self->{insertion_mode} = IN_BODY_IM;          $self->{insertion_mode} = IN_BODY_IM;
2661          ## NOTE: Reprocess.          ## The "frameset-ok" flag is left unchanged in this case.
2662          redo B;          ## Reprocess the token.
2663            next B;
2664        } else {        } else {
2665          die "$0: $token->{type}: Unknown token type";          die "$0: $token->{type}: Unknown token type";
2666        }        }
   
           ## ISSUE: An issue in the spec.  
2667      } elsif ($self->{insertion_mode} & BODY_IMS) {      } elsif ($self->{insertion_mode} & BODY_IMS) {
2668            if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == CHARACTER_TOKEN) {
2669              !!!cp ('t150');          !!!cp ('t150');
2670              ## NOTE: There is a code clone of "character in body".          $reconstruct_active_formatting_elements->($insert_to_current);
2671              $reconstruct_active_formatting_elements->($insert_to_current);          
2672                        $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});
             $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});  
2673    
2674              !!!next-token;          if ($token->{data} =~ /[^\x09\x0A\x0C\x0D\x20]/) {
2675              redo B;            delete $self->{frameset_ok};
2676            } elsif ($token->{type} == START_TAG_TOKEN) {          }
2677    
2678            !!!next-token;
2679            next B;
2680          } elsif ($token->{type} == START_TAG_TOKEN) {
2681              if ({              if ({
2682                   caption => 1, col => 1, colgroup => 1, tbody => 1,                   caption => 1, col => 1, colgroup => 1, tbody => 1,
2683                   td => 1, tfoot => 1, th => 1, thead => 1, tr => 1,                   td => 1, tfoot => 1, th => 1, thead => 1, tr => 1,
2684                  }->{$token->{tag_name}}) {                  }->{$token->{tag_name}}) {
2685                if ($self->{insertion_mode} == IN_CELL_IM) {                if (($self->{insertion_mode} & IM_MASK) == IN_CELL_IM) {
2686                  ## have an element in table scope                  ## have an element in table scope
2687                  for (reverse 0..$#{$self->{open_elements}}) {                  for (reverse 0..$#{$self->{open_elements}}) {
2688                    my $node = $self->{open_elements}->[$_];                    my $node = $self->{open_elements}->[$_];
2689                    if ($node->[1] eq 'td' or $node->[1] eq 'th') {                    if ($node->[1] == TABLE_CELL_EL) {
2690                      !!!cp ('t151');                      !!!cp ('t151');
2691    
2692                      ## Close the cell                      ## Close the cell
2693                      !!!back-token; # <?>                      !!!back-token; # <x>
2694                      $token = {type => END_TAG_TOKEN, tag_name => $node->[1],                      $token = {type => END_TAG_TOKEN,
2695                                  tag_name => $node->[0]->manakai_local_name,
2696                                line => $token->{line},                                line => $token->{line},
2697                                column => $token->{column}};                                column => $token->{column}};
2698                      redo B;                      next B;
2699                    } elsif ({                    } elsif ($node->[1] & TABLE_SCOPING_EL) {
                             table => 1, html => 1,  
                            }->{$node->[1]}) {  
2700                      !!!cp ('t152');                      !!!cp ('t152');
2701                      ## ISSUE: This case can never be reached, maybe.                      ## ISSUE: This case can never be reached, maybe.
2702                      last;                      last;
# Line 3977  sub _tree_construction_main ($) { Line 2705  sub _tree_construction_main ($) {
2705    
2706                  !!!cp ('t153');                  !!!cp ('t153');
2707                  !!!parse-error (type => 'start tag not allowed',                  !!!parse-error (type => 'start tag not allowed',
2708                      value => $token->{tag_name}, token => $token);                      text => $token->{tag_name}, token => $token);
2709                  ## Ignore the token                  ## Ignore the token
2710                    !!!nack ('t153.1');
2711                  !!!next-token;                  !!!next-token;
2712                  redo B;                  next B;
2713                } elsif ($self->{insertion_mode} == IN_CAPTION_IM) {                } elsif (($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) {
2714                  !!!parse-error (type => 'not closed:caption', token => $token);                  !!!parse-error (type => 'not closed', text => 'caption',
2715                                    token => $token);
2716                                    
2717                  ## NOTE: As if </caption>.                  ## NOTE: As if </caption>.
2718                  ## have a table element in table scope                  ## have a table element in table scope
# Line 3990  sub _tree_construction_main ($) { Line 2720  sub _tree_construction_main ($) {
2720                  INSCOPE: {                  INSCOPE: {
2721                    for (reverse 0..$#{$self->{open_elements}}) {                    for (reverse 0..$#{$self->{open_elements}}) {
2722                      my $node = $self->{open_elements}->[$_];                      my $node = $self->{open_elements}->[$_];
2723                      if ($node->[1] eq 'caption') {                      if ($node->[1] == CAPTION_EL) {
2724                        !!!cp ('t155');                        !!!cp ('t155');
2725                        $i = $_;                        $i = $_;
2726                        last INSCOPE;                        last INSCOPE;
2727                      } elsif ({                      } elsif ($node->[1] & TABLE_SCOPING_EL) {
                               table => 1, html => 1,  
                              }->{$node->[1]}) {  
2728                        !!!cp ('t156');                        !!!cp ('t156');
2729                        last;                        last;
2730                      }                      }
# Line 4004  sub _tree_construction_main ($) { Line 2732  sub _tree_construction_main ($) {
2732    
2733                    !!!cp ('t157');                    !!!cp ('t157');
2734                    !!!parse-error (type => 'start tag not allowed',                    !!!parse-error (type => 'start tag not allowed',
2735                                    value => $token->{tag_name}, token => $token);                                    text => $token->{tag_name}, token => $token);
2736                    ## Ignore the token                    ## Ignore the token
2737                      !!!nack ('t157.1');
2738                    !!!next-token;                    !!!next-token;
2739                    redo B;                    next B;
2740                  } # INSCOPE                  } # INSCOPE
2741                                    
2742                  ## generate implied end tags                  ## generate implied end tags
2743                  while ({                  while ($self->{open_elements}->[-1]->[1]
2744                          dd => 1, dt => 1, li => 1, p => 1,                             & END_TAG_OPTIONAL_EL) {
                        }->{$self->{open_elements}->[-1]->[1]}) {  
2745                    !!!cp ('t158');                    !!!cp ('t158');
2746                    pop @{$self->{open_elements}};                    pop @{$self->{open_elements}};
2747                  }                  }
2748    
2749                  if ($self->{open_elements}->[-1]->[1] ne 'caption') {                  unless ($self->{open_elements}->[-1]->[1] == CAPTION_EL) {
2750                    !!!cp ('t159');                    !!!cp ('t159');
2751                    !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1], token => $token);                    !!!parse-error (type => 'not closed',
2752                                      text => $self->{open_elements}->[-1]->[0]
2753                                          ->manakai_local_name,
2754                                      token => $token);
2755                  } else {                  } else {
2756                    !!!cp ('t160');                    !!!cp ('t160');
2757                  }                  }
# Line 4032  sub _tree_construction_main ($) { Line 2763  sub _tree_construction_main ($) {
2763                  $self->{insertion_mode} = IN_TABLE_IM;                  $self->{insertion_mode} = IN_TABLE_IM;
2764                                    
2765                  ## reprocess                  ## reprocess
2766                  redo B;                  !!!ack-later;
2767                    next B;
2768                } else {                } else {
2769                  !!!cp ('t161');                  !!!cp ('t161');
2770                  #                  #
# Line 4043  sub _tree_construction_main ($) { Line 2775  sub _tree_construction_main ($) {
2775              }              }
2776            } elsif ($token->{type} == END_TAG_TOKEN) {            } elsif ($token->{type} == END_TAG_TOKEN) {
2777              if ($token->{tag_name} eq 'td' or $token->{tag_name} eq 'th') {              if ($token->{tag_name} eq 'td' or $token->{tag_name} eq 'th') {
2778                if ($self->{insertion_mode} == IN_CELL_IM) {                if (($self->{insertion_mode} & IM_MASK) == IN_CELL_IM) {
2779                  ## have an element in table scope                  ## have an element in table scope
2780                  my $i;                  my $i;
2781                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
2782                    my $node = $self->{open_elements}->[$_];                    my $node = $self->{open_elements}->[$_];
2783                    if ($node->[1] eq $token->{tag_name}) {                    if ($node->[0]->manakai_local_name eq $token->{tag_name}) {
2784                      !!!cp ('t163');                      !!!cp ('t163');
2785                      $i = $_;                      $i = $_;
2786                      last INSCOPE;                      last INSCOPE;
2787                    } elsif ({                    } elsif ($node->[1] & TABLE_SCOPING_EL) {
                             table => 1, html => 1,  
                            }->{$node->[1]}) {  
2788                      !!!cp ('t164');                      !!!cp ('t164');
2789                      last INSCOPE;                      last INSCOPE;
2790                    }                    }
2791                  } # INSCOPE                  } # INSCOPE
2792                    unless (defined $i) {                    unless (defined $i) {
2793                      !!!cp ('t165');                      !!!cp ('t165');
2794                      !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);                      !!!parse-error (type => 'unmatched end tag',
2795                                        text => $token->{tag_name},
2796                                        token => $token);
2797                      ## Ignore the token                      ## Ignore the token
2798                      !!!next-token;                      !!!next-token;
2799                      redo B;                      next B;
2800                    }                    }
2801                                    
2802                  ## generate implied end tags                  ## generate implied end tags
2803                  while ({                  while ($self->{open_elements}->[-1]->[1]
2804                          dd => 1, dt => 1, li => 1, p => 1,                             & END_TAG_OPTIONAL_EL) {
                        }->{$self->{open_elements}->[-1]->[1]}) {  
2805                    !!!cp ('t166');                    !!!cp ('t166');
2806                    pop @{$self->{open_elements}};                    pop @{$self->{open_elements}};
2807                  }                  }
2808    
2809                  if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {                  if ($self->{open_elements}->[-1]->[0]->manakai_local_name
2810                            ne $token->{tag_name}) {
2811                    !!!cp ('t167');                    !!!cp ('t167');
2812                    !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1], token => $token);                    !!!parse-error (type => 'not closed',
2813                                      text => $self->{open_elements}->[-1]->[0]
2814                                          ->manakai_local_name,
2815                                      token => $token);
2816                  } else {                  } else {
2817                    !!!cp ('t168');                    !!!cp ('t168');
2818                  }                  }
# Line 4089  sub _tree_construction_main ($) { Line 2824  sub _tree_construction_main ($) {
2824                  $self->{insertion_mode} = IN_ROW_IM;                  $self->{insertion_mode} = IN_ROW_IM;
2825                                    
2826                  !!!next-token;                  !!!next-token;
2827                  redo B;                  next B;
2828                } elsif ($self->{insertion_mode} == IN_CAPTION_IM) {                } elsif (($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) {
2829                  !!!cp ('t169');                  !!!cp ('t169');
2830                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);                  !!!parse-error (type => 'unmatched end tag',
2831                                    text => $token->{tag_name}, token => $token);
2832                  ## Ignore the token                  ## Ignore the token
2833                  !!!next-token;                  !!!next-token;
2834                  redo B;                  next B;
2835                } else {                } else {
2836                  !!!cp ('t170');                  !!!cp ('t170');
2837                  #                  #
2838                }                }
2839              } elsif ($token->{tag_name} eq 'caption') {              } elsif ($token->{tag_name} eq 'caption') {
2840                if ($self->{insertion_mode} == IN_CAPTION_IM) {                if (($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) {
2841                  ## have a table element in table scope                  ## have a table element in table scope
2842                  my $i;                  my $i;
2843                  INSCOPE: {                  INSCOPE: {
2844                    for (reverse 0..$#{$self->{open_elements}}) {                    for (reverse 0..$#{$self->{open_elements}}) {
2845                      my $node = $self->{open_elements}->[$_];                      my $node = $self->{open_elements}->[$_];
2846                      if ($node->[1] eq $token->{tag_name}) {                      if ($node->[1] == CAPTION_EL) {
2847                        !!!cp ('t171');                        !!!cp ('t171');
2848                        $i = $_;                        $i = $_;
2849                        last INSCOPE;                        last INSCOPE;
2850                      } elsif ({                      } elsif ($node->[1] & TABLE_SCOPING_EL) {
                               table => 1, html => 1,  
                              }->{$node->[1]}) {  
2851                        !!!cp ('t172');                        !!!cp ('t172');
2852                        last;                        last;
2853                      }                      }
# Line 4121  sub _tree_construction_main ($) { Line 2855  sub _tree_construction_main ($) {
2855    
2856                    !!!cp ('t173');                    !!!cp ('t173');
2857                    !!!parse-error (type => 'unmatched end tag',                    !!!parse-error (type => 'unmatched end tag',
2858                                    value => $token->{tag_name}, token => $token);                                    text => $token->{tag_name}, token => $token);
2859                    ## Ignore the token                    ## Ignore the token
2860                    !!!next-token;                    !!!next-token;
2861                    redo B;                    next B;
2862                  } # INSCOPE                  } # INSCOPE
2863                                    
2864                  ## generate implied end tags                  ## generate implied end tags
2865                  while ({                  while ($self->{open_elements}->[-1]->[1]
2866                          dd => 1, dt => 1, li => 1, p => 1,                             & END_TAG_OPTIONAL_EL) {
                        }->{$self->{open_elements}->[-1]->[1]}) {  
2867                    !!!cp ('t174');                    !!!cp ('t174');
2868                    pop @{$self->{open_elements}};                    pop @{$self->{open_elements}};
2869                  }                  }
2870                                    
2871                  if ($self->{open_elements}->[-1]->[1] ne 'caption') {                  unless ($self->{open_elements}->[-1]->[1] == CAPTION_EL) {
2872                    !!!cp ('t175');                    !!!cp ('t175');
2873                    !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1], token => $token);                    !!!parse-error (type => 'not closed',
2874                                      text => $self->{open_elements}->[-1]->[0]
2875                                          ->manakai_local_name,
2876                                      token => $token);
2877                  } else {                  } else {
2878                    !!!cp ('t176');                    !!!cp ('t176');
2879                  }                  }
# Line 4149  sub _tree_construction_main ($) { Line 2885  sub _tree_construction_main ($) {
2885                  $self->{insertion_mode} = IN_TABLE_IM;                  $self->{insertion_mode} = IN_TABLE_IM;
2886                                    
2887                  !!!next-token;                  !!!next-token;
2888                  redo B;                  next B;
2889                } elsif ($self->{insertion_mode} == IN_CELL_IM) {                } elsif (($self->{insertion_mode} & IM_MASK) == IN_CELL_IM) {
2890                  !!!cp ('t177');                  !!!cp ('t177');
2891                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);                  !!!parse-error (type => 'unmatched end tag',
2892                                    text => $token->{tag_name}, token => $token);
2893                  ## Ignore the token                  ## Ignore the token
2894                  !!!next-token;                  !!!next-token;
2895                  redo B;                  next B;
2896                } else {                } else {
2897                  !!!cp ('t178');                  !!!cp ('t178');
2898                  #                  #
# Line 4164  sub _tree_construction_main ($) { Line 2901  sub _tree_construction_main ($) {
2901                        table => 1, tbody => 1, tfoot => 1,                        table => 1, tbody => 1, tfoot => 1,
2902                        thead => 1, tr => 1,                        thead => 1, tr => 1,
2903                       }->{$token->{tag_name}} and                       }->{$token->{tag_name}} and
2904                       $self->{insertion_mode} == IN_CELL_IM) {                       ($self->{insertion_mode} & IM_MASK) == IN_CELL_IM) {
2905                ## have an element in table scope                ## have an element in table scope
2906                my $i;                my $i;
2907                my $tn;                my $tn;
2908                INSCOPE: {                INSCOPE: {
2909                  for (reverse 0..$#{$self->{open_elements}}) {                  for (reverse 0..$#{$self->{open_elements}}) {
2910                    my $node = $self->{open_elements}->[$_];                    my $node = $self->{open_elements}->[$_];
2911                    if ($node->[1] eq $token->{tag_name}) {                    if ($node->[0]->manakai_local_name eq $token->{tag_name}) {
2912                      !!!cp ('t179');                      !!!cp ('t179');
2913                      $i = $_;                      $i = $_;
2914    
2915                      ## Close the cell                      ## Close the cell
2916                      !!!back-token; # </?>                      !!!back-token; # </x>
2917                      $token = {type => END_TAG_TOKEN, tag_name => $tn,                      $token = {type => END_TAG_TOKEN, tag_name => $tn,
2918                                line => $token->{line},                                line => $token->{line},
2919                                column => $token->{column}};                                column => $token->{column}};
2920                      redo B;                      next B;
2921                    } elsif ($node->[1] eq 'td' or $node->[1] eq 'th') {                    } elsif ($node->[1] == TABLE_CELL_EL) {
2922                      !!!cp ('t180');                      !!!cp ('t180');
2923                      $tn = $node->[1];                      $tn = $node->[0]->manakai_local_name;
2924                      ## NOTE: There is exactly one |td| or |th| element                      ## NOTE: There is exactly one |td| or |th| element
2925                      ## in scope in the stack of open elements by definition.                      ## in scope in the stack of open elements by definition.
2926                    } elsif ({                    } elsif ($node->[1] & TABLE_SCOPING_EL) {
                             table => 1, html => 1,  
                            }->{$node->[1]}) {  
2927                      ## ISSUE: Can this be reached?                      ## ISSUE: Can this be reached?
2928                      !!!cp ('t181');                      !!!cp ('t181');
2929                      last;                      last;
# Line 4197  sub _tree_construction_main ($) { Line 2932  sub _tree_construction_main ($) {
2932    
2933                  !!!cp ('t182');                  !!!cp ('t182');
2934                  !!!parse-error (type => 'unmatched end tag',                  !!!parse-error (type => 'unmatched end tag',
2935                      value => $token->{tag_name}, token => $token);                      text => $token->{tag_name}, token => $token);
2936                  ## Ignore the token                  ## Ignore the token
2937                  !!!next-token;                  !!!next-token;
2938                  redo B;                  next B;
2939                } # INSCOPE                } # INSCOPE
2940              } elsif ($token->{tag_name} eq 'table' and              } elsif ($token->{tag_name} eq 'table' and
2941                       $self->{insertion_mode} == IN_CAPTION_IM) {                       ($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) {
2942                !!!parse-error (type => 'not closed:caption', token => $token);                !!!parse-error (type => 'not closed', text => 'caption',
2943                                  token => $token);
2944    
2945                ## As if </caption>                ## As if </caption>
2946                ## have a table element in table scope                ## have a table element in table scope
2947                my $i;                my $i;
2948                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
2949                  my $node = $self->{open_elements}->[$_];                  my $node = $self->{open_elements}->[$_];
2950                  if ($node->[1] eq 'caption') {                  if ($node->[1] == CAPTION_EL) {
2951                    !!!cp ('t184');                    !!!cp ('t184');
2952                    $i = $_;                    $i = $_;
2953                    last INSCOPE;                    last INSCOPE;
2954                  } elsif ({                  } elsif ($node->[1] & TABLE_SCOPING_EL) {
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
2955                    !!!cp ('t185');                    !!!cp ('t185');
2956                    last INSCOPE;                    last INSCOPE;
2957                  }                  }
2958                } # INSCOPE                } # INSCOPE
2959                unless (defined $i) {                unless (defined $i) {
2960                  !!!cp ('t186');                  !!!cp ('t186');
2961                  !!!parse-error (type => 'unmatched end tag:caption', token => $token);          ## TODO: Wrong error type?
2962                    !!!parse-error (type => 'unmatched end tag',
2963                                    text => 'caption', token => $token);
2964                  ## Ignore the token                  ## Ignore the token
2965                  !!!next-token;                  !!!next-token;
2966                  redo B;                  next B;
2967                }                }
2968                                
2969                ## generate implied end tags                ## generate implied end tags
2970                while ({                while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
                       dd => 1, dt => 1, li => 1, p => 1,  
                      }->{$self->{open_elements}->[-1]->[1]}) {  
2971                  !!!cp ('t187');                  !!!cp ('t187');
2972                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
2973                }                }
2974    
2975                if ($self->{open_elements}->[-1]->[1] ne 'caption') {                unless ($self->{open_elements}->[-1]->[1] == CAPTION_EL) {
2976                  !!!cp ('t188');                  !!!cp ('t188');
2977                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1], token => $token);                  !!!parse-error (type => 'not closed',
2978                                    text => $self->{open_elements}->[-1]->[0]
2979                                        ->manakai_local_name,
2980                                    token => $token);
2981                } else {                } else {
2982                  !!!cp ('t189');                  !!!cp ('t189');
2983                }                }
# Line 4252  sub _tree_construction_main ($) { Line 2989  sub _tree_construction_main ($) {
2989                $self->{insertion_mode} = IN_TABLE_IM;                $self->{insertion_mode} = IN_TABLE_IM;
2990    
2991                ## reprocess                ## reprocess
2992                redo B;                next B;
2993              } elsif ({              } elsif ({
2994                        body => 1, col => 1, colgroup => 1, html => 1,                        body => 1, col => 1, colgroup => 1, html => 1,
2995                       }->{$token->{tag_name}}) {                       }->{$token->{tag_name}}) {
2996                if ($self->{insertion_mode} & BODY_TABLE_IMS) {                if ($self->{insertion_mode} & BODY_TABLE_IMS) {
2997                  !!!cp ('t190');                  !!!cp ('t190');
2998                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);                  !!!parse-error (type => 'unmatched end tag',
2999                                    text => $token->{tag_name}, token => $token);
3000                  ## Ignore the token                  ## Ignore the token
3001                  !!!next-token;                  !!!next-token;
3002                  redo B;                  next B;
3003                } else {                } else {
3004                  !!!cp ('t191');                  !!!cp ('t191');
3005                  #                  #
3006                }                }
3007              } elsif ({          } elsif ({
3008                        tbody => 1, tfoot => 1,                    tbody => 1, tfoot => 1,
3009                        thead => 1, tr => 1,                    thead => 1, tr => 1,
3010                       }->{$token->{tag_name}} and                   }->{$token->{tag_name}} and
3011                       $self->{insertion_mode} == IN_CAPTION_IM) {                   ($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) {
3012                !!!cp ('t192');            !!!cp ('t192');
3013                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);            !!!parse-error (type => 'unmatched end tag',
3014                ## Ignore the token                            text => $token->{tag_name}, token => $token);
3015                !!!next-token;            ## Ignore the token
3016                redo B;            !!!next-token;
3017              } else {            next B;
3018                !!!cp ('t193');          } else {
3019                #            !!!cp ('t193');
3020              }            #
3021            }
3022        } elsif ($token->{type} == END_OF_FILE_TOKEN) {        } elsif ($token->{type} == END_OF_FILE_TOKEN) {
3023          for my $entry (@{$self->{open_elements}}) {          for my $entry (@{$self->{open_elements}}) {
3024            if (not {            unless ($entry->[1] & ALL_END_TAG_OPTIONAL_EL) {
             dd => 1, dt => 1, li => 1, p => 1, tbody => 1, td => 1, tfoot => 1,  
             th => 1, thead => 1, tr => 1, body => 1, html => 1,  
           }->{$entry->[1]}) {  
3025              !!!cp ('t75');              !!!cp ('t75');
3026              !!!parse-error (type => 'in body:#eof', token => $token);              !!!parse-error (type => 'in body:#eof', token => $token);
3027              last;              last;
# Line 4301  sub _tree_construction_main ($) { Line 3037  sub _tree_construction_main ($) {
3037        $insert = $insert_to_current;        $insert = $insert_to_current;
3038        #        #
3039      } elsif ($self->{insertion_mode} & TABLE_IMS) {      } elsif ($self->{insertion_mode} & TABLE_IMS) {
3040        if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == START_TAG_TOKEN) {
3041          if (not $open_tables->[-1]->[1] and # tainted          if ({
3042              $token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {               tr => (($self->{insertion_mode} & IM_MASK) != IN_ROW_IM),
3043            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);               th => 1, td => 1,
3044                              }->{$token->{tag_name}}) {
3045            unless (length $token->{data}) {            if (($self->{insertion_mode} & IM_MASK) == IN_TABLE_IM) {
3046              !!!cp ('t194');              ## Clear back to table context
3047              !!!next-token;              while (not ($self->{open_elements}->[-1]->[1]
3048              redo B;                              & TABLE_SCOPING_EL)) {
3049            } else {                !!!cp ('t201');
3050              !!!cp ('t195');                pop @{$self->{open_elements}};
3051            }              }
         }  
   
             !!!parse-error (type => 'in table:#character', token => $token);  
   
             ## As if in body, but insert into foster parent element  
             ## ISSUE: Spec says that "whenever a node would be inserted  
             ## into the current node" while characters might not be  
             ## result in a new Text node.  
             $reconstruct_active_formatting_elements->($insert_to_foster);  
               
             if ({  
                  table => 1, tbody => 1, tfoot => 1,  
                  thead => 1, tr => 1,  
                 }->{$self->{open_elements}->[-1]->[1]}) {  
               # MUST  
               my $foster_parent_element;  
               my $next_sibling;  
               my $prev_sibling;  
               OE: for (reverse 0..$#{$self->{open_elements}}) {  
                 if ($self->{open_elements}->[$_]->[1] eq 'table') {  
                   my $parent = $self->{open_elements}->[$_]->[0]->parent_node;  
                   if (defined $parent and $parent->node_type == 1) {  
                     !!!cp ('t196');  
                     $foster_parent_element = $parent;  
                     $next_sibling = $self->{open_elements}->[$_]->[0];  
                     $prev_sibling = $next_sibling->previous_sibling;  
                   } else {  
                     !!!cp ('t197');  
                     $foster_parent_element = $self->{open_elements}->[$_ - 1]->[0];  
                     $prev_sibling = $foster_parent_element->last_child;  
                   }  
                   last OE;  
                 }  
               } # OE  
               $foster_parent_element = $self->{open_elements}->[0]->[0] and  
               $prev_sibling = $foster_parent_element->last_child  
                 unless defined $foster_parent_element;  
               if (defined $prev_sibling and  
                   $prev_sibling->node_type == 3) {  
                 !!!cp ('t198');  
                 $prev_sibling->manakai_append_text ($token->{data});  
               } else {  
                 !!!cp ('t199');  
                 $foster_parent_element->insert_before  
                   ($self->{document}->create_text_node ($token->{data}),  
                    $next_sibling);  
               }  
           $open_tables->[-1]->[1] = 1; # tainted  
         } else {  
           !!!cp ('t200');  
           $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});  
         }  
3052                            
3053          !!!next-token;              !!!insert-element ('tbody',, $token);
3054          redo B;              $self->{insertion_mode} = IN_TABLE_BODY_IM;
3055        } elsif ($token->{type} == START_TAG_TOKEN) {              ## reprocess in the "in table body" insertion mode...
3056              if ({            }
3057                   tr => ($self->{insertion_mode} != IN_ROW_IM),            
3058                   th => 1, td => 1,            if (($self->{insertion_mode} & IM_MASK) == IN_TABLE_BODY_IM) {
3059                  }->{$token->{tag_name}}) {              unless ($token->{tag_name} eq 'tr') {
3060                if ($self->{insertion_mode} == IN_TABLE_IM) {                !!!cp ('t202');
3061                  ## Clear back to table context                !!!parse-error (type => 'missing start tag:tr', token => $token);
3062                  while ($self->{open_elements}->[-1]->[1] ne 'table' and              }
                        $self->{open_elements}->[-1]->[1] ne 'html') {  
                   !!!cp ('t201');  
                   pop @{$self->{open_elements}};  
                 }  
                   
                 !!!insert-element ('tbody',, $token);  
                 $self->{insertion_mode} = IN_TABLE_BODY_IM;  
                 ## reprocess in the "in table body" insertion mode...  
               }  
   
               if ($self->{insertion_mode} == IN_TABLE_BODY_IM) {  
                 unless ($token->{tag_name} eq 'tr') {  
                   !!!cp ('t202');  
                   !!!parse-error (type => 'missing start tag:tr', token => $token);  
                 }  
3063                                    
3064                  ## Clear back to table body context              ## Clear back to table body context
3065                  while (not {              while (not ($self->{open_elements}->[-1]->[1]
3066                    tbody => 1, tfoot => 1, thead => 1, html => 1,                              & TABLE_ROWS_SCOPING_EL)) {
3067                  }->{$self->{open_elements}->[-1]->[1]}) {                !!!cp ('t203');
3068                    !!!cp ('t203');                ## ISSUE: Can this case be reached?
3069                    ## ISSUE: Can this case be reached?                pop @{$self->{open_elements}};
3070                    pop @{$self->{open_elements}};              }
                 }  
3071                                    
3072                  $self->{insertion_mode} = IN_ROW_IM;              $self->{insertion_mode} = IN_ROW_IM;
3073                  if ($token->{tag_name} eq 'tr') {              if ($token->{tag_name} eq 'tr') {
3074                    !!!cp ('t204');                !!!cp ('t204');
3075                    !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);                !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3076                    !!!next-token;                $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3077                    redo B;                !!!nack ('t204');
3078                  } else {                !!!next-token;
3079                    !!!cp ('t205');                next B;
3080                    !!!insert-element ('tr',, $token);              } else {
3081                    ## reprocess in the "in row" insertion mode                !!!cp ('t205');
3082                  }                !!!insert-element ('tr',, $token);
3083                } else {                ## reprocess in the "in row" insertion mode
3084                  !!!cp ('t206');              }
3085                }            } else {
3086                !!!cp ('t206');
3087              }
3088    
3089                ## Clear back to table row context                ## Clear back to table row context
3090                while (not {                while (not ($self->{open_elements}->[-1]->[1]
3091                  tr => 1, html => 1,                                & TABLE_ROW_SCOPING_EL)) {
               }->{$self->{open_elements}->[-1]->[1]}) {  
3092                  !!!cp ('t207');                  !!!cp ('t207');
3093                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
3094                }                }
3095                                
3096                !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);            !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3097                $self->{insertion_mode} = IN_CELL_IM;            $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3098              $self->{insertion_mode} = IN_CELL_IM;
3099    
3100                push @$active_formatting_elements, ['#marker', ''];            push @$active_formatting_elements, ['#marker', ''];
3101                                
3102              !!!nack ('t207.1');
3103              !!!next-token;
3104              next B;
3105            } elsif ({
3106                      caption => 1, col => 1, colgroup => 1,
3107                      tbody => 1, tfoot => 1, thead => 1,
3108                      tr => 1, # $self->{insertion_mode} == IN_ROW_IM
3109                     }->{$token->{tag_name}}) {
3110              if (($self->{insertion_mode} & IM_MASK) == IN_ROW_IM) {
3111                ## As if </tr>
3112                ## have an element in table scope
3113                my $i;
3114                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3115                  my $node = $self->{open_elements}->[$_];
3116                  if ($node->[1] == TABLE_ROW_EL) {
3117                    !!!cp ('t208');
3118                    $i = $_;
3119                    last INSCOPE;
3120                  } elsif ($node->[1] & TABLE_SCOPING_EL) {
3121                    !!!cp ('t209');
3122                    last INSCOPE;
3123                  }
3124                } # INSCOPE
3125                unless (defined $i) {
3126                  !!!cp ('t210');
3127                  ## TODO: This type is wrong.
3128                  !!!parse-error (type => 'unmacthed end tag',
3129                                  text => $token->{tag_name}, token => $token);
3130                  ## Ignore the token
3131                  !!!nack ('t210.1');
3132                !!!next-token;                !!!next-token;
3133                redo B;                next B;
3134              } elsif ({              }
                       caption => 1, col => 1, colgroup => 1,  
                       tbody => 1, tfoot => 1, thead => 1,  
                       tr => 1, # $self->{insertion_mode} == IN_ROW_IM  
                      }->{$token->{tag_name}}) {  
               if ($self->{insertion_mode} == IN_ROW_IM) {  
                 ## As if </tr>  
                 ## have an element in table scope  
                 my $i;  
                 INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {  
                   my $node = $self->{open_elements}->[$_];  
                   if ($node->[1] eq 'tr') {  
                     !!!cp ('t208');  
                     $i = $_;  
                     last INSCOPE;  
                   } elsif ({  
                             html => 1,  
   
                             ## NOTE: This element does not appear here, maybe.  
                             table => 1,  
                            }->{$node->[1]}) {  
                     !!!cp ('t209');  
                     last INSCOPE;  
                   }  
                 } # INSCOPE  
                 unless (defined $i) {  
                  !!!cp ('t210');  
 ## TODO: This type is wrong.  
                  !!!parse-error (type => 'unmacthed end tag:'.$token->{tag_name}, token => $token);  
                   ## Ignore the token  
                   !!!next-token;  
                   redo B;  
                 }  
3135                                    
3136                  ## Clear back to table row context                  ## Clear back to table row context
3137                  while (not {                  while (not ($self->{open_elements}->[-1]->[1]
3138                    tr => 1, html => 1,                                  & TABLE_ROW_SCOPING_EL)) {
                 }->{$self->{open_elements}->[-1]->[1]}) {  
3139                    !!!cp ('t211');                    !!!cp ('t211');
3140                    ## ISSUE: Can this case be reached?                    ## ISSUE: Can this case be reached?
3141                    pop @{$self->{open_elements}};                    pop @{$self->{open_elements}};
# Line 4479  sub _tree_construction_main ($) { Line 3146  sub _tree_construction_main ($) {
3146                  if ($token->{tag_name} eq 'tr') {                  if ($token->{tag_name} eq 'tr') {
3147                    !!!cp ('t212');                    !!!cp ('t212');
3148                    ## reprocess                    ## reprocess
3149                    redo B;                    !!!ack-later;
3150                      next B;
3151                  } else {                  } else {
3152                    !!!cp ('t213');                    !!!cp ('t213');
3153                    ## reprocess in the "in table body" insertion mode...                    ## reprocess in the "in table body" insertion mode...
3154                  }                  }
3155                }                }
3156    
3157                if ($self->{insertion_mode} == IN_TABLE_BODY_IM) {                if (($self->{insertion_mode} & IM_MASK) == IN_TABLE_BODY_IM) {
3158                  ## have an element in table scope                  ## have an element in table scope
3159                  my $i;                  my $i;
3160                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3161                    my $node = $self->{open_elements}->[$_];                    my $node = $self->{open_elements}->[$_];
3162                    if ({                    if ($node->[1] == TABLE_ROW_GROUP_EL) {
                        tbody => 1, thead => 1, tfoot => 1,  
                       }->{$node->[1]}) {  
3163                      !!!cp ('t214');                      !!!cp ('t214');
3164                      $i = $_;                      $i = $_;
3165                      last INSCOPE;                      last INSCOPE;
3166                    } elsif ({                    } elsif ($node->[1] & TABLE_SCOPING_EL) {
                             table => 1, html => 1,  
                            }->{$node->[1]}) {  
3167                      !!!cp ('t215');                      !!!cp ('t215');
3168                      last INSCOPE;                      last INSCOPE;
3169                    }                    }
3170                  } # INSCOPE                  } # INSCOPE
3171                  unless (defined $i) {                  unless (defined $i) {
3172                    !!!cp ('t216');                    !!!cp ('t216');
3173  ## TODO: This erorr type ios wrong.  ## TODO: This erorr type is wrong.
3174                    !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);                    !!!parse-error (type => 'unmatched end tag',
3175                                      text => $token->{tag_name}, token => $token);
3176                    ## Ignore the token                    ## Ignore the token
3177                      !!!nack ('t216.1');
3178                    !!!next-token;                    !!!next-token;
3179                    redo B;                    next B;
3180                  }                  }
3181    
3182                  ## Clear back to table body context                  ## Clear back to table body context
3183                  while (not {                  while (not ($self->{open_elements}->[-1]->[1]
3184                    tbody => 1, tfoot => 1, thead => 1, html => 1,                                  & TABLE_ROWS_SCOPING_EL)) {
                 }->{$self->{open_elements}->[-1]->[1]}) {  
3185                    !!!cp ('t217');                    !!!cp ('t217');
3186                    ## ISSUE: Can this state be reached?                    ## ISSUE: Can this state be reached?
3187                    pop @{$self->{open_elements}};                    pop @{$self->{open_elements}};
# Line 4536  sub _tree_construction_main ($) { Line 3201  sub _tree_construction_main ($) {
3201                  !!!cp ('t218');                  !!!cp ('t218');
3202                }                }
3203    
3204                if ($token->{tag_name} eq 'col') {            if ($token->{tag_name} eq 'col') {
3205                  ## Clear back to table context              ## Clear back to table context
3206                  while ($self->{open_elements}->[-1]->[1] ne 'table' and              while (not ($self->{open_elements}->[-1]->[1]
3207                         $self->{open_elements}->[-1]->[1] ne 'html') {                              & TABLE_SCOPING_EL)) {
3208                    !!!cp ('t219');                !!!cp ('t219');
3209                    ## ISSUE: Can this state be reached?                ## ISSUE: Can this state be reached?
3210                    pop @{$self->{open_elements}};                pop @{$self->{open_elements}};
3211                  }              }
3212                                
3213                  !!!insert-element ('colgroup',, $token);              !!!insert-element ('colgroup',, $token);
3214                  $self->{insertion_mode} = IN_COLUMN_GROUP_IM;              $self->{insertion_mode} = IN_COLUMN_GROUP_IM;
3215                  ## reprocess              ## reprocess
3216                  redo B;              $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3217                } elsif ({              !!!ack-later;
3218                          caption => 1,              next B;
3219                          colgroup => 1,            } elsif ({
3220                          tbody => 1, tfoot => 1, thead => 1,                      caption => 1,
3221                         }->{$token->{tag_name}}) {                      colgroup => 1,
3222                  ## Clear back to table context                      tbody => 1, tfoot => 1, thead => 1,
3223                  while ($self->{open_elements}->[-1]->[1] ne 'table' and                     }->{$token->{tag_name}}) {
3224                         $self->{open_elements}->[-1]->[1] ne 'html') {              ## Clear back to table context
3225                    while (not ($self->{open_elements}->[-1]->[1]
3226                                    & TABLE_SCOPING_EL)) {
3227                    !!!cp ('t220');                    !!!cp ('t220');
3228                    ## ISSUE: Can this state be reached?                    ## ISSUE: Can this state be reached?
3229                    pop @{$self->{open_elements}};                    pop @{$self->{open_elements}};
3230                  }                  }
3231                                    
3232                  push @$active_formatting_elements, ['#marker', '']              push @$active_formatting_elements, ['#marker', '']
3233                      if $token->{tag_name} eq 'caption';                  if $token->{tag_name} eq 'caption';
3234                                    
3235                  !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);              !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3236                  $self->{insertion_mode} = {              $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3237                                             caption => IN_CAPTION_IM,              $self->{insertion_mode} = {
3238                                             colgroup => IN_COLUMN_GROUP_IM,                                         caption => IN_CAPTION_IM,
3239                                             tbody => IN_TABLE_BODY_IM,                                         colgroup => IN_COLUMN_GROUP_IM,
3240                                             tfoot => IN_TABLE_BODY_IM,                                         tbody => IN_TABLE_BODY_IM,
3241                                             thead => IN_TABLE_BODY_IM,                                         tfoot => IN_TABLE_BODY_IM,
3242                                            }->{$token->{tag_name}};                                         thead => IN_TABLE_BODY_IM,
3243                  !!!next-token;                                        }->{$token->{tag_name}};
3244                  redo B;              !!!next-token;
3245                } else {              !!!nack ('t220.1');
3246                  die "$0: in table: <>: $token->{tag_name}";              next B;
3247                }            } else {
3248                die "$0: in table: <>: $token->{tag_name}";
3249              }
3250              } elsif ($token->{tag_name} eq 'table') {              } elsif ($token->{tag_name} eq 'table') {
3251                !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1], token => $token);                !!!parse-error (type => 'not closed',
3252                                  text => $self->{open_elements}->[-1]->[0]
3253                                      ->manakai_local_name,
3254                                  token => $token);
3255    
3256                ## As if </table>                ## As if </table>
3257                ## have a table element in table scope                ## have a table element in table scope
3258                my $i;                my $i;
3259                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3260                  my $node = $self->{open_elements}->[$_];                  my $node = $self->{open_elements}->[$_];
3261                  if ($node->[1] eq 'table') {                  if ($node->[1] == TABLE_EL) {
3262                    !!!cp ('t221');                    !!!cp ('t221');
3263                    $i = $_;                    $i = $_;
3264                    last INSCOPE;                    last INSCOPE;
3265                  } elsif ({                  } elsif ($node->[1] & TABLE_SCOPING_EL) {
                           #table => 1,  
                           html => 1,  
                          }->{$node->[1]}) {  
3266                    !!!cp ('t222');                    !!!cp ('t222');
3267                    last INSCOPE;                    last INSCOPE;
3268                  }                  }
# Line 4601  sub _tree_construction_main ($) { Line 3270  sub _tree_construction_main ($) {
3270                unless (defined $i) {                unless (defined $i) {
3271                  !!!cp ('t223');                  !!!cp ('t223');
3272  ## TODO: The following is wrong, maybe.  ## TODO: The following is wrong, maybe.
3273                  !!!parse-error (type => 'unmatched end tag:table', token => $token);                  !!!parse-error (type => 'unmatched end tag', text => 'table',
3274                                    token => $token);
3275                  ## Ignore tokens </table><table>                  ## Ignore tokens </table><table>
3276                    !!!nack ('t223.1');
3277                  !!!next-token;                  !!!next-token;
3278                  redo B;                  next B;
3279                }                }
3280                                
3281  ## TODO: Followings are removed from the latest spec.  ## TODO: Followings are removed from the latest spec.
3282                ## generate implied end tags                ## generate implied end tags
3283                while ({                while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
                       dd => 1, dt => 1, li => 1, p => 1,  
                      }->{$self->{open_elements}->[-1]->[1]}) {  
3284                  !!!cp ('t224');                  !!!cp ('t224');
3285                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
3286                }                }
3287    
3288                if ($self->{open_elements}->[-1]->[1] ne 'table') {                unless ($self->{open_elements}->[-1]->[1] == TABLE_EL) {
3289                  !!!cp ('t225');                  !!!cp ('t225');
3290  ## ISSUE: Can this case be reached?                  ## NOTE: |<table><tr><table>|
3291                  !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1], token => $token);                  !!!parse-error (type => 'not closed',
3292                                    text => $self->{open_elements}->[-1]->[0]
3293                                        ->manakai_local_name,
3294                                    token => $token);
3295                } else {                } else {
3296                  !!!cp ('t226');                  !!!cp ('t226');
3297                }                }
# Line 4629  sub _tree_construction_main ($) { Line 3301  sub _tree_construction_main ($) {
3301    
3302                $self->_reset_insertion_mode;                $self->_reset_insertion_mode;
3303    
3304                ## reprocess            ## reprocess
3305                redo B;            !!!ack-later;
3306              next B;
3307          } elsif ($token->{tag_name} eq 'style') {          } elsif ($token->{tag_name} eq 'style') {
3308            if (not $open_tables->[-1]->[1]) { # tainted            !!!cp ('t227.8');
3309              !!!cp ('t227.8');            ## NOTE: This is a "as if in head" code clone.
3310              ## NOTE: This is a "as if in head" code clone.            $parse_rcdata->(CDATA_CONTENT_MODEL);
3311              $parse_rcdata->(CDATA_CONTENT_MODEL);            $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3312              redo B;            next B;
           } else {  
             !!!cp ('t227.7');  
             #  
           }  
3313          } elsif ($token->{tag_name} eq 'script') {          } elsif ($token->{tag_name} eq 'script') {
3314            if (not $open_tables->[-1]->[1]) { # tainted            !!!cp ('t227.6');
3315              !!!cp ('t227.6');            ## NOTE: This is a "as if in head" code clone.
3316              ## NOTE: This is a "as if in head" code clone.            $script_start_tag->();
3317              $script_start_tag->();            $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3318              redo B;            next B;
           } else {  
             !!!cp ('t227.5');  
             #  
           }  
3319          } elsif ($token->{tag_name} eq 'input') {          } elsif ($token->{tag_name} eq 'input') {
3320            if (not $open_tables->[-1]->[1]) { # tainted            if ($token->{attributes}->{type}) {
3321              if ($token->{attributes}->{type}) { ## TODO: case              my $type = $token->{attributes}->{type}->{value};
3322                my $type = lc $token->{attributes}->{type}->{value};              $type =~ tr/A-Z/a-z/; ## ASCII case-insensitive.
3323                if ($type eq 'hidden') {              if ($type eq 'hidden') {
3324                  !!!cp ('t227.3');                !!!cp ('t227.3');
3325                  !!!parse-error (type => 'in table:'.$token->{tag_name}, token => $token);                !!!parse-error (type => 'in table',
3326                                  text => $token->{tag_name}, token => $token);
3327    
3328                  !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);                !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3329                  $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted
3330    
3331                  ## TODO: form element pointer                ## TODO: form element pointer
3332    
3333                  pop @{$self->{open_elements}};                pop @{$self->{open_elements}};
3334    
3335                  !!!next-token;                !!!next-token;
3336                  redo B;                !!!ack ('t227.2.1');
3337                } else {                next B;
                 !!!cp ('t227.2');  
                 #  
               }  
3338              } else {              } else {
3339                !!!cp ('t227.1');                !!!cp ('t227.1');
3340                #                #
# Line 4684  sub _tree_construction_main ($) { Line 3348  sub _tree_construction_main ($) {
3348            #            #
3349          }          }
3350    
3351          !!!parse-error (type => 'in table:'.$token->{tag_name}, token => $token);          !!!parse-error (type => 'in table', text => $token->{tag_name},
3352                            token => $token);
3353    
3354          $insert = $insert_to_foster;          $insert = $insert_to_foster;
3355          #          #
3356        } elsif ($token->{type} == END_TAG_TOKEN) {        } elsif ($token->{type} == END_TAG_TOKEN) {
3357              if ($token->{tag_name} eq 'tr' and          if ($token->{tag_name} eq 'tr' and
3358                  $self->{insertion_mode} == IN_ROW_IM) {              ($self->{insertion_mode} & IM_MASK) == IN_ROW_IM) {
3359                ## have an element in table scope            ## have an element in table scope
3360                my $i;                my $i;
3361                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3362                  my $node = $self->{open_elements}->[$_];                  my $node = $self->{open_elements}->[$_];
3363                  if ($node->[1] eq $token->{tag_name}) {                  if ($node->[1] == TABLE_ROW_EL) {
3364                    !!!cp ('t228');                    !!!cp ('t228');
3365                    $i = $_;                    $i = $_;
3366                    last INSCOPE;                    last INSCOPE;
3367                  } elsif ({                  } elsif ($node->[1] & TABLE_SCOPING_EL) {
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
3368                    !!!cp ('t229');                    !!!cp ('t229');
3369                    last INSCOPE;                    last INSCOPE;
3370                  }                  }
3371                } # INSCOPE                } # INSCOPE
3372                unless (defined $i) {                unless (defined $i) {
3373                  !!!cp ('t230');                  !!!cp ('t230');
3374                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);                  !!!parse-error (type => 'unmatched end tag',
3375                                    text => $token->{tag_name}, token => $token);
3376                  ## Ignore the token                  ## Ignore the token
3377                    !!!nack ('t230.1');
3378                  !!!next-token;                  !!!next-token;
3379                  redo B;                  next B;
3380                } else {                } else {
3381                  !!!cp ('t232');                  !!!cp ('t232');
3382                }                }
3383    
3384                ## Clear back to table row context                ## Clear back to table row context
3385                while (not {                while (not ($self->{open_elements}->[-1]->[1]
3386                  tr => 1, html => 1,                                & TABLE_ROW_SCOPING_EL)) {
               }->{$self->{open_elements}->[-1]->[1]}) {  
3387                  !!!cp ('t231');                  !!!cp ('t231');
3388  ## ISSUE: Can this state be reached?  ## ISSUE: Can this state be reached?
3389                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
# Line 4728  sub _tree_construction_main ($) { Line 3392  sub _tree_construction_main ($) {
3392                pop @{$self->{open_elements}}; # tr                pop @{$self->{open_elements}}; # tr
3393                $self->{insertion_mode} = IN_TABLE_BODY_IM;                $self->{insertion_mode} = IN_TABLE_BODY_IM;
3394                !!!next-token;                !!!next-token;
3395                redo B;                !!!nack ('t231.1');
3396                  next B;
3397              } elsif ($token->{tag_name} eq 'table') {              } elsif ($token->{tag_name} eq 'table') {
3398                if ($self->{insertion_mode} == IN_ROW_IM) {                if (($self->{insertion_mode} & IM_MASK) == IN_ROW_IM) {
3399                  ## As if </tr>                  ## As if </tr>
3400                  ## have an element in table scope                  ## have an element in table scope
3401                  my $i;                  my $i;
3402                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3403                    my $node = $self->{open_elements}->[$_];                    my $node = $self->{open_elements}->[$_];
3404                    if ($node->[1] eq 'tr') {                    if ($node->[1] == TABLE_ROW_EL) {
3405                      !!!cp ('t233');                      !!!cp ('t233');
3406                      $i = $_;                      $i = $_;
3407                      last INSCOPE;                      last INSCOPE;
3408                    } elsif ({                    } elsif ($node->[1] & TABLE_SCOPING_EL) {
                             table => 1, html => 1,  
                            }->{$node->[1]}) {  
3409                      !!!cp ('t234');                      !!!cp ('t234');
3410                      last INSCOPE;                      last INSCOPE;
3411                    }                    }
# Line 4750  sub _tree_construction_main ($) { Line 3413  sub _tree_construction_main ($) {
3413                  unless (defined $i) {                  unless (defined $i) {
3414                    !!!cp ('t235');                    !!!cp ('t235');
3415  ## TODO: The following is wrong.  ## TODO: The following is wrong.
3416                    !!!parse-error (type => 'unmatched end tag:'.$token->{type}, token => $token);                    !!!parse-error (type => 'unmatched end tag',
3417                                      text => $token->{type}, token => $token);
3418                    ## Ignore the token                    ## Ignore the token
3419                      !!!nack ('t236.1');
3420                    !!!next-token;                    !!!next-token;
3421                    redo B;                    next B;
3422                  }                  }
3423                                    
3424                  ## Clear back to table row context                  ## Clear back to table row context
3425                  while (not {                  while (not ($self->{open_elements}->[-1]->[1]
3426                    tr => 1, html => 1,                                  & TABLE_ROW_SCOPING_EL)) {
                 }->{$self->{open_elements}->[-1]->[1]}) {  
3427                    !!!cp ('t236');                    !!!cp ('t236');
3428  ## ISSUE: Can this state be reached?  ## ISSUE: Can this state be reached?
3429                    pop @{$self->{open_elements}};                    pop @{$self->{open_elements}};
# Line 4770  sub _tree_construction_main ($) { Line 3434  sub _tree_construction_main ($) {
3434                  ## reprocess in the "in table body" insertion mode...                  ## reprocess in the "in table body" insertion mode...
3435                }                }
3436    
3437                if ($self->{insertion_mode} == IN_TABLE_BODY_IM) {                if (($self->{insertion_mode} & IM_MASK) == IN_TABLE_BODY_IM) {
3438                  ## have an element in table scope                  ## have an element in table scope
3439                  my $i;                  my $i;
3440                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3441                    my $node = $self->{open_elements}->[$_];                    my $node = $self->{open_elements}->[$_];
3442                    if ({                    if ($node->[1] == TABLE_ROW_GROUP_EL) {
                        tbody => 1, thead => 1, tfoot => 1,  
                       }->{$node->[1]}) {  
3443                      !!!cp ('t237');                      !!!cp ('t237');
3444                      $i = $_;                      $i = $_;
3445                      last INSCOPE;                      last INSCOPE;
3446                    } elsif ({                    } elsif ($node->[1] & TABLE_SCOPING_EL) {
                             table => 1, html => 1,  
                            }->{$node->[1]}) {  
3447                      !!!cp ('t238');                      !!!cp ('t238');
3448                      last INSCOPE;                      last INSCOPE;
3449                    }                    }
3450                  } # INSCOPE                  } # INSCOPE
3451                  unless (defined $i) {                  unless (defined $i) {
3452                    !!!cp ('t239');                    !!!cp ('t239');
3453                    !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);                    !!!parse-error (type => 'unmatched end tag',
3454                                      text => $token->{tag_name}, token => $token);
3455                    ## Ignore the token                    ## Ignore the token
3456                      !!!nack ('t239.1');
3457                    !!!next-token;                    !!!next-token;
3458                    redo B;                    next B;
3459                  }                  }
3460                                    
3461                  ## Clear back to table body context                  ## Clear back to table body context
3462                  while (not {                  while (not ($self->{open_elements}->[-1]->[1]
3463                    tbody => 1, tfoot => 1, thead => 1, html => 1,                                  & TABLE_ROWS_SCOPING_EL)) {
                 }->{$self->{open_elements}->[-1]->[1]}) {  
3464                    !!!cp ('t240');                    !!!cp ('t240');
3465                    pop @{$self->{open_elements}};                    pop @{$self->{open_elements}};
3466                  }                  }
# Line 4825  sub _tree_construction_main ($) { Line 3486  sub _tree_construction_main ($) {
3486                my $i;                my $i;
3487                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3488                  my $node = $self->{open_elements}->[$_];                  my $node = $self->{open_elements}->[$_];
3489                  if ($node->[1] eq $token->{tag_name}) {                  if ($node->[1] == TABLE_EL) {
3490                    !!!cp ('t241');                    !!!cp ('t241');
3491                    $i = $_;                    $i = $_;
3492                    last INSCOPE;                    last INSCOPE;
3493                  } elsif ({                  } elsif ($node->[1] & TABLE_SCOPING_EL) {
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
3494                    !!!cp ('t242');                    !!!cp ('t242');
3495                    last INSCOPE;                    last INSCOPE;
3496                  }                  }
3497                } # INSCOPE                } # INSCOPE
3498                unless (defined $i) {                unless (defined $i) {
3499                  !!!cp ('t243');                  !!!cp ('t243');
3500                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);                  !!!parse-error (type => 'unmatched end tag',
3501                                    text => $token->{tag_name}, token => $token);
3502                  ## Ignore the token                  ## Ignore the token
3503                    !!!nack ('t243.1');
3504                  !!!next-token;                  !!!next-token;
3505                  redo B;                  next B;
3506                }                }
3507                                    
3508                splice @{$self->{open_elements}}, $i;                splice @{$self->{open_elements}}, $i;
# Line 4850  sub _tree_construction_main ($) { Line 3511  sub _tree_construction_main ($) {
3511                $self->_reset_insertion_mode;                $self->_reset_insertion_mode;
3512                                
3513                !!!next-token;                !!!next-token;
3514                redo B;                next B;
3515              } elsif ({              } elsif ({
3516                        tbody => 1, tfoot => 1, thead => 1,                        tbody => 1, tfoot => 1, thead => 1,
3517                       }->{$token->{tag_name}} and                       }->{$token->{tag_name}} and
3518                       $self->{insertion_mode} & ROW_IMS) {                       $self->{insertion_mode} & ROW_IMS) {
3519                if ($self->{insertion_mode} == IN_ROW_IM) {                if (($self->{insertion_mode} & IM_MASK) == IN_ROW_IM) {
3520                  ## have an element in table scope                  ## have an element in table scope
3521                  my $i;                  my $i;
3522                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3523                    my $node = $self->{open_elements}->[$_];                    my $node = $self->{open_elements}->[$_];
3524                    if ($node->[1] eq $token->{tag_name}) {                    if ($node->[0]->manakai_local_name eq $token->{tag_name}) {
3525                      !!!cp ('t247');                      !!!cp ('t247');
3526                      $i = $_;                      $i = $_;
3527                      last INSCOPE;                      last INSCOPE;
3528                    } elsif ({                    } elsif ($node->[1] & TABLE_SCOPING_EL) {
                             table => 1, html => 1,  
                            }->{$node->[1]}) {  
3529                      !!!cp ('t248');                      !!!cp ('t248');
3530                      last INSCOPE;                      last INSCOPE;
3531                    }                    }
3532                  } # INSCOPE                  } # INSCOPE
3533                    unless (defined $i) {                    unless (defined $i) {
3534                      !!!cp ('t249');                      !!!cp ('t249');
3535                      !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);                      !!!parse-error (type => 'unmatched end tag',
3536                                        text => $token->{tag_name}, token => $token);
3537                      ## Ignore the token                      ## Ignore the token
3538                        !!!nack ('t249.1');
3539                      !!!next-token;                      !!!next-token;
3540                      redo B;                      next B;
3541                    }                    }
3542                                    
3543                  ## As if </tr>                  ## As if </tr>
# Line 4884  sub _tree_construction_main ($) { Line 3545  sub _tree_construction_main ($) {
3545                  my $i;                  my $i;
3546                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                  INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3547                    my $node = $self->{open_elements}->[$_];                    my $node = $self->{open_elements}->[$_];
3548                    if ($node->[1] eq 'tr') {                    if ($node->[1] == TABLE_ROW_EL) {
3549                      !!!cp ('t250');                      !!!cp ('t250');
3550                      $i = $_;                      $i = $_;
3551                      last INSCOPE;                      last INSCOPE;
3552                    } elsif ({                    } elsif ($node->[1] & TABLE_SCOPING_EL) {
                             table => 1, html => 1,  
                            }->{$node->[1]}) {  
3553                      !!!cp ('t251');                      !!!cp ('t251');
3554                      last INSCOPE;                      last INSCOPE;
3555                    }                    }
3556                  } # INSCOPE                  } # INSCOPE
3557                    unless (defined $i) {                    unless (defined $i) {
3558                      !!!cp ('t252');                      !!!cp ('t252');
3559                      !!!parse-error (type => 'unmatched end tag:tr', token => $token);                      !!!parse-error (type => 'unmatched end tag',
3560                                        text => 'tr', token => $token);
3561                      ## Ignore the token                      ## Ignore the token
3562                        !!!nack ('t252.1');
3563                      !!!next-token;                      !!!next-token;
3564                      redo B;                      next B;
3565                    }                    }
3566                                    
3567                  ## Clear back to table row context                  ## Clear back to table row context
3568                  while (not {                  while (not ($self->{open_elements}->[-1]->[1]
3569                    tr => 1, html => 1,                                  & TABLE_ROW_SCOPING_EL)) {
                 }->{$self->{open_elements}->[-1]->[1]}) {  
3570                    !!!cp ('t253');                    !!!cp ('t253');
3571  ## ISSUE: Can this case be reached?  ## ISSUE: Can this case be reached?
3572                    pop @{$self->{open_elements}};                    pop @{$self->{open_elements}};
# Line 4921  sub _tree_construction_main ($) { Line 3581  sub _tree_construction_main ($) {
3581                my $i;                my $i;
3582                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3583                  my $node = $self->{open_elements}->[$_];                  my $node = $self->{open_elements}->[$_];
3584                  if ($node->[1] eq $token->{tag_name}) {                  if ($node->[0]->manakai_local_name eq $token->{tag_name}) {
3585                    !!!cp ('t254');                    !!!cp ('t254');
3586                    $i = $_;                    $i = $_;
3587                    last INSCOPE;                    last INSCOPE;
3588                  } elsif ({                  } elsif ($node->[1] & TABLE_SCOPING_EL) {
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
3589                    !!!cp ('t255');                    !!!cp ('t255');
3590                    last INSCOPE;                    last INSCOPE;
3591                  }                  }
3592                } # INSCOPE                } # INSCOPE
3593                unless (defined $i) {                unless (defined $i) {
3594                  !!!cp ('t256');                  !!!cp ('t256');
3595                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);                  !!!parse-error (type => 'unmatched end tag',
3596                                    text => $token->{tag_name}, token => $token);
3597                  ## Ignore the token                  ## Ignore the token
3598                    !!!nack ('t256.1');
3599                  !!!next-token;                  !!!next-token;
3600                  redo B;                  next B;
3601                }                }
3602    
3603                ## Clear back to table body context                ## Clear back to table body context
3604                while (not {                while (not ($self->{open_elements}->[-1]->[1]
3605                  tbody => 1, tfoot => 1, thead => 1, html => 1,                                & TABLE_ROWS_SCOPING_EL)) {
               }->{$self->{open_elements}->[-1]->[1]}) {  
3606                  !!!cp ('t257');                  !!!cp ('t257');
3607  ## ISSUE: Can this case be reached?  ## ISSUE: Can this case be reached?
3608                  pop @{$self->{open_elements}};                  pop @{$self->{open_elements}};
# Line 4951  sub _tree_construction_main ($) { Line 3610  sub _tree_construction_main ($) {
3610    
3611                pop @{$self->{open_elements}};                pop @{$self->{open_elements}};
3612                $self->{insertion_mode} = IN_TABLE_IM;                $self->{insertion_mode} = IN_TABLE_IM;
3613                  !!!nack ('t257.1');
3614                !!!next-token;                !!!next-token;
3615                redo B;                next B;
3616              } elsif ({              } elsif ({
3617                        body => 1, caption => 1, col => 1, colgroup => 1,                        body => 1, caption => 1, col => 1, colgroup => 1,
3618                        html => 1, td => 1, th => 1,                        html => 1, td => 1, th => 1,
3619                        tr => 1, # $self->{insertion_mode} == IN_ROW_IM                        tr => 1, # $self->{insertion_mode} == IN_ROW_IM
3620                        tbody => 1, tfoot => 1, thead => 1, # $self->{insertion_mode} == IN_TABLE_IM                        tbody => 1, tfoot => 1, thead => 1, # $self->{insertion_mode} == IN_TABLE_IM
3621                       }->{$token->{tag_name}}) {                       }->{$token->{tag_name}}) {
3622                !!!cp ('t258');            !!!cp ('t258');
3623                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);            !!!parse-error (type => 'unmatched end tag',
3624                ## Ignore the token                            text => $token->{tag_name}, token => $token);
3625                !!!next-token;            ## Ignore the token
3626                redo B;            !!!nack ('t258.1');
3627               !!!next-token;
3628              next B;
3629          } else {          } else {
3630            !!!cp ('t259');            !!!cp ('t259');
3631            !!!parse-error (type => 'in table:/'.$token->{tag_name}, token => $token);            !!!parse-error (type => 'in table:/',
3632                              text => $token->{tag_name}, token => $token);
3633    
3634            $insert = $insert_to_foster;            $insert = $insert_to_foster;
3635            #            #
3636          }          }
3637        } elsif ($token->{type} == END_OF_FILE_TOKEN) {        } elsif ($token->{type} == END_OF_FILE_TOKEN) {
3638          unless ($self->{open_elements}->[-1]->[1] eq 'html' and          unless ($self->{open_elements}->[-1]->[1] == HTML_EL and
3639                  @{$self->{open_elements}} == 1) { # redundant, maybe                  @{$self->{open_elements}} == 1) { # redundant, maybe
3640            !!!parse-error (type => 'in body:#eof', token => $token);            !!!parse-error (type => 'in body:#eof', token => $token);
3641            !!!cp ('t259.1');            !!!cp ('t259.1');
# Line 4987  sub _tree_construction_main ($) { Line 3650  sub _tree_construction_main ($) {
3650        } else {        } else {
3651          die "$0: $token->{type}: Unknown token type";          die "$0: $token->{type}: Unknown token type";
3652        }        }
3653      } elsif ($self->{insertion_mode} == IN_COLUMN_GROUP_IM) {      } elsif (($self->{insertion_mode} & IM_MASK) == IN_COLUMN_GROUP_IM) {
3654            if ($token->{type} == CHARACTER_TOKEN) {            if ($token->{type} == CHARACTER_TOKEN) {
3655              if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {              if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
3656                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);                $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
3657                unless (length $token->{data}) {                unless (length $token->{data}) {
3658                  !!!cp ('t260');                  !!!cp ('t260');
3659                  !!!next-token;                  !!!next-token;
3660                  redo B;                  next B;
3661                }                }
3662              }              }
3663                            
# Line 5005  sub _tree_construction_main ($) { Line 3668  sub _tree_construction_main ($) {
3668                !!!cp ('t262');                !!!cp ('t262');
3669                !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);                !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3670                pop @{$self->{open_elements}};                pop @{$self->{open_elements}};
3671                  !!!ack ('t262.1');
3672                !!!next-token;                !!!next-token;
3673                redo B;                next B;
3674              } else {              } else {
3675                !!!cp ('t263');                !!!cp ('t263');
3676                #                #
3677              }              }
3678            } elsif ($token->{type} == END_TAG_TOKEN) {            } elsif ($token->{type} == END_TAG_TOKEN) {
3679              if ($token->{tag_name} eq 'colgroup') {              if ($token->{tag_name} eq 'colgroup') {
3680                if ($self->{open_elements}->[-1]->[1] eq 'html') {                if ($self->{open_elements}->[-1]->[1] == HTML_EL) {
3681                  !!!cp ('t264');                  !!!cp ('t264');
3682                  !!!parse-error (type => 'unmatched end tag:colgroup', token => $token);                  !!!parse-error (type => 'unmatched end tag',
3683                                    text => 'colgroup', token => $token);
3684                  ## Ignore the token                  ## Ignore the token
3685                  !!!next-token;                  !!!next-token;
3686                  redo B;                  next B;
3687                } else {                } else {
3688                  !!!cp ('t265');                  !!!cp ('t265');
3689                  pop @{$self->{open_elements}}; # colgroup                  pop @{$self->{open_elements}}; # colgroup
3690                  $self->{insertion_mode} = IN_TABLE_IM;                  $self->{insertion_mode} = IN_TABLE_IM;
3691                  !!!next-token;                  !!!next-token;
3692                  redo B;                              next B;            
3693                }                }
3694              } elsif ($token->{tag_name} eq 'col') {              } elsif ($token->{tag_name} eq 'col') {
3695                !!!cp ('t266');                !!!cp ('t266');
3696                !!!parse-error (type => 'unmatched end tag:col', token => $token);                !!!parse-error (type => 'unmatched end tag',
3697                                  text => 'col', token => $token);
3698                ## Ignore the token                ## Ignore the token
3699                !!!next-token;                !!!next-token;
3700                redo B;                next B;
3701              } else {              } else {
3702                !!!cp ('t267');                !!!cp ('t267');
3703                #                #
3704              }              }
3705        } elsif ($token->{type} == END_OF_FILE_TOKEN) {        } elsif ($token->{type} == END_OF_FILE_TOKEN) {
3706          if ($self->{open_elements}->[-1]->[1] eq 'html' or          if ($self->{open_elements}->[-1]->[1] == HTML_EL and
3707              @{$self->{open_elements}} == 1) { # redundant, maybe              @{$self->{open_elements}} == 1) { # redundant, maybe
3708            !!!cp ('t270.2');            !!!cp ('t270.2');
3709            ## Stop parsing.            ## Stop parsing.
# Line 5048  sub _tree_construction_main ($) { Line 3714  sub _tree_construction_main ($) {
3714            pop @{$self->{open_elements}}; # colgroup            pop @{$self->{open_elements}}; # colgroup
3715            $self->{insertion_mode} = IN_TABLE_IM;            $self->{insertion_mode} = IN_TABLE_IM;
3716            ## Reprocess.            ## Reprocess.
3717            redo B;            next B;
3718          }          }
3719        } else {        } else {
3720          die "$0: $token->{type}: Unknown token type";          die "$0: $token->{type}: Unknown token type";
3721        }        }
3722    
3723            ## As if </colgroup>            ## As if </colgroup>
3724            if ($self->{open_elements}->[-1]->[1] eq 'html') {            if ($self->{open_elements}->[-1]->[1] == HTML_EL) {
3725              !!!cp ('t269');              !!!cp ('t269');
3726  ## TODO: Wrong error type?  ## TODO: Wrong error type?
3727              !!!parse-error (type => 'unmatched end tag:colgroup', token => $token);              !!!parse-error (type => 'unmatched end tag',
3728                                text => 'colgroup', token => $token);
3729              ## Ignore the token              ## Ignore the token
3730                !!!nack ('t269.1');
3731              !!!next-token;              !!!next-token;
3732              redo B;              next B;
3733            } else {            } else {
3734              !!!cp ('t270');              !!!cp ('t270');
3735              pop @{$self->{open_elements}}; # colgroup              pop @{$self->{open_elements}}; # colgroup
3736              $self->{insertion_mode} = IN_TABLE_IM;              $self->{insertion_mode} = IN_TABLE_IM;
3737                !!!ack-later;
3738              ## reprocess              ## reprocess
3739              redo B;              next B;
3740            }            }
3741      } elsif ($self->{insertion_mode} & SELECT_IMS) {      } elsif ($self->{insertion_mode} & SELECT_IMS) {
3742        if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == CHARACTER_TOKEN) {
3743          !!!cp ('t271');          !!!cp ('t271');
3744          $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});          $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data});
3745          !!!next-token;          !!!next-token;
3746          redo B;          next B;
3747        } elsif ($token->{type} == START_TAG_TOKEN) {        } elsif ($token->{type} == START_TAG_TOKEN) {
3748              if ($token->{tag_name} eq 'option') {          if ($token->{tag_name} eq 'option') {
3749                if ($self->{open_elements}->[-1]->[1] eq 'option') {            if ($self->{open_elements}->[-1]->[1] == OPTION_EL) {
3750                  !!!cp ('t272');              !!!cp ('t272');
3751                  ## As if </option>              ## As if </option>
3752                  pop @{$self->{open_elements}};              pop @{$self->{open_elements}};
3753                } else {            } else {
3754                  !!!cp ('t273');              !!!cp ('t273');
3755                }            }
3756    
3757                !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);            !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3758                !!!next-token;            !!!nack ('t273.1');
3759                redo B;            !!!next-token;
3760              } elsif ($token->{tag_name} eq 'optgroup') {            next B;
3761                if ($self->{open_elements}->[-1]->[1] eq 'option') {          } elsif ($token->{tag_name} eq 'optgroup') {
3762                  !!!cp ('t274');            if ($self->{open_elements}->[-1]->[1] == OPTION_EL) {
3763                  ## As if </option>              !!!cp ('t274');
3764                  pop @{$self->{open_elements}};              ## As if </option>
3765                } else {              pop @{$self->{open_elements}};
3766                  !!!cp ('t275');            } else {
3767                }              !!!cp ('t275');
3768              }
3769    
3770                if ($self->{open_elements}->[-1]->[1] eq 'optgroup') {            if ($self->{open_elements}->[-1]->[1] == OPTGROUP_EL) {
3771                  !!!cp ('t276');              !!!cp ('t276');
3772                  ## As if </optgroup>              ## As if </optgroup>
3773                  pop @{$self->{open_elements}};              pop @{$self->{open_elements}};
3774                } else {            } else {
3775                  !!!cp ('t277');              !!!cp ('t277');
3776                }            }
3777    
3778                !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);            !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
3779                !!!next-token;            !!!nack ('t277.1');
3780                redo B;            !!!next-token;
3781          } elsif ($token->{tag_name} eq 'select' or            next B;
3782                   $token->{tag_name} eq 'input' or          } elsif ({
3783                   ($self->{insertion_mode} == IN_SELECT_IN_TABLE_IM and                     select => 1, input => 1, textarea => 1, keygen => 1,
3784                     }->{$token->{tag_name}} or
3785                     (($self->{insertion_mode} & IM_MASK)
3786                          == IN_SELECT_IN_TABLE_IM and
3787                    {                    {
3788                     caption => 1, table => 1,                     caption => 1, table => 1,
3789                     tbody => 1, tfoot => 1, thead => 1,                     tbody => 1, tfoot => 1, thead => 1,
3790                     tr => 1, td => 1, th => 1,                     tr => 1, td => 1, th => 1,
3791                    }->{$token->{tag_name}})) {                    }->{$token->{tag_name}})) {
3792            ## TODO: The type below is not good - <select> is replaced by </select>  
3793            !!!parse-error (type => 'not closed:select', token => $token);            ## 1. Parse error.
3794            ## NOTE: As if the token were </select> (<select> case) or            if ($token->{tag_name} eq 'select') {
3795            ## as if there were </select> (otherwise).                !!!parse-error (type => 'select in select', ## XXX: documentation
3796                ## have an element in table scope                                token => $token);
3797                my $i;            } else {
3798                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {              !!!parse-error (type => 'not closed', text => 'select',
3799                  my $node = $self->{open_elements}->[$_];                              token => $token);
3800                  if ($node->[1] eq 'select') {            }
3801                    !!!cp ('t278');  
3802                    $i = $_;            ## 2./<select>-1. Unless "have an element in table scope" (select):
3803                    last INSCOPE;            my $i;
3804                  } elsif ({            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3805                            table => 1, html => 1,              my $node = $self->{open_elements}->[$_];
3806                           }->{$node->[1]}) {              if ($node->[1] == SELECT_EL) {
3807                    !!!cp ('t279');                !!!cp ('t278');
3808                    last INSCOPE;                $i = $_;
3809                  }                last INSCOPE;
3810                } # INSCOPE              } elsif ($node->[1] & TABLE_SCOPING_EL) {
3811                unless (defined $i) {                !!!cp ('t279');
3812                  !!!cp ('t280');                last INSCOPE;
3813                  !!!parse-error (type => 'unmatched end tag:select', token => $token);              }
3814                  ## Ignore the token            } # INSCOPE
3815                  !!!next-token;            unless (defined $i) {
3816                  redo B;              !!!cp ('t280');
3817                }              if ($token->{tag_name} eq 'select') {
3818                  ## NOTE: This error would be raised when
3819                  ## |select.innerHTML = '<select>'| is executed; in this
3820                  ## case two errors, "select in select" and "unmatched
3821                  ## end tags" are reported to the user, the latter might
3822                  ## be confusing but this is what the spec requires.
3823                  !!!parse-error (type => 'unmatched end tag',
3824                                  text => 'select',
3825                                  token => $token);
3826                }
3827                ## Ignore the token.
3828                !!!nack ('t280.1');
3829                !!!next-token;
3830                next B;
3831              }
3832    
3833              ## 3. Otherwise, as if there were <select>:
3834                                
3835                !!!cp ('t281');            !!!cp ('t281');
3836                splice @{$self->{open_elements}}, $i;            splice @{$self->{open_elements}}, $i;
3837    
3838                $self->_reset_insertion_mode;            $self->_reset_insertion_mode;
3839    
3840            if ($token->{tag_name} eq 'select') {            if ($token->{tag_name} eq 'select') {
3841              !!!cp ('t281.2');              !!!nack ('t281.2');
3842              !!!next-token;              !!!next-token;
3843              redo B;              next B;
3844            } else {            } else {
3845              !!!cp ('t281.1');              !!!cp ('t281.1');
3846                !!!ack-later;
3847              ## Reprocess the token.              ## Reprocess the token.
3848              redo B;              next B;
3849            }            }
3850            } elsif ($token->{tag_name} eq 'script') {
3851              !!!cp ('t281.3');
3852              ## NOTE: This is an "as if in head" code clone
3853              $script_start_tag->();
3854              next B;
3855          } else {          } else {
3856            !!!cp ('t282');            !!!cp ('t282');
3857            !!!parse-error (type => 'in select:'.$token->{tag_name}, token => $token);            !!!parse-error (type => 'in select',
3858                              text => $token->{tag_name}, token => $token);
3859            ## Ignore the token            ## Ignore the token
3860              !!!nack ('t282.1');
3861            !!!next-token;            !!!next-token;
3862            redo B;            next B;
3863          }          }
3864        } elsif ($token->{type} == END_TAG_TOKEN) {        } elsif ($token->{type} == END_TAG_TOKEN) {
3865              if ($token->{tag_name} eq 'optgroup') {          if ($token->{tag_name} eq 'optgroup') {
3866                if ($self->{open_elements}->[-1]->[1] eq 'option' and            if ($self->{open_elements}->[-1]->[1] == OPTION_EL and
3867                    $self->{open_elements}->[-2]->[1] eq 'optgroup') {                $self->{open_elements}->[-2]->[1] == OPTGROUP_EL) {
3868                  !!!cp ('t283');              !!!cp ('t283');
3869                  ## As if </option>              ## As if </option>
3870                  splice @{$self->{open_elements}}, -2;              splice @{$self->{open_elements}}, -2;
3871                } elsif ($self->{open_elements}->[-1]->[1] eq 'optgroup') {            } elsif ($self->{open_elements}->[-1]->[1] == OPTGROUP_EL) {
3872                  !!!cp ('t284');              !!!cp ('t284');
3873                  pop @{$self->{open_elements}};              pop @{$self->{open_elements}};
3874                } else {            } else {
3875                  !!!cp ('t285');              !!!cp ('t285');
3876                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);              !!!parse-error (type => 'unmatched end tag',
3877                  ## Ignore the token                              text => $token->{tag_name}, token => $token);
3878                }              ## Ignore the token
3879                !!!next-token;            }
3880                redo B;            !!!nack ('t285.1');
3881              } elsif ($token->{tag_name} eq 'option') {            !!!next-token;
3882                if ($self->{open_elements}->[-1]->[1] eq 'option') {            next B;
3883                  !!!cp ('t286');          } elsif ($token->{tag_name} eq 'option') {
3884                  pop @{$self->{open_elements}};            if ($self->{open_elements}->[-1]->[1] == OPTION_EL) {
3885                } else {              !!!cp ('t286');
3886                  !!!cp ('t287');              pop @{$self->{open_elements}};
3887                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);            } else {
3888                  ## Ignore the token              !!!cp ('t287');
3889                }              !!!parse-error (type => 'unmatched end tag',
3890                !!!next-token;                              text => $token->{tag_name}, token => $token);
3891                redo B;              ## Ignore the token
3892              } elsif ($token->{tag_name} eq 'select') {            }
3893                ## have an element in table scope            !!!nack ('t287.1');
3894                my $i;            !!!next-token;
3895                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {            next B;
3896                  my $node = $self->{open_elements}->[$_];          } elsif ($token->{tag_name} eq 'select') {
3897                  if ($node->[1] eq $token->{tag_name}) {            ## have an element in table scope
3898                    !!!cp ('t288');            my $i;
3899                    $i = $_;            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3900                    last INSCOPE;              my $node = $self->{open_elements}->[$_];
3901                  } elsif ({              if ($node->[1] == SELECT_EL) {
3902                            table => 1, html => 1,                !!!cp ('t288');
3903                           }->{$node->[1]}) {                $i = $_;
3904                    !!!cp ('t289');                last INSCOPE;
3905                    last INSCOPE;              } elsif ($node->[1] & TABLE_SCOPING_EL) {
3906                  }                !!!cp ('t289');
3907                } # INSCOPE                last INSCOPE;
3908                unless (defined $i) {              }
3909                  !!!cp ('t290');            } # INSCOPE
3910                  !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);            unless (defined $i) {
3911                  ## Ignore the token              !!!cp ('t290');
3912                  !!!next-token;              !!!parse-error (type => 'unmatched end tag',
3913                  redo B;                              text => $token->{tag_name}, token => $token);
3914                }              ## Ignore the token
3915                !!!nack ('t290.1');
3916                !!!next-token;
3917                next B;
3918              }
3919                                
3920                !!!cp ('t291');            !!!cp ('t291');
3921                splice @{$self->{open_elements}}, $i;            splice @{$self->{open_elements}}, $i;
3922    
3923                $self->_reset_insertion_mode;            $self->_reset_insertion_mode;
3924    
3925                !!!next-token;            !!!nack ('t291.1');
3926                redo B;            !!!next-token;
3927          } elsif ($self->{insertion_mode} == IN_SELECT_IN_TABLE_IM and            next B;
3928            } elsif (($self->{insertion_mode} & IM_MASK)
3929                         == IN_SELECT_IN_TABLE_IM and
3930                   {                   {
3931                    caption => 1, table => 1, tbody => 1,                    caption => 1, table => 1, tbody => 1,
3932                    tfoot => 1, thead => 1, tr => 1, td => 1, th => 1,                    tfoot => 1, thead => 1, tr => 1, td => 1, th => 1,
3933                   }->{$token->{tag_name}}) {                   }->{$token->{tag_name}}) {
3934  ## TODO: The following is wrong?  ## TODO: The following is wrong?
3935                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);            !!!parse-error (type => 'unmatched end tag',
3936                              text => $token->{tag_name}, token => $token);
3937                                
3938                ## have an element in table scope            ## have an element in table scope
3939                my $i;            my $i;
3940                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3941                  my $node = $self->{open_elements}->[$_];              my $node = $self->{open_elements}->[$_];
3942                  if ($node->[1] eq $token->{tag_name}) {              if ($node->[0]->manakai_local_name eq $token->{tag_name}) {
3943                    !!!cp ('t292');                !!!cp ('t292');
3944                    $i = $_;                $i = $_;
3945                    last INSCOPE;                last INSCOPE;
3946                  } elsif ({              } elsif ($node->[1] & TABLE_SCOPING_EL) {
3947                            table => 1, html => 1,                !!!cp ('t293');
3948                           }->{$node->[1]}) {                last INSCOPE;
3949                    !!!cp ('t293');              }
3950                    last INSCOPE;            } # INSCOPE
3951                  }            unless (defined $i) {
3952                } # INSCOPE              !!!cp ('t294');
3953                unless (defined $i) {              ## Ignore the token
3954                  !!!cp ('t294');              !!!nack ('t294.1');
3955                  ## Ignore the token              !!!next-token;
3956                  !!!next-token;              next B;
3957                  redo B;            }
               }  
3958                                
3959                ## As if </select>            ## As if </select>
3960                ## have an element in table scope            ## have an element in table scope
3961                undef $i;            undef $i;
3962                INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
3963                  my $node = $self->{open_elements}->[$_];              my $node = $self->{open_elements}->[$_];
3964                  if ($node->[1] eq 'select') {              if ($node->[1] == SELECT_EL) {
3965                    !!!cp ('t295');                !!!cp ('t295');
3966                    $i = $_;                $i = $_;
3967                    last INSCOPE;                last INSCOPE;
3968                  } elsif ({              } elsif ($node->[1] & TABLE_SCOPING_EL) {
                           table => 1, html => 1,  
                          }->{$node->[1]}) {  
3969  ## ISSUE: Can this state be reached?  ## ISSUE: Can this state be reached?
3970                    !!!cp ('t296');                !!!cp ('t296');
3971                    last INSCOPE;                last INSCOPE;
3972                  }              }
3973                } # INSCOPE            } # INSCOPE
3974                unless (defined $i) {            unless (defined $i) {
3975                  !!!cp ('t297');              !!!cp ('t297');
3976  ## TODO: The following error type is correct?  ## TODO: The following error type is correct?
3977                  !!!parse-error (type => 'unmatched end tag:select', token => $token);              !!!parse-error (type => 'unmatched end tag',
3978                  ## Ignore the </select> token                              text => 'select', token => $token);
3979                  !!!next-token; ## TODO: ok?              ## Ignore the </select> token
3980                  redo B;              !!!nack ('t297.1');
3981                }              !!!next-token; ## TODO: ok?
3982                next B;
3983              }
3984                                
3985                !!!cp ('t298');            !!!cp ('t298');
3986                splice @{$self->{open_elements}}, $i;            splice @{$self->{open_elements}}, $i;
3987    
3988                $self->_reset_insertion_mode;            $self->_reset_insertion_mode;
3989    
3990                ## reprocess            !!!ack-later;
3991                redo B;            ## reprocess
3992              next B;
3993          } else {          } else {
3994            !!!cp ('t299');            !!!cp ('t299');
3995            !!!parse-error (type => 'in select:/'.$token->{tag_name}, token => $token);            !!!parse-error (type => 'in select:/',
3996                              text => $token->{tag_name}, token => $token);
3997            ## Ignore the token            ## Ignore the token
3998              !!!nack ('t299.3');
3999            !!!next-token;            !!!next-token;
4000            redo B;            next B;
4001          }          }
4002        } elsif ($token->{type} == END_OF_FILE_TOKEN) {        } elsif ($token->{type} == END_OF_FILE_TOKEN) {
4003          unless ($self->{open_elements}->[-1]->[1] eq 'html' and          unless ($self->{open_elements}->[-1]->[1] == HTML_EL and
4004                  @{$self->{open_elements}} == 1) { # redundant, maybe                  @{$self->{open_elements}} == 1) { # redundant, maybe
4005            !!!cp ('t299.1');            !!!cp ('t299.1');
4006            !!!parse-error (type => 'in body:#eof', token => $token);            !!!parse-error (type => 'in body:#eof', token => $token);
# Line 5309  sub _tree_construction_main ($) { Line 4015  sub _tree_construction_main ($) {
4015        }        }
4016      } elsif ($self->{insertion_mode} & BODY_AFTER_IMS) {      } elsif ($self->{insertion_mode} & BODY_AFTER_IMS) {
4017        if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == CHARACTER_TOKEN) {
4018          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
4019            my $data = $1;            my $data = $1;
4020            ## As if in body            ## As if in body
4021            $reconstruct_active_formatting_elements->($insert_to_current);            $reconstruct_active_formatting_elements->($insert_to_current);
# Line 5319  sub _tree_construction_main ($) { Line 4025  sub _tree_construction_main ($) {
4025            unless (length $token->{data}) {            unless (length $token->{data}) {
4026              !!!cp ('t300');              !!!cp ('t300');
4027              !!!next-token;              !!!next-token;
4028              redo B;              next B;
4029            }            }
4030          }          }
4031                    
4032          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4033            !!!cp ('t301');            !!!cp ('t301');
4034            !!!parse-error (type => 'after html:#character', token => $token);            !!!parse-error (type => 'after html:#text', token => $token);
4035              #
           ## Reprocess in the "after body" insertion mode.  
4036          } else {          } else {
4037            !!!cp ('t302');            !!!cp ('t302');
4038              ## "after body" insertion mode
4039              !!!parse-error (type => 'after body:#text', token => $token);
4040              #
4041          }          }
           
         ## "after body" insertion mode  
         !!!parse-error (type => 'after body:#character', token => $token);  
4042    
4043          $self->{insertion_mode} = IN_BODY_IM;          $self->{insertion_mode} = IN_BODY_IM;
4044          ## reprocess          ## reprocess
4045          redo B;          next B;
4046        } elsif ($token->{type} == START_TAG_TOKEN) {        } elsif ($token->{type} == START_TAG_TOKEN) {
4047          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4048            !!!cp ('t303');            !!!cp ('t303');
4049            !!!parse-error (type => 'after html:'.$token->{tag_name}, token => $token);            !!!parse-error (type => 'after html',
4050                                        text => $token->{tag_name}, token => $token);
4051            ## Reprocess in the "after body" insertion mode.            #
4052          } else {          } else {
4053            !!!cp ('t304');            !!!cp ('t304');
4054              ## "after body" insertion mode
4055              !!!parse-error (type => 'after body',
4056                              text => $token->{tag_name}, token => $token);
4057              #
4058          }          }
4059    
         ## "after body" insertion mode  
         !!!parse-error (type => 'after body:'.$token->{tag_name}, token => $token);  
   
4060          $self->{insertion_mode} = IN_BODY_IM;          $self->{insertion_mode} = IN_BODY_IM;
4061            !!!ack-later;
4062          ## reprocess          ## reprocess
4063          redo B;          next B;
4064        } elsif ($token->{type} == END_TAG_TOKEN) {        } elsif ($token->{type} == END_TAG_TOKEN) {
4065          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {          if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) {
4066            !!!cp ('t305');            !!!cp ('t305');
4067            !!!parse-error (type => 'after html:/'.$token->{tag_name}, token => $token);            !!!parse-error (type => 'after html:/',
4068                              text => $token->{tag_name}, token => $token);
4069                        
4070            $self->{insertion_mode} = AFTER_BODY_IM;            $self->{insertion_mode} = IN_BODY_IM;
4071            ## Reprocess in the "after body" insertion mode.            ## Reprocess.
4072              next B;
4073          } else {          } else {
4074            !!!cp ('t306');            !!!cp ('t306');
4075          }          }
# Line 5369  sub _tree_construction_main ($) { Line 4078  sub _tree_construction_main ($) {
4078          if ($token->{tag_name} eq 'html') {          if ($token->{tag_name} eq 'html') {
4079            if (defined $self->{inner_html_node}) {            if (defined $self->{inner_html_node}) {
4080              !!!cp ('t307');              !!!cp ('t307');
4081              !!!parse-error (type => 'unmatched end tag:html', token => $token);              !!!parse-error (type => 'unmatched end tag',
4082                                text => 'html', token => $token);
4083              ## Ignore the token              ## Ignore the token
4084              !!!next-token;              !!!next-token;
4085              redo B;              next B;
4086            } else {            } else {
4087              !!!cp ('t308');              !!!cp ('t308');
4088              $self->{insertion_mode} = AFTER_HTML_BODY_IM;              $self->{insertion_mode} = AFTER_HTML_BODY_IM;
4089              !!!next-token;              !!!next-token;
4090              redo B;              next B;
4091            }            }
4092          } else {          } else {
4093            !!!cp ('t309');            !!!cp ('t309');
4094            !!!parse-error (type => 'after body:/'.$token->{tag_name}, token => $token);            !!!parse-error (type => 'after body:/',
4095                              text => $token->{tag_name}, token => $token);
4096    
4097            $self->{insertion_mode} = IN_BODY_IM;            $self->{insertion_mode} = IN_BODY_IM;
4098            ## reprocess            ## reprocess
4099            redo B;            next B;
4100          }          }
4101        } elsif ($token->{type} == END_OF_FILE_TOKEN) {        } elsif ($token->{type} == END_OF_FILE_TOKEN) {
4102          !!!cp ('t309.2');          !!!cp ('t309.2');
# Line 5396  sub _tree_construction_main ($) { Line 4107  sub _tree_construction_main ($) {
4107        }        }
4108      } elsif ($self->{insertion_mode} & FRAME_IMS) {      } elsif ($self->{insertion_mode} & FRAME_IMS) {
4109        if ($token->{type} == CHARACTER_TOKEN) {        if ($token->{type} == CHARACTER_TOKEN) {
4110          if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) {          if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) {
4111            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);            $self->{open_elements}->[-1]->[0]->manakai_append_text ($1);
4112                        
4113            unless (length $token->{data}) {            unless (length $token->{data}) {
4114              !!!cp ('t310');              !!!cp ('t310');
4115              !!!next-token;              !!!next-token;
4116              redo B;              next B;
4117            }            }
4118          }          }
4119                    
4120          if ($token->{data} =~ s/^[^\x09\x0A\x0B\x0C\x20]+//) {          if ($token->{data} =~ s/^[^\x09\x0A\x0C\x20]+//) {
4121            if ($self->{insertion_mode} == IN_FRAMESET_IM) {            if ($self->{insertion_mode} == IN_FRAMESET_IM) {
4122              !!!cp ('t311');              !!!cp ('t311');
4123              !!!parse-error (type => 'in frameset:#character', token => $token);              !!!parse-error (type => 'in frameset:#text', token => $token);
4124            } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) {            } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) {
4125              !!!cp ('t312');              !!!cp ('t312');
4126              !!!parse-error (type => 'after frameset:#character', token => $token);              !!!parse-error (type => 'after frameset:#text', token => $token);
4127            } else { # "after html frameset"            } else { # "after after frameset"
4128              !!!cp ('t313');              !!!cp ('t313');
4129              !!!parse-error (type => 'after html:#character', token => $token);              !!!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:#character', token => $token);  
4130            }            }
4131                        
4132            ## Ignore the token.            ## Ignore the token.
# Line 5430  sub _tree_construction_main ($) { Line 4137  sub _tree_construction_main ($) {
4137              !!!cp ('t315');              !!!cp ('t315');
4138              !!!next-token;              !!!next-token;
4139            }            }
4140            redo B;            next B;
4141          }          }
4142                    
4143          die qq[$0: Character "$token->{data}"];          die qq[$0: Character "$token->{data}"];
4144        } elsif ($token->{type} == START_TAG_TOKEN) {        } elsif ($token->{type} == START_TAG_TOKEN) {
         if ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {  
           !!!cp ('t316');  
           !!!parse-error (type => 'after html:'.$token->{tag_name}, token => $token);  
   
           $self->{insertion_mode} = AFTER_FRAMESET_IM;  
           ## Process in the "after frameset" insertion mode.  
         } else {  
           !!!cp ('t317');  
         }  
   
4145          if ($token->{tag_name} eq 'frameset' and          if ($token->{tag_name} eq 'frameset' and
4146              $self->{insertion_mode} == IN_FRAMESET_IM) {              $self->{insertion_mode} == IN_FRAMESET_IM) {
4147            !!!cp ('t318');            !!!cp ('t318');
4148            !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);            !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
4149              !!!nack ('t318.1');
4150            !!!next-token;            !!!next-token;
4151            redo B;            next B;
4152          } elsif ($token->{tag_name} eq 'frame' and          } elsif ($token->{tag_name} eq 'frame' and
4153                   $self->{insertion_mode} == IN_FRAMESET_IM) {                   $self->{insertion_mode} == IN_FRAMESET_IM) {
4154            !!!cp ('t319');            !!!cp ('t319');
4155            !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);            !!!insert-element ($token->{tag_name}, $token->{attributes}, $token);
4156            pop @{$self->{open_elements}};            pop @{$self->{open_elements}};
4157              !!!ack ('t319.1');
4158            !!!next-token;            !!!next-token;
4159            redo B;            next B;
4160          } elsif ($token->{tag_name} eq 'noframes') {          } elsif ($token->{tag_name} eq 'noframes') {
4161            !!!cp ('t320');            !!!cp ('t320');
4162            ## NOTE: As if in body.            ## NOTE: As if in head.
4163            $parse_rcdata->(CDATA_CONTENT_MODEL);            $parse_rcdata->(CDATA_CONTENT_MODEL);
4164            redo B;            next B;
4165    
4166              ## NOTE: |<!DOCTYPE HTML><frameset></frameset></html><noframes></noframes>|
4167              ## has no parse error.
4168          } else {          } else {
4169            if ($self->{insertion_mode} == IN_FRAMESET_IM) {            if ($self->{insertion_mode} == IN_FRAMESET_IM) {
4170              !!!cp ('t321');              !!!cp ('t321');
4171              !!!parse-error (type => 'in frameset:'.$token->{tag_name}, token => $token);              !!!parse-error (type => 'in frameset',
4172            } else {                              text => $token->{tag_name}, token => $token);
4173              } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) {
4174              !!!cp ('t322');              !!!cp ('t322');
4175              !!!parse-error (type => 'after frameset:'.$token->{tag_name}, token => $token);              !!!parse-error (type => 'after frameset',
4176                                text => $token->{tag_name}, token => $token);
4177              } else { # "after after frameset"
4178                !!!cp ('t322.2');
4179                !!!parse-error (type => 'after after frameset',
4180                                text => $token->{tag_name}, token => $token);
4181            }            }
4182            ## Ignore the token            ## Ignore the token
4183              !!!nack ('t322.1');
4184            !!!next-token;            !!!next-token;
4185            redo B;            next B;
4186          }          }
4187        } elsif ($token->{type} == END_TAG_TOKEN) {        } elsif ($token->{type} == END_TAG_TOKEN) {
         if ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) {  
           !!!cp ('t323');  
           !!!parse-error (type => 'after html:/'.$token->{tag_name}, token => $token);  
   
           $self->{insertion_mode} = AFTER_FRAMESET_IM;  
           ## Process in the "after frameset" insertion mode.  
         } else {  
           !!!cp ('t324');  
         }  
   
4188          if ($token->{tag_name} eq 'frameset' and          if ($token->{tag_name} eq 'frameset' and
4189              $self->{insertion_mode} == IN_FRAMESET_IM) {              $self->{insertion_mode} == IN_FRAMESET_IM) {
4190            if ($self->{open_elements}->[-1]->[1] eq 'html' and            if ($self->{open_elements}->[-1]->[1] == HTML_EL and
4191                @{$self->{open_elements}} == 1) {                @{$self->{open_elements}} == 1) {
4192              !!!cp ('t325');              !!!cp ('t325');
4193              !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);              !!!parse-error (type => 'unmatched end tag',
4194                                text => $token->{tag_name}, token => $token);
4195              ## Ignore the token              ## Ignore the token
4196              !!!next-token;              !!!next-token;
4197            } else {            } else {
# Line 5501  sub _tree_construction_main ($) { Line 4201  sub _tree_construction_main ($) {
4201            }            }
4202    
4203            if (not defined $self->{inner_html_node} and            if (not defined $self->{inner_html_node} and
4204                $self->{open_elements}->[-1]->[1] ne 'frameset') {                not ($self->{open_elements}->[-1]->[1] == FRAMESET_EL)) {
4205              !!!cp ('t327');              !!!cp ('t327');
4206              $self->{insertion_mode} = AFTER_FRAMESET_IM;              $self->{insertion_mode} = AFTER_FRAMESET_IM;
4207            } else {            } else {
4208              !!!cp ('t328');              !!!cp ('t328');
4209            }            }
4210            redo B;            next B;
4211          } elsif ($token->{tag_name} eq 'html' and          } elsif ($token->{tag_name} eq 'html' and
4212                   $self->{insertion_mode} == AFTER_FRAMESET_IM) {                   $self->{insertion_mode} == AFTER_FRAMESET_IM) {
4213            !!!cp ('t329');            !!!cp ('t329');
4214            $self->{insertion_mode} = AFTER_HTML_FRAMESET_IM;            $self->{insertion_mode} = AFTER_HTML_FRAMESET_IM;
4215            !!!next-token;            !!!next-token;
4216            redo B;            next B;
4217          } else {          } else {
4218            if ($self->{insertion_mode} == IN_FRAMESET_IM) {            if ($self->{insertion_mode} == IN_FRAMESET_IM) {
4219              !!!cp ('t330');              !!!cp ('t330');
4220              !!!parse-error (type => 'in frameset:/'.$token->{tag_name}, token => $token);              !!!parse-error (type => 'in frameset:/',
4221            } else {                              text => $token->{tag_name}, token => $token);
4222              } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) {
4223                !!!cp ('t330.1');
4224                !!!parse-error (type => 'after frameset:/',
4225                                text => $token->{tag_name}, token => $token);
4226              } else { # "after after html"
4227              !!!cp ('t331');              !!!cp ('t331');
4228              !!!parse-error (type => 'after frameset:/'.$token->{tag_name}, token => $token);              !!!parse-error (type => 'after after frameset:/',
4229                                text => $token->{tag_name}, token => $token);
4230            }            }
4231            ## Ignore the token            ## Ignore the token
4232            !!!next-token;            !!!next-token;
4233            redo B;            next B;
4234          }          }
4235        } elsif ($token->{type} == END_OF_FILE_TOKEN) {        } elsif ($token->{type} == END_OF_FILE_TOKEN) {
4236          unless ($self->{open_elements}->[-1]->[1] eq 'html' and          unless ($self->{open_elements}->[-1]->[1] == HTML_EL and
4237                  @{$self->{open_elements}} == 1) { # redundant, maybe                  @{$self->{open_elements}} == 1) { # redundant, maybe
4238            !!!cp ('t331.1');            !!!cp ('t331.1');
4239            !!!parse-error (type => 'in body:#eof', token => $token);            !!!parse-error (type => 'in body:#eof', token => $token);
# Line 5540  sub _tree_construction_main ($) { Line 4246  sub _tree_construction_main ($) {
4246        } else {        } else {
4247          die "$0: $token->{type}: Unknown token type";          die "$0: $token->{type}: Unknown token type";
4248        }        }
   
       ## ISSUE: An issue in spec here  
4249      } else {      } else {
4250        die "$0: $self->{insertion_mode}: Unknown insertion mode";        die "$0: $self->{insertion_mode}: Unknown insertion mode";
4251      }      }
# Line 5552  sub _tree_construction_main ($) { Line 4256  sub _tree_construction_main ($) {
4256          !!!cp ('t332');          !!!cp ('t332');
4257          ## NOTE: This is an "as if in head" code clone          ## NOTE: This is an "as if in head" code clone
4258          $script_start_tag->();          $script_start_tag->();
4259          redo B;          next B;
4260        } elsif ($token->{tag_name} eq 'style') {        } elsif ($token->{tag_name} eq 'style') {
4261          !!!cp ('t333');          !!!cp ('t333');
4262          ## NOTE: This is an "as if in head" code clone          ## NOTE: This is an "as if in head" code clone
4263          $parse_rcdata->(CDATA_CONTENT_MODEL);          $parse_rcdata->(CDATA_CONTENT_MODEL);
4264          redo B;          next B;
4265        } elsif ({        } elsif ({
4266                  base => 1, link => 1,                  base => 1, command => 1, link => 1,
4267                 }->{$token->{tag_name}}) {                 }->{$token->{tag_name}}) {
4268          !!!cp ('t334');          !!!cp ('t334');
4269          ## NOTE: This is an "as if in head" code clone, only "-t" differs          ## NOTE: This is an "as if in head" code clone, only "-t" differs
4270          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4271          pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.          pop @{$self->{open_elements}};
4272            !!!ack ('t334.1');
4273          !!!next-token;          !!!next-token;
4274          redo B;          next B;
4275        } elsif ($token->{tag_name} eq 'meta') {        } elsif ($token->{tag_name} eq 'meta') {
4276          ## NOTE: This is an "as if in head" code clone, only "-t" differs          ## NOTE: This is an "as if in head" code clone, only "-t" differs
4277          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4278          my $meta_el = pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec.          my $meta_el = pop @{$self->{open_elements}};
4279    
4280          unless ($self->{confident}) {          unless ($self->{confident}) {
4281            if ($token->{attributes}->{charset}) { ## TODO: And if supported            if ($token->{attributes}->{charset}) {
4282              !!!cp ('t335');              !!!cp ('t335');
4283                ## NOTE: Whether the encoding is supported or not is handled
4284                ## in the {change_encoding} callback.
4285              $self->{change_encoding}              $self->{change_encoding}
4286                  ->($self, $token->{attributes}->{charset}->{value}, $token);                  ->($self, $token->{attributes}->{charset}->{value}, $token);
4287                            
# Line 5583  sub _tree_construction_main ($) { Line 4290  sub _tree_construction_main ($) {
4290                                       $token->{attributes}->{charset}                                       $token->{attributes}->{charset}
4291                                           ->{has_reference});                                           ->{has_reference});
4292            } elsif ($token->{attributes}->{content}) {            } elsif ($token->{attributes}->{content}) {
             ## ISSUE: Algorithm name in the spec was incorrect so that not linked to the definition.  
4293              if ($token->{attributes}->{content}->{value}              if ($token->{attributes}->{content}->{value}
4294                  =~ /\A[^;]*;[\x09-\x0D\x20]*[Cc][Hh][Aa][Rr][Ss][Ee][Tt]                  =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt]
4295                      [\x09-\x0D\x20]*=                      [\x09\x0A\x0C\x0D\x20]*=
4296                      [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'|                      [\x09\x0A\x0C\x0D\x20]*(?>"([^"]*)"|'([^']*)'|
4297                      ([^"'\x09-\x0D\x20][^\x09-\x0D\x20]*))/x) {                      ([^"'\x09\x0A\x0C\x0D\x20][^\x09\x0A\x0C\x0D\x20\x3B]*))
4298                       /x) {
4299                !!!cp ('t336');                !!!cp ('t336');
4300                  ## NOTE: Whether the encoding is supported or not is handled
4301                  ## in the {change_encoding} callback.
4302                $self->{change_encoding}                $self->{change_encoding}
4303                    ->($self, defined $1 ? $1 : defined $2 ? $2 : $3, $token);                    ->($self, defined $1 ? $1 : defined $2 ? $2 : $3, $token);
4304                $meta_el->[0]->get_attribute_node_ns (undef, 'content')                $meta_el->[0]->get_attribute_node_ns (undef, 'content')
# Line 5615  sub _tree_construction_main ($) { Line 4324  sub _tree_construction_main ($) {
4324            }            }
4325          }          }
4326    
4327            !!!ack ('t338.1');
4328          !!!next-token;          !!!next-token;
4329          redo B;          next B;
4330        } elsif ($token->{tag_name} eq 'title') {        } elsif ($token->{tag_name} eq 'title') {
4331          !!!cp ('t341');          !!!cp ('t341');
4332          ## NOTE: This is an "as if in head" code clone          ## NOTE: This is an "as if in head" code clone
4333          $parse_rcdata->(RCDATA_CONTENT_MODEL);          $parse_rcdata->(RCDATA_CONTENT_MODEL);
4334          redo B;          next B;
4335        } elsif ($token->{tag_name} eq 'body') {        } elsif ($token->{tag_name} eq 'body') {
4336          !!!parse-error (type => 'in body:body', token => $token);          !!!parse-error (type => 'in body', text => 'body', token => $token);
4337                                
4338          if (@{$self->{open_elements}} == 1 or          if (@{$self->{open_elements}} == 1 or
4339              $self->{open_elements}->[1]->[1] ne 'body') {              not ($self->{open_elements}->[1]->[1] == BODY_EL)) {
4340            !!!cp ('t342');            !!!cp ('t342');
4341            ## Ignore the token            ## Ignore the token
4342          } else {          } else {
# Line 5640  sub _tree_construction_main ($) { Line 4350  sub _tree_construction_main ($) {
4350              }              }
4351            }            }
4352          }          }
4353            !!!nack ('t343.1');
4354          !!!next-token;          !!!next-token;
4355          redo B;          next B;
4356          } elsif ($token->{tag_name} eq 'frameset') {
4357            !!!parse-error (type => 'in body', text => $token->{tag_name},
4358                            token => $token);
4359    
4360            if (@{$self->{open_elements}} == 1 or
4361                not ($self->{open_elements}->[1]->[1] == BODY_EL)) {
4362              !!!cp ('t343.2');
4363              ## Ignore the token.
4364            } elsif (not $self->{frameset_ok}) {
4365              !!!cp ('t343.3');
4366              ## Ignore the token.
4367            } else {
4368              !!!cp ('t343.4');
4369              
4370              ## 1. Remove the second element.
4371              my $body = $self->{open_elements}->[1]->[0];
4372              my $body_parent = $body->parent_node;
4373              $body_parent->remove_child ($body) if $body_parent;
4374    
4375              ## 2. Pop nodes.
4376              splice @{$self->{open_elements}}, 1;
4377    
4378              ## 3. Insert.
4379              !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4380    
4381              ## 4. Switch.
4382              $self->{insertion_mode} = IN_FRAMESET_IM;
4383            }
4384    
4385            !!!nack ('t343.5');
4386            !!!next-token;
4387            next B;
4388        } elsif ({        } elsif ({
4389                  address => 1, blockquote => 1, center => 1, dir => 1,                  ## NOTE: Start tags for non-phrasing flow content elements
4390                  div => 1, dl => 1, fieldset => 1,  
4391                  h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,                  ## NOTE: The normal one
4392                  menu => 1, ol => 1, p => 1, ul => 1,                  address => 1, article => 1, aside => 1, blockquote => 1,
4393                    center => 1, datagrid => 1, details => 1, dialog => 1,
4394                    dir => 1, div => 1, dl => 1, fieldset => 1, figure => 1,
4395                    footer => 1, h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1,
4396                    h6 => 1, header => 1, hgroup => 1,
4397                    menu => 1, nav => 1, ol => 1, p => 1,
4398                    section => 1, ul => 1,
4399                    ## NOTE: As normal, but drops leading newline
4400                  pre => 1, listing => 1,                  pre => 1, listing => 1,
4401                    ## NOTE: As normal, but interacts with the form element pointer
4402                  form => 1,                  form => 1,
4403                    
4404                  table => 1,                  table => 1,
4405                  hr => 1,                  hr => 1,
4406                 }->{$token->{tag_name}}) {                 }->{$token->{tag_name}}) {
4407    
4408            ## 1. When there is an opening |form| element:
4409          if ($token->{tag_name} eq 'form' and defined $self->{form_element}) {          if ($token->{tag_name} eq 'form' and defined $self->{form_element}) {
4410            !!!cp ('t350');            !!!cp ('t350');
4411            !!!parse-error (type => 'in form:form', token => $token);            !!!parse-error (type => 'in form:form', token => $token);
4412            ## Ignore the token            ## Ignore the token
4413              !!!nack ('t350.1');
4414            !!!next-token;            !!!next-token;
4415            redo B;            next B;
4416          }          }
4417    
4418          ## has a p element in scope          ## 2. Close the |p| element, if any.
4419          INSCOPE: for (reverse @{$self->{open_elements}}) {          if ($token->{tag_name} ne 'table' or # The Hixie Quirk
4420            if ($_->[1] eq 'p') {              $self->{document}->manakai_compat_mode ne 'quirks') {
4421              !!!cp ('t344');            ## has a p element in scope
4422              !!!back-token;            INSCOPE: for (reverse @{$self->{open_elements}}) {
4423              $token = {type => END_TAG_TOKEN, tag_name => 'p',              if ($_->[1] == P_EL) {
4424                        line => $token->{line}, column => $token->{column}};                !!!cp ('t344');
4425              redo B;                !!!back-token; # <form>
4426            } elsif ({                $token = {type => END_TAG_TOKEN, tag_name => 'p',
4427                      applet => 1, table => 1, caption => 1, td => 1, th => 1,                          line => $token->{line}, column => $token->{column}};
4428                      button => 1, marquee => 1, object => 1, html => 1,                next B;
4429                     }->{$_->[1]}) {              } elsif ($_->[1] & SCOPING_EL) {
4430              !!!cp ('t345');                !!!cp ('t345');
4431              last INSCOPE;                last INSCOPE;
4432                }
4433              } # INSCOPE
4434            }
4435    
4436            ## 3. Close the opening <hn> element, if any.
4437            if ({h1 => 1, h2 => 1, h3 => 1,
4438                 h4 => 1, h5 => 1, h6 => 1}->{$token->{tag_name}}) {
4439              if ($self->{open_elements}->[-1]->[1] == HEADING_EL) {
4440                !!!parse-error (type => 'not closed',
4441                                text => $self->{open_elements}->[-1]->[0]->manakai_local_name,
4442                                token => $token);
4443                pop @{$self->{open_elements}};
4444            }            }
4445          } # INSCOPE          }
4446              
4447            ## 4. Insertion.
4448          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4449          if ($token->{tag_name} eq 'pre' or $token->{tag_name} eq 'listing') {          if ($token->{tag_name} eq 'pre' or $token->{tag_name} eq 'listing') {
4450              !!!nack ('t346.1');
4451            !!!next-token;            !!!next-token;
4452            if ($token->{type} == CHARACTER_TOKEN) {            if ($token->{type} == CHARACTER_TOKEN) {
4453              $token->{data} =~ s/^\x0A//;              $token->{data} =~ s/^\x0A//;
# Line 5691  sub _tree_construction_main ($) { Line 4460  sub _tree_construction_main ($) {
4460            } else {            } else {
4461              !!!cp ('t348');              !!!cp ('t348');
4462            }            }
4463    
4464              delete $self->{frameset_ok};
4465          } elsif ($token->{tag_name} eq 'form') {          } elsif ($token->{tag_name} eq 'form') {
4466            !!!cp ('t347.1');            !!!cp ('t347.1');
4467            $self->{form_element} = $self->{open_elements}->[-1]->[0];            $self->{form_element} = $self->{open_elements}->[-1]->[0];
4468    
4469              !!!nack ('t347.2');
4470            !!!next-token;            !!!next-token;
4471          } elsif ($token->{tag_name} eq 'table') {          } elsif ($token->{tag_name} eq 'table') {
4472            !!!cp ('t382');            !!!cp ('t382');
4473            push @{$open_tables}, [$self->{open_elements}->[-1]->[0]];            push @{$open_tables}, [$self->{open_elements}->[-1]->[0]];
4474    
4475              delete $self->{frameset_ok};
4476                        
4477            $self->{insertion_mode} = IN_TABLE_IM;            $self->{insertion_mode} = IN_TABLE_IM;
4478    
4479              !!!nack ('t382.1');
4480            !!!next-token;            !!!next-token;
4481          } elsif ($token->{tag_name} eq 'hr') {          } elsif ($token->{tag_name} eq 'hr') {
4482            !!!cp ('t386');            !!!cp ('t386');
4483            pop @{$self->{open_elements}};            pop @{$self->{open_elements}};
4484                      
4485              !!!ack ('t386.1');
4486    
4487              delete $self->{frameset_ok};
4488    
4489            !!!next-token;            !!!next-token;
4490          } else {          } else {
4491            !!!cp ('t347');            !!!nack ('t347.1');
4492            !!!next-token;            !!!next-token;
4493          }          }
4494          redo B;          next B;
4495        } elsif ({li => 1, dt => 1, dd => 1}->{$token->{tag_name}}) {        } elsif ($token->{tag_name} eq 'li') {
4496          ## has a p element in scope          ## NOTE: As normal, but imply </li> when there's another <li> ...
4497    
4498            ## NOTE: Special, Scope (<li><foo><li> == <li><foo><li/></foo></li>)::
4499              ## Interpreted as <li><foo/></li><li/> (non-conforming):
4500              ## blockquote (O9.27), center (O), dd (Fx3, O, S3.1.2, IE7),
4501              ## dt (Fx, O, S, IE), dl (O), fieldset (O, S, IE), form (Fx, O, S),
4502              ## hn (O), pre (O), applet (O, S), button (O, S), marquee (Fx, O, S),
4503              ## object (Fx)
4504              ## Generate non-tree (non-conforming):
4505              ## basefont (IE7 (where basefont is non-void)), center (IE),
4506              ## form (IE), hn (IE)
4507            ## address, div, p (<li><foo><li> == <li><foo/></li><li/>)::
4508              ## Interpreted as <li><foo><li/></foo></li> (non-conforming):
4509              ## div (Fx, S)
4510    
4511            ## 1. Frameset-ng
4512            delete $self->{frameset_ok};
4513    
4514            my $non_optional;
4515            my $i = -1;
4516    
4517            ## 2.
4518            for my $node (reverse @{$self->{open_elements}}) {
4519              if ($node->[1] == LI_EL) {
4520                ## 3. (a) As if </li>
4521                {
4522                  ## If no </li> - not applied
4523                  #
4524    
4525                  ## Otherwise
4526    
4527                  ## 1. generate implied end tags, except for </li>
4528                  #
4529    
4530                  ## 2. If current node != "li", parse error
4531                  if ($non_optional) {
4532                    !!!parse-error (type => 'not closed',
4533                                    text => $non_optional->[0]->manakai_local_name,
4534                                    token => $token);
4535                    !!!cp ('t355');
4536                  } else {
4537                    !!!cp ('t356');
4538                  }
4539    
4540                  ## 3. Pop
4541                  splice @{$self->{open_elements}}, $i;
4542                }
4543    
4544                last; ## 3. (b) goto 5.
4545              } elsif (
4546                       ## NOTE: not "formatting" and not "phrasing"
4547                       ($node->[1] & SPECIAL_EL or
4548                        $node->[1] & SCOPING_EL) and
4549                       ## NOTE: "li", "dt", and "dd" are in |SPECIAL_EL|.
4550                       (not $node->[1] & ADDRESS_DIV_P_EL)
4551                      ) {
4552                ## 4.
4553                !!!cp ('t357');
4554                last; ## goto 6.
4555              } elsif ($node->[1] & END_TAG_OPTIONAL_EL) {
4556                !!!cp ('t358');
4557                #
4558              } else {
4559                !!!cp ('t359');
4560                $non_optional ||= $node;
4561                #
4562              }
4563              ## 5.
4564              ## goto 3.
4565              $i--;
4566            }
4567    
4568            ## 6. (a) has a |p| element in scope
4569          INSCOPE: for (reverse @{$self->{open_elements}}) {          INSCOPE: for (reverse @{$self->{open_elements}}) {
4570            if ($_->[1] eq 'p') {            if ($_->[1] == P_EL) {
4571              !!!cp ('t353');              !!!cp ('t353');
4572              !!!back-token;  
4573                ## NOTE: |<p><li>|, for example.
4574    
4575                !!!back-token; # <x>
4576              $token = {type => END_TAG_TOKEN, tag_name => 'p',              $token = {type => END_TAG_TOKEN, tag_name => 'p',
4577                        line => $token->{line}, column => $token->{column}};                        line => $token->{line}, column => $token->{column}};
4578              redo B;              next B;
4579            } elsif ({            } elsif ($_->[1] & SCOPING_EL) {
                     applet => 1, table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$_->[1]}) {  
4580              !!!cp ('t354');              !!!cp ('t354');
4581              last INSCOPE;              last INSCOPE;
4582            }            }
4583          } # INSCOPE          } # INSCOPE
4584              
4585          ## Step 1          ## 6. (b) insert
4586            !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4587            !!!nack ('t359.1');
4588            !!!next-token;
4589            next B;
4590          } elsif ($token->{tag_name} eq 'dt' or
4591                   $token->{tag_name} eq 'dd') {
4592            ## NOTE: As normal, but imply </dt> or </dd> when ...
4593    
4594            ## 1. Frameset-ng
4595            delete $self->{frameset_ok};
4596    
4597            my $non_optional;
4598          my $i = -1;          my $i = -1;
4599          my $node = $self->{open_elements}->[$i];  
4600          my $li_or_dtdd = {li => {li => 1},          ## 2.
4601                            dt => {dt => 1, dd => 1},          for my $node (reverse @{$self->{open_elements}}) {
4602                            dd => {dt => 1, dd => 1}}->{$token->{tag_name}};            if ($node->[1] == DTDD_EL) {
4603          LI: {              ## 3. (a) As if </li>
4604            ## Step 2              {
4605            if ($li_or_dtdd->{$node->[1]}) {                ## If no </li> - not applied
4606              if ($i != -1) {                #
4607                !!!cp ('t355');  
4608                !!!parse-error (type => 'end tag missing:'.                ## Otherwise
4609                                $self->{open_elements}->[-1]->[1], token => $token);  
4610              } else {                ## 1. generate implied end tags, except for </dt> or </dd>
4611                !!!cp ('t356');                #
4612    
4613                  ## 2. If current node != "dt"|"dd", parse error
4614                  if ($non_optional) {
4615                    !!!parse-error (type => 'not closed',
4616                                    text => $non_optional->[0]->manakai_local_name,
4617                                    token => $token);
4618                    !!!cp ('t355.1');
4619                  } else {
4620                    !!!cp ('t356.1');
4621                  }
4622    
4623                  ## 3. Pop
4624                  splice @{$self->{open_elements}}, $i;
4625              }              }
4626              splice @{$self->{open_elements}}, $i;  
4627              last LI;              last; ## 3. (b) goto 5.
4628              } elsif (
4629                       ## NOTE: not "formatting" and not "phrasing"
4630                       ($node->[1] & SPECIAL_EL or
4631                        $node->[1] & SCOPING_EL) and
4632                       ## NOTE: "li", "dt", and "dd" are in |SPECIAL_EL|.
4633    
4634                       (not $node->[1] & ADDRESS_DIV_P_EL)
4635                      ) {
4636                ## 4.
4637                !!!cp ('t357.1');
4638                last; ## goto 5.
4639              } elsif ($node->[1] & END_TAG_OPTIONAL_EL) {
4640                !!!cp ('t358.1');
4641                #
4642            } else {            } else {
4643              !!!cp ('t357');              !!!cp ('t359.1');
4644            }              $non_optional ||= $node;
4645                          #
           ## Step 3  
           if (not $formatting_category->{$node->[1]} and  
               #not $phrasing_category->{$node->[1]} and  
               ($special_category->{$node->[1]} or  
                $scoping_category->{$node->[1]}) and  
               $node->[1] ne 'address' and $node->[1] ne 'div') {  
             !!!cp ('t358');  
             last LI;  
4646            }            }
4647                        ## 5.
4648            !!!cp ('t359');            ## goto 3.
           ## Step 4  
4649            $i--;            $i--;
4650            $node = $self->{open_elements}->[$i];          }
4651            redo LI;  
4652          } # LI          ## 6. (a) has a |p| element in scope
4653                      INSCOPE: for (reverse @{$self->{open_elements}}) {
4654              if ($_->[1] == P_EL) {
4655                !!!cp ('t353.1');
4656                !!!back-token; # <x>
4657                $token = {type => END_TAG_TOKEN, tag_name => 'p',
4658                          line => $token->{line}, column => $token->{column}};
4659                next B;
4660              } elsif ($_->[1] & SCOPING_EL) {
4661                !!!cp ('t354.1');
4662                last INSCOPE;
4663              }
4664            } # INSCOPE
4665    
4666            ## 6. (b) insert
4667          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4668            !!!nack ('t359.2');
4669          !!!next-token;          !!!next-token;
4670          redo B;          next B;
4671        } elsif ($token->{tag_name} eq 'plaintext') {        } elsif ($token->{tag_name} eq 'plaintext') {
4672            ## NOTE: As normal, but effectively ends parsing
4673    
4674          ## has a p element in scope          ## has a p element in scope
4675          INSCOPE: for (reverse @{$self->{open_elements}}) {          INSCOPE: for (reverse @{$self->{open_elements}}) {
4676            if ($_->[1] eq 'p') {            if ($_->[1] == P_EL) {
4677              !!!cp ('t367');              !!!cp ('t367');
4678              !!!back-token;              !!!back-token; # <plaintext>
4679              $token = {type => END_TAG_TOKEN, tag_name => 'p',              $token = {type => END_TAG_TOKEN, tag_name => 'p',
4680                        line => $token->{line}, column => $token->{column}};                        line => $token->{line}, column => $token->{column}};
4681              redo B;              next B;
4682            } elsif ({            } elsif ($_->[1] & SCOPING_EL) {
                     applet => 1, table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$_->[1]}) {  
4683              !!!cp ('t368');              !!!cp ('t368');
4684              last INSCOPE;              last INSCOPE;
4685            }            }
# Line 5795  sub _tree_construction_main ($) { Line 4689  sub _tree_construction_main ($) {
4689                        
4690          $self->{content_model} = PLAINTEXT_CONTENT_MODEL;          $self->{content_model} = PLAINTEXT_CONTENT_MODEL;
4691                        
4692            !!!nack ('t368.1');
4693          !!!next-token;          !!!next-token;
4694          redo B;          next B;
4695        } elsif ($token->{tag_name} eq 'a') {        } elsif ($token->{tag_name} eq 'a') {
4696          AFE: for my $i (reverse 0..$#$active_formatting_elements) {          AFE: for my $i (reverse 0..$#$active_formatting_elements) {
4697            my $node = $active_formatting_elements->[$i];            my $node = $active_formatting_elements->[$i];
4698            if ($node->[1] eq 'a') {            if ($node->[1] == A_EL) {
4699              !!!cp ('t371');              !!!cp ('t371');
4700              !!!parse-error (type => 'in a:a', token => $token);              !!!parse-error (type => 'in a:a', token => $token);
4701                            
4702              !!!back-token;              !!!back-token; # <a>
4703              $token = {type => END_TAG_TOKEN, tag_name => 'a',              $token = {type => END_TAG_TOKEN, tag_name => 'a',
4704                        line => $token->{line}, column => $token->{column}};                        line => $token->{line}, column => $token->{column}};
4705              $formatting_end_tag->($token);              $formatting_end_tag->($token);
# Line 5835  sub _tree_construction_main ($) { Line 4730  sub _tree_construction_main ($) {
4730          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4731          push @$active_formatting_elements, $self->{open_elements}->[-1];          push @$active_formatting_elements, $self->{open_elements}->[-1];
4732    
4733            !!!nack ('t374.1');
4734          !!!next-token;          !!!next-token;
4735          redo B;          next B;
4736        } elsif ($token->{tag_name} eq 'nobr') {        } elsif ($token->{tag_name} eq 'nobr') {
4737          $reconstruct_active_formatting_elements->($insert_to_current);          $reconstruct_active_formatting_elements->($insert_to_current);
4738    
4739          ## has a |nobr| element in scope          ## has a |nobr| element in scope
4740          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4741            my $node = $self->{open_elements}->[$_];            my $node = $self->{open_elements}->[$_];
4742            if ($node->[1] eq 'nobr') {            if ($node->[1] == NOBR_EL) {
4743              !!!cp ('t376');              !!!cp ('t376');
4744              !!!parse-error (type => 'in nobr:nobr', token => $token);              !!!parse-error (type => 'in nobr:nobr', token => $token);
4745              !!!back-token;              !!!back-token; # <nobr>
4746              $token = {type => END_TAG_TOKEN, tag_name => 'nobr',              $token = {type => END_TAG_TOKEN, tag_name => 'nobr',
4747                        line => $token->{line}, column => $token->{column}};                        line => $token->{line}, column => $token->{column}};
4748              redo B;              next B;
4749            } elsif ({            } elsif ($node->[1] & SCOPING_EL) {
                     applet => 1, table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$node->[1]}) {  
4750              !!!cp ('t377');              !!!cp ('t377');
4751              last INSCOPE;              last INSCOPE;
4752            }            }
# Line 5862  sub _tree_construction_main ($) { Line 4755  sub _tree_construction_main ($) {
4755          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4756          push @$active_formatting_elements, $self->{open_elements}->[-1];          push @$active_formatting_elements, $self->{open_elements}->[-1];
4757                    
4758            !!!nack ('t377.1');
4759          !!!next-token;          !!!next-token;
4760          redo B;          next B;
4761        } elsif ($token->{tag_name} eq 'button') {        } elsif ($token->{tag_name} eq 'button') {
4762          ## has a button element in scope          ## has a button element in scope
4763          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4764            my $node = $self->{open_elements}->[$_];            my $node = $self->{open_elements}->[$_];
4765            if ($node->[1] eq 'button') {            if ($node->[1] == BUTTON_EL) {
4766              !!!cp ('t378');              !!!cp ('t378');
4767              !!!parse-error (type => 'in button:button', token => $token);              !!!parse-error (type => 'in button:button', token => $token);
4768              !!!back-token;              !!!back-token; # <button>
4769              $token = {type => END_TAG_TOKEN, tag_name => 'button',              $token = {type => END_TAG_TOKEN, tag_name => 'button',
4770                        line => $token->{line}, column => $token->{column}};                        line => $token->{line}, column => $token->{column}};
4771              redo B;              next B;
4772            } elsif ({            } elsif ($node->[1] & SCOPING_EL) {
                     applet => 1, table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$node->[1]}) {  
4773              !!!cp ('t379');              !!!cp ('t379');
4774              last INSCOPE;              last INSCOPE;
4775            }            }
# Line 5892  sub _tree_construction_main ($) { Line 4783  sub _tree_construction_main ($) {
4783    
4784          push @$active_formatting_elements, ['#marker', ''];          push @$active_formatting_elements, ['#marker', ''];
4785    
4786            delete $self->{frameset_ok};
4787    
4788            !!!nack ('t379.1');
4789          !!!next-token;          !!!next-token;
4790          redo B;          next B;
4791        } elsif ({        } elsif ({
4792                  xmp => 1,                  xmp => 1,
4793                  iframe => 1,                  iframe => 1,
4794                  noembed => 1,                  noembed => 1,
4795                  noframes => 1,                  noframes => 1, ## NOTE: This is an "as if in head" code clone.
4796                  noscript => 0, ## TODO: 1 if scripting is enabled                  noscript => 0, ## TODO: 1 if scripting is enabled
4797                 }->{$token->{tag_name}}) {                 }->{$token->{tag_name}}) {
4798          if ($token->{tag_name} eq 'xmp') {          if ($token->{tag_name} eq 'xmp') {
4799            !!!cp ('t381');            !!!cp ('t381');
4800            $reconstruct_active_formatting_elements->($insert_to_current);            $reconstruct_active_formatting_elements->($insert_to_current);
4801    
4802              delete $self->{frameset_ok};
4803            } elsif ($token->{tag_name} eq 'iframe') {
4804              !!!cp ('t381.1');
4805              delete $self->{frameset_ok};
4806          } else {          } else {
4807            !!!cp ('t399');            !!!cp ('t399');
4808          }          }
4809          ## NOTE: There is an "as if in body" code clone.          ## NOTE: There is an "as if in body" code clone.
4810          $parse_rcdata->(CDATA_CONTENT_MODEL);          $parse_rcdata->(CDATA_CONTENT_MODEL);
4811          redo B;          next B;
4812        } elsif ($token->{tag_name} eq 'isindex') {        } elsif ($token->{tag_name} eq 'isindex') {
4813          !!!parse-error (type => 'isindex', token => $token);          !!!parse-error (type => 'isindex', token => $token);
4814                    
4815          if (defined $self->{form_element}) {          if (defined $self->{form_element}) {
4816            !!!cp ('t389');            !!!cp ('t389');
4817            ## Ignore the token            ## Ignore the token
4818              !!!nack ('t389'); ## NOTE: Not acknowledged.
4819            !!!next-token;            !!!next-token;
4820            redo B;            next B;
4821          } else {          } else {
4822              !!!ack ('t391.1');
4823    
4824            my $at = $token->{attributes};            my $at = $token->{attributes};
4825            my $form_attrs;            my $form_attrs;
4826            $form_attrs->{action} = $at->{action} if $at->{action};            $form_attrs->{action} = $at->{action} if $at->{action};
# Line 5932  sub _tree_construction_main ($) { Line 4834  sub _tree_construction_main ($) {
4834                           line => $token->{line}, column => $token->{column}},                           line => $token->{line}, column => $token->{column}},
4835                          {type => START_TAG_TOKEN, tag_name => 'hr',                          {type => START_TAG_TOKEN, tag_name => 'hr',
4836                           line => $token->{line}, column => $token->{column}},                           line => $token->{line}, column => $token->{column}},
                         {type => START_TAG_TOKEN, tag_name => 'p',  
                          line => $token->{line}, column => $token->{column}},  
4837                          {type => START_TAG_TOKEN, tag_name => 'label',                          {type => START_TAG_TOKEN, tag_name => 'label',
4838                           line => $token->{line}, column => $token->{column}},                           line => $token->{line}, column => $token->{column}},
4839                         );                         );
# Line 5956  sub _tree_construction_main ($) { Line 4856  sub _tree_construction_main ($) {
4856                          #{type => CHARACTER_TOKEN, data => ''}, # SHOULD                          #{type => CHARACTER_TOKEN, data => ''}, # SHOULD
4857                          {type => END_TAG_TOKEN, tag_name => 'label',                          {type => END_TAG_TOKEN, tag_name => 'label',
4858                           line => $token->{line}, column => $token->{column}},                           line => $token->{line}, column => $token->{column}},
                         {type => END_TAG_TOKEN, tag_name => 'p',  
                          line => $token->{line}, column => $token->{column}},  
4859                          {type => START_TAG_TOKEN, tag_name => 'hr',                          {type => START_TAG_TOKEN, tag_name => 'hr',
4860                           line => $token->{line}, column => $token->{column}},                           line => $token->{line}, column => $token->{column}},
4861                          {type => END_TAG_TOKEN, tag_name => 'form',                          {type => END_TAG_TOKEN, tag_name => 'form',
4862                           line => $token->{line}, column => $token->{column}};                           line => $token->{line}, column => $token->{column}};
           $token = shift @tokens;  
4863            !!!back-token (@tokens);            !!!back-token (@tokens);
4864            redo B;            !!!next-token;
4865              next B;
4866          }          }
4867        } elsif ($token->{tag_name} eq 'textarea') {        } elsif ($token->{tag_name} eq 'textarea') {
4868          my $tag_name = $token->{tag_name};          ## 1. Insert
4869          my $el;          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
         !!!create-element ($el, $token->{tag_name}, $token->{attributes}, $token);  
4870                    
4871            ## Step 2 # XXX
4872          ## TODO: $self->{form_element} if defined          ## TODO: $self->{form_element} if defined
4873    
4874            ## 2. Drop U+000A LINE FEED
4875            $self->{ignore_newline} = 1;
4876    
4877            ## 3. RCDATA
4878          $self->{content_model} = RCDATA_CONTENT_MODEL;          $self->{content_model} = RCDATA_CONTENT_MODEL;
4879          delete $self->{escape}; # MUST          delete $self->{escape}; # MUST
4880            
4881          $insert->($el);          ## 4., 6. Insertion mode
4882                    $self->{insertion_mode} |= IN_CDATA_RCDATA_IM;
4883          my $text = '';  
4884            ## 5. Frameset-ng.
4885            delete $self->{frameset_ok};
4886    
4887            !!!nack ('t392.1');
4888          !!!next-token;          !!!next-token;
4889          if ($token->{type} == CHARACTER_TOKEN) {          next B;
4890            $token->{data} =~ s/^\x0A//;        } elsif ($token->{tag_name} eq 'optgroup' or
4891            unless (length $token->{data}) {                 $token->{tag_name} eq 'option') {
4892              !!!cp ('t392');          ## has an |option| element in scope
4893              !!!next-token;          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4894            } else {            my $node = $self->{open_elements}->[$_];
4895              !!!cp ('t393');            if ($node->[1] == OPTION_EL) {
4896                !!!cp ('t397.1');
4897                ## NOTE: As if </option>
4898                !!!back-token; # <option> or <optgroup>
4899                $token = {type => END_TAG_TOKEN, tag_name => 'option',
4900                          line => $token->{line}, column => $token->{column}};
4901                next B;
4902              } elsif ($node->[1] & SCOPING_EL) {
4903                !!!cp ('t397.2');
4904                last INSCOPE;
4905            }            }
4906          } else {          } # INSCOPE
4907            !!!cp ('t394');  
4908          }          $reconstruct_active_formatting_elements->($insert_to_current);
4909          while ($token->{type} == CHARACTER_TOKEN) {  
4910            !!!cp ('t395');          !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4911            $text .= $token->{data};  
4912            !!!next-token;          !!!nack ('t397.3');
4913          }          !!!next-token;
4914          if (length $text) {          redo B;
4915            !!!cp ('t396');        } elsif ($token->{tag_name} eq 'rt' or
4916            $el->manakai_append_text ($text);                 $token->{tag_name} eq 'rp') {
4917          }          ## has a |ruby| element in scope
4918            INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
4919              my $node = $self->{open_elements}->[$_];
4920              if ($node->[1] == RUBY_EL) {
4921                !!!cp ('t398.1');
4922                ## generate implied end tags
4923                while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
4924                  !!!cp ('t398.2');
4925                  pop @{$self->{open_elements}};
4926                }
4927                unless ($self->{open_elements}->[-1]->[1] == RUBY_EL) {
4928                  !!!cp ('t398.3');
4929                  !!!parse-error (type => 'not closed',
4930                                  text => $self->{open_elements}->[-1]->[0]
4931                                      ->manakai_local_name,
4932                                  token => $token);
4933                  pop @{$self->{open_elements}}
4934                      while not $self->{open_elements}->[-1]->[1] == RUBY_EL;
4935                }
4936                last INSCOPE;
4937              } elsif ($node->[1] & SCOPING_EL) {
4938                !!!cp ('t398.4');
4939                last INSCOPE;
4940              }
4941            } # INSCOPE
4942              
4943            ## TODO: <non-ruby><rt> is not allowed.
4944    
4945            !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4946    
4947            !!!nack ('t398.5');
4948            !!!next-token;
4949            redo B;
4950          } elsif ($token->{tag_name} eq 'math' or
4951                   $token->{tag_name} eq 'svg') {
4952            $reconstruct_active_formatting_elements->($insert_to_current);
4953    
4954            ## "Adjust MathML attributes" ('math' only) - done in insert-element-f
4955    
4956            ## "adjust SVG attributes" ('svg' only) - done in insert-element-f
4957    
4958            ## "adjust foreign attributes" - done in insert-element-f
4959                    
4960          $self->{content_model} = PCDATA_CONTENT_MODEL;          !!!insert-element-f ($token->{tag_name} eq 'math' ? $MML_NS : $SVG_NS, $token->{tag_name}, $token->{attributes}, $token);
4961                    
4962          if ($token->{type} == END_TAG_TOKEN and          if ($self->{self_closing}) {
4963              $token->{tag_name} eq $tag_name) {            pop @{$self->{open_elements}};
4964            !!!cp ('t397');            !!!ack ('t398.6');
           ## Ignore the token  
4965          } else {          } else {
4966            !!!cp ('t398');            !!!cp ('t398.7');
4967            !!!parse-error (type => 'in RCDATA:#'.$token->{type}, token => $token);            $self->{insertion_mode} |= IN_FOREIGN_CONTENT_IM;
4968              ## NOTE: |<body><math><mi><svg>| -> "in foreign content" insertion
4969              ## mode, "in body" (not "in foreign content") secondary insertion
4970              ## mode, maybe.
4971          }          }
4972    
4973          !!!next-token;          !!!next-token;
4974          redo B;          next B;
4975        } elsif ({        } elsif ({
4976                  caption => 1, col => 1, colgroup => 1, frame => 1,                  caption => 1, col => 1, colgroup => 1, frame => 1,
4977                  frameset => 1, head => 1, option => 1, optgroup => 1,                  head => 1,
4978                  tbody => 1, td => 1, tfoot => 1, th => 1,                  tbody => 1, td => 1, tfoot => 1, th => 1,
4979                  thead => 1, tr => 1,                  thead => 1, tr => 1,
4980                 }->{$token->{tag_name}}) {                 }->{$token->{tag_name}}) {
4981          !!!cp ('t401');          !!!cp ('t401');
4982          !!!parse-error (type => 'in body:'.$token->{tag_name}, token => $token);          !!!parse-error (type => 'in body',
4983                            text => $token->{tag_name}, token => $token);
4984          ## Ignore the token          ## Ignore the token
4985            !!!nack ('t401.1'); ## NOTE: |<col/>| or |<frame/>| here is an error.
4986            !!!next-token;
4987            next B;
4988          } elsif ($token->{tag_name} eq 'param' or
4989                   $token->{tag_name} eq 'source') {
4990            !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token);
4991            pop @{$self->{open_elements}};
4992    
4993            !!!ack ('t398.5');
4994          !!!next-token;          !!!next-token;
4995          redo B;          redo B;
           
         ## ISSUE: An issue on HTML5 new elements in the spec.  
4996        } else {        } else {
4997          if ($token->{tag_name} eq 'image') {          if ($token->{tag_name} eq 'image') {
4998            !!!cp ('t384');            !!!cp ('t384');
# Line 6043  sub _tree_construction_main ($) { Line 5011  sub _tree_construction_main ($) {
5011               applet => 1, marquee => 1, object => 1,               applet => 1, marquee => 1, object => 1,
5012              }->{$token->{tag_name}}) {              }->{$token->{tag_name}}) {
5013            !!!cp ('t380');            !!!cp ('t380');
5014    
5015            push @$active_formatting_elements, ['#marker', ''];            push @$active_formatting_elements, ['#marker', ''];
5016    
5017              delete $self->{frameset_ok};
5018    
5019              !!!nack ('t380.1');
5020          } elsif ({          } elsif ({
5021                    b => 1, big => 1, em => 1, font => 1, i => 1,                    b => 1, big => 1, em => 1, font => 1, i => 1,
5022                    s => 1, small => 1, strile => 1,                    s => 1, small => 1, strike => 1,
5023                    strong => 1, tt => 1, u => 1,                    strong => 1, tt => 1, u => 1,
5024                   }->{$token->{tag_name}}) {                   }->{$token->{tag_name}}) {
5025            !!!cp ('t375');            !!!cp ('t375');
5026            push @$active_formatting_elements, $self->{open_elements}->[-1];            push @$active_formatting_elements, $self->{open_elements}->[-1];
5027              !!!nack ('t375.1');
5028          } elsif ($token->{tag_name} eq 'input') {          } elsif ($token->{tag_name} eq 'input') {
5029            !!!cp ('t388');            !!!cp ('t388');
5030            ## TODO: associate with $self->{form_element} if defined            ## TODO: associate with $self->{form_element} if defined
5031            pop @{$self->{open_elements}};            pop @{$self->{open_elements}};
5032              !!!ack ('t388.2');
5033          } elsif ({          } elsif ({
5034                    area => 1, basefont => 1, bgsound => 1, br => 1,                    area => 1, basefont => 1, bgsound => 1, br => 1,
5035                    embed => 1, img => 1, param => 1, spacer => 1, wbr => 1,                    embed => 1, img => 1, spacer => 1, wbr => 1,
5036                    #image => 1,                    keygen => 1,
5037                   }->{$token->{tag_name}}) {                   }->{$token->{tag_name}}) {
5038            !!!cp ('t388.1');            !!!cp ('t388.1');
5039    
5040            pop @{$self->{open_elements}};            pop @{$self->{open_elements}};
5041    
5042              delete $self->{frameset_ok};
5043    
5044              !!!ack ('t388.3');
5045          } elsif ($token->{tag_name} eq 'select') {          } elsif ($token->{tag_name} eq 'select') {
5046            ## TODO: associate with $self->{form_element} if defined            ## TODO: associate with $self->{form_element} if defined
5047            
5048              delete $self->{frameset_ok};
5049              
5050            if ($self->{insertion_mode} & TABLE_IMS or            if ($self->{insertion_mode} & TABLE_IMS or
5051                $self->{insertion_mode} & BODY_TABLE_IMS or                $self->{insertion_mode} & BODY_TABLE_IMS or
5052                $self->{insertion_mode} == IN_COLUMN_GROUP_IM) {                ($self->{insertion_mode} & IM_MASK) == IN_COLUMN_GROUP_IM) {
5053              !!!cp ('t400.1');              !!!cp ('t400.1');
5054              $self->{insertion_mode} = IN_SELECT_IN_TABLE_IM;              $self->{insertion_mode} = IN_SELECT_IN_TABLE_IM;
5055            } else {            } else {
5056              !!!cp ('t400.2');              !!!cp ('t400.2');
5057              $self->{insertion_mode} = IN_SELECT_IM;              $self->{insertion_mode} = IN_SELECT_IM;
5058            }            }
5059              !!!nack ('t400.3');
5060          } else {          } else {
5061            !!!cp ('t402');            !!!nack ('t402');
5062          }          }
5063                    
5064          !!!next-token;          !!!next-token;
5065          redo B;          next B;
5066        }        }
5067      } elsif ($token->{type} == END_TAG_TOKEN) {      } elsif ($token->{type} == END_TAG_TOKEN) {
5068        if ($token->{tag_name} eq 'body') {        if ($token->{tag_name} eq 'body' or $token->{tag_name} eq 'html') {
5069          ## has a |body| element in scope  
5070            ## 1. If not "have an element in scope":
5071            ## "has a |body| element in scope"
5072          my $i;          my $i;
5073          INSCOPE: {          INSCOPE: {
5074            for (reverse @{$self->{open_elements}}) {            for (reverse @{$self->{open_elements}}) {
5075              if ($_->[1] eq 'body') {              if ($_->[1] == BODY_EL) {
5076                !!!cp ('t405');                !!!cp ('t405');
5077                $i = $_;                $i = $_;
5078                last INSCOPE;                last INSCOPE;
5079              } elsif ({              } elsif ($_->[1] & SCOPING_EL) {
                       applet => 1, table => 1, caption => 1, td => 1, th => 1,  
                       button => 1, marquee => 1, object => 1, html => 1,  
                      }->{$_->[1]}) {  
5080                !!!cp ('t405.1');                !!!cp ('t405.1');
5081                last;                last;
5082              }              }
5083            }            }
5084    
5085            !!!parse-error (type => 'start tag not allowed',            ## NOTE: |<marquee></body>|, |<svg><foreignobject></body>|,
5086                            value => $token->{tag_name}, token => $token);            ## and fragment cases.
5087            ## NOTE: Ignore the token.  
5088              !!!parse-error (type => 'unmatched end tag',
5089                              text => $token->{tag_name}, token => $token);
5090              ## Ignore the token.  (</body> or </html>)
5091            !!!next-token;            !!!next-token;
5092            redo B;            next B;
5093          } # INSCOPE          } # INSCOPE
5094    
5095            ## 2. If unclosed elements:
5096          for (@{$self->{open_elements}}) {          for (@{$self->{open_elements}}) {
5097            unless ({            unless ($_->[1] & ALL_END_TAG_OPTIONAL_EL ||
5098                     dd => 1, dt => 1, li => 1, p => 1, td => 1,                    $_->[1] == OPTGROUP_EL ||
5099                     th => 1, tr => 1, body => 1, html => 1,                    $_->[1] == OPTION_EL ||
5100                     tbody => 1, tfoot => 1, thead => 1,                    $_->[1] == RUBY_COMPONENT_EL) {
                   }->{$_->[1]}) {  
5101              !!!cp ('t403');              !!!cp ('t403');
5102              !!!parse-error (type => 'not closed:'.$_->[1], token => $token);              !!!parse-error (type => 'not closed',
5103                                text => $_->[0]->manakai_local_name,
5104                                token => $token);
5105              last;              last;
5106            } else {            } else {
5107              !!!cp ('t404');              !!!cp ('t404');
5108            }            }
5109          }          }
5110    
5111            ## 3. Switch the insertion mode.
5112          $self->{insertion_mode} = AFTER_BODY_IM;          $self->{insertion_mode} = AFTER_BODY_IM;
5113          !!!next-token;          if ($token->{tag_name} eq 'body') {
         redo B;  
       } elsif ($token->{tag_name} eq 'html') {  
         if (@{$self->{open_elements}} > 1 and $self->{open_elements}->[1]->[1] eq 'body') {  
           ## ISSUE: There is an issue in the spec.  
           if ($self->{open_elements}->[-1]->[1] ne 'body') {  
             !!!cp ('t406');  
             !!!parse-error (type => 'not closed:'.$self->{open_elements}->[1]->[1], token => $token);  
           } else {  
             !!!cp ('t407');  
           }  
           $self->{insertion_mode} = AFTER_BODY_IM;  
           ## reprocess  
           redo B;  
         } else {  
           !!!cp ('t408');  
           !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);  
           ## Ignore the token  
5114            !!!next-token;            !!!next-token;
5115            redo B;          } else { # html
5116              ## Reprocess.
5117          }          }
5118            next B;
5119        } elsif ({        } elsif ({
5120                  address => 1, blockquote => 1, center => 1, dir => 1,                  ## NOTE: End tags for non-phrasing flow content elements
5121                  div => 1, dl => 1, fieldset => 1, listing => 1,  
5122                  menu => 1, ol => 1, pre => 1, ul => 1,                  ## NOTE: The normal ones
5123                    address => 1, article => 1, aside => 1, blockquote => 1,
5124                    center => 1, datagrid => 1, details => 1, dialog => 1,
5125                    dir => 1, div => 1, dl => 1, fieldset => 1, figure => 1,
5126                    footer => 1, header => 1, hgroup => 1,
5127                    listing => 1, menu => 1, nav => 1,
5128                    ol => 1, pre => 1, section => 1, ul => 1,
5129    
5130                    ## NOTE: As normal, but ... optional tags
5131                  dd => 1, dt => 1, li => 1,                  dd => 1, dt => 1, li => 1,
5132    
5133                  applet => 1, button => 1, marquee => 1, object => 1,                  applet => 1, button => 1, marquee => 1, object => 1,
5134                 }->{$token->{tag_name}}) {                 }->{$token->{tag_name}}) {
5135            ## NOTE: Code for <li> start tags includes "as if </li>" code.
5136            ## Code for <dt> or <dd> start tags includes "as if </dt> or
5137            ## </dd>" code.
5138    
5139          ## has an element in scope          ## has an element in scope
5140          my $i;          my $i;
5141          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5142            my $node = $self->{open_elements}->[$_];            my $node = $self->{open_elements}->[$_];
5143            if ($node->[1] eq $token->{tag_name}) {            if ($node->[0]->manakai_local_name eq $token->{tag_name}) {
5144              !!!cp ('t410');              !!!cp ('t410');
5145              $i = $_;              $i = $_;
5146              last INSCOPE;              last INSCOPE;
5147            } elsif ({            } elsif ($node->[1] & SCOPING_EL) {
                     applet => 1, table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$node->[1]}) {  
5148              !!!cp ('t411');              !!!cp ('t411');
5149              last INSCOPE;              last INSCOPE;
5150            }            }
# Line 6169  sub _tree_construction_main ($) { Line 5152  sub _tree_construction_main ($) {
5152    
5153          unless (defined $i) { # has an element in scope          unless (defined $i) { # has an element in scope
5154            !!!cp ('t413');            !!!cp ('t413');
5155            !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);            !!!parse-error (type => 'unmatched end tag',
5156                              text => $token->{tag_name}, token => $token);
5157              ## NOTE: Ignore the token.
5158          } else {          } else {
5159            ## Step 1. generate implied end tags            ## Step 1. generate implied end tags
5160            while ({            while ({
5161                      ## END_TAG_OPTIONAL_EL
5162                    dd => ($token->{tag_name} ne 'dd'),                    dd => ($token->{tag_name} ne 'dd'),
5163                    dt => ($token->{tag_name} ne 'dt'),                    dt => ($token->{tag_name} ne 'dt'),
5164                    li => ($token->{tag_name} ne 'li'),                    li => ($token->{tag_name} ne 'li'),
5165                      option => 1,
5166                      optgroup => 1,
5167                    p => 1,                    p => 1,
5168                   }->{$self->{open_elements}->[-1]->[1]}) {                    rt => 1,
5169                      rp => 1,
5170                     }->{$self->{open_elements}->[-1]->[0]->manakai_local_name}) {
5171              !!!cp ('t409');              !!!cp ('t409');
5172              pop @{$self->{open_elements}};              pop @{$self->{open_elements}};
5173            }            }
5174    
5175            ## Step 2.            ## Step 2.
5176            if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {            if ($self->{open_elements}->[-1]->[0]->manakai_local_name
5177                      ne $token->{tag_name}) {
5178              !!!cp ('t412');              !!!cp ('t412');
5179              !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1], token => $token);              !!!parse-error (type => 'not closed',
5180                                text => $self->{open_elements}->[-1]->[0]
5181                                    ->manakai_local_name,
5182                                token => $token);
5183            } else {            } else {
5184              !!!cp ('t414');              !!!cp ('t414');
5185            }            }
# Line 6200  sub _tree_construction_main ($) { Line 5194  sub _tree_construction_main ($) {
5194                }->{$token->{tag_name}};                }->{$token->{tag_name}};
5195          }          }
5196          !!!next-token;          !!!next-token;
5197          redo B;          next B;
5198        } elsif ($token->{tag_name} eq 'form') {        } elsif ($token->{tag_name} eq 'form') {
5199            ## NOTE: As normal, but interacts with the form element pointer
5200    
5201          undef $self->{form_element};          undef $self->{form_element};
5202    
5203          ## has an element in scope          ## has an element in scope
5204          my $i;          my $i;
5205          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5206            my $node = $self->{open_elements}->[$_];            my $node = $self->{open_elements}->[$_];
5207            if ($node->[1] eq $token->{tag_name}) {            if ($node->[1] == FORM_EL) {
5208              !!!cp ('t418');              !!!cp ('t418');
5209              $i = $_;              $i = $_;
5210              last INSCOPE;              last INSCOPE;
5211            } elsif ({            } elsif ($node->[1] & SCOPING_EL) {
                     applet => 1, table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$node->[1]}) {  
5212              !!!cp ('t419');              !!!cp ('t419');
5213              last INSCOPE;              last INSCOPE;
5214            }            }
# Line 6223  sub _tree_construction_main ($) { Line 5216  sub _tree_construction_main ($) {
5216    
5217          unless (defined $i) { # has an element in scope          unless (defined $i) { # has an element in scope
5218            !!!cp ('t421');            !!!cp ('t421');
5219            !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);            !!!parse-error (type => 'unmatched end tag',
5220                              text => $token->{tag_name}, token => $token);
5221              ## NOTE: Ignore the token.
5222          } else {          } else {
5223            ## Step 1. generate implied end tags            ## Step 1. generate implied end tags
5224            while ({            while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
                   dd => 1, dt => 1, li => 1, p => 1,  
                  }->{$self->{open_elements}->[-1]->[1]}) {  
5225              !!!cp ('t417');              !!!cp ('t417');
5226              pop @{$self->{open_elements}};              pop @{$self->{open_elements}};
5227            }            }
5228                        
5229            ## Step 2.            ## Step 2.
5230            if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {            if ($self->{open_elements}->[-1]->[0]->manakai_local_name
5231                      ne $token->{tag_name}) {
5232              !!!cp ('t417.1');              !!!cp ('t417.1');
5233              !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1], token => $token);              !!!parse-error (type => 'not closed',
5234                                text => $self->{open_elements}->[-1]->[0]
5235                                    ->manakai_local_name,
5236                                token => $token);
5237            } else {            } else {
5238              !!!cp ('t420');              !!!cp ('t420');
5239            }              }  
# Line 6246  sub _tree_construction_main ($) { Line 5243  sub _tree_construction_main ($) {
5243          }          }
5244    
5245          !!!next-token;          !!!next-token;
5246          redo B;          next B;
5247        } elsif ({        } elsif ({
5248                    ## NOTE: As normal, except acts as a closer for any ...
5249                  h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,                  h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,
5250                 }->{$token->{tag_name}}) {                 }->{$token->{tag_name}}) {
5251          ## has an element in scope          ## has an element in scope
5252          my $i;          my $i;
5253          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5254            my $node = $self->{open_elements}->[$_];            my $node = $self->{open_elements}->[$_];
5255            if ({            if ($node->[1] == HEADING_EL) {
                h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1,  
               }->{$node->[1]}) {  
5256              !!!cp ('t423');              !!!cp ('t423');
5257              $i = $_;              $i = $_;
5258              last INSCOPE;              last INSCOPE;
5259            } elsif ({            } elsif ($node->[1] & SCOPING_EL) {
                     applet => 1, table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$node->[1]}) {  
5260              !!!cp ('t424');              !!!cp ('t424');
5261              last INSCOPE;              last INSCOPE;
5262            }            }
# Line 6271  sub _tree_construction_main ($) { Line 5264  sub _tree_construction_main ($) {
5264    
5265          unless (defined $i) { # has an element in scope          unless (defined $i) { # has an element in scope
5266            !!!cp ('t425.1');            !!!cp ('t425.1');
5267            !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);            !!!parse-error (type => 'unmatched end tag',
5268                              text => $token->{tag_name}, token => $token);
5269              ## NOTE: Ignore the token.
5270          } else {          } else {
5271            ## Step 1. generate implied end tags            ## Step 1. generate implied end tags
5272            while ({            while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
                   dd => 1, dt => 1, li => 1, p => 1,  
                  }->{$self->{open_elements}->[-1]->[1]}) {  
5273              !!!cp ('t422');              !!!cp ('t422');
5274              pop @{$self->{open_elements}};              pop @{$self->{open_elements}};
5275            }            }
5276                        
5277            ## Step 2.            ## Step 2.
5278            if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {            if ($self->{open_elements}->[-1]->[0]->manakai_local_name
5279                      ne $token->{tag_name}) {
5280              !!!cp ('t425');              !!!cp ('t425');
5281              !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);              !!!parse-error (type => 'unmatched end tag',
5282                                text => $token->{tag_name}, token => $token);
5283            } else {            } else {
5284              !!!cp ('t426');              !!!cp ('t426');
5285            }            }
# Line 6294  sub _tree_construction_main ($) { Line 5289  sub _tree_construction_main ($) {
5289          }          }
5290                    
5291          !!!next-token;          !!!next-token;
5292          redo B;          next B;
5293        } elsif ($token->{tag_name} eq 'p') {        } elsif ($token->{tag_name} eq 'p') {
5294            ## NOTE: As normal, except </p> implies <p> and ...
5295    
5296          ## has an element in scope          ## has an element in scope
5297            my $non_optional;
5298          my $i;          my $i;
5299          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {          INSCOPE: for (reverse 0..$#{$self->{open_elements}}) {
5300            my $node = $self->{open_elements}->[$_];            my $node = $self->{open_elements}->[$_];
5301            if ($node->[1] eq $token->{tag_name}) {            if ($node->[1] == P_EL) {
5302              !!!cp ('t410.1');              !!!cp ('t410.1');
5303              $i = $_;              $i = $_;
5304              last INSCOPE;              last INSCOPE;
5305            } elsif ({            } elsif ($node->[1] & SCOPING_EL) {
                     applet => 1, table => 1, caption => 1, td => 1, th => 1,  
                     button => 1, marquee => 1, object => 1, html => 1,  
                    }->{$node->[1]}) {  
5306              !!!cp ('t411.1');              !!!cp ('t411.1');
5307              last INSCOPE;              last INSCOPE;
5308              } elsif ($node->[1] & END_TAG_OPTIONAL_EL) {
5309                ## NOTE: |END_TAG_OPTIONAL_EL| includes "p"
5310                !!!cp ('t411.2');
5311                #
5312              } else {
5313                !!!cp ('t411.3');
5314                $non_optional ||= $node;
5315                #
5316            }            }
5317          } # INSCOPE          } # INSCOPE
5318    
5319          if (defined $i) {          if (defined $i) {
5320            if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) {            ## 1. Generate implied end tags
5321              #
5322    
5323              ## 2. If current node != "p", parse error
5324              if ($non_optional) {
5325              !!!cp ('t412.1');              !!!cp ('t412.1');
5326              !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1], token => $token);              !!!parse-error (type => 'not closed',
5327                                text => $non_optional->[0]->manakai_local_name,
5328                                token => $token);
5329            } else {            } else {
5330              !!!cp ('t414.1');              !!!cp ('t414.1');
5331            }            }
5332    
5333              ## 3. Pop
5334            splice @{$self->{open_elements}}, $i;            splice @{$self->{open_elements}}, $i;
5335          } else {          } else {
5336            !!!cp ('t413.1');            !!!cp ('t413.1');
5337            !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);            !!!parse-error (type => 'unmatched end tag',
5338                              text => $token->{tag_name}, token => $token);
5339    
5340            !!!cp ('t415.1');            !!!cp ('t415.1');
5341            ## As if <p>, then reprocess the current token            ## As if <p>, then reprocess the current token
5342            my $el;            my $el;
5343            !!!create-element ($el, 'p',, $token);            !!!create-element ($el, $HTML_NS, 'p',, $token);
5344            $insert->($el);            $insert->($el);
5345            ## NOTE: Not inserted into |$self->{open_elements}|.            ## NOTE: Not inserted into |$self->{open_elements}|.
5346          }          }
5347    
5348          !!!next-token;          !!!next-token;
5349          redo B;          next B;
5350        } elsif ({        } elsif ({
5351                  a => 1,                  a => 1,
5352                  b => 1, big => 1, em => 1, font => 1, i => 1,                  b => 1, big => 1, em => 1, font => 1, i => 1,
5353                  nobr => 1, s => 1, small => 1, strile => 1,                  nobr => 1, s => 1, small => 1, strike => 1,
5354                  strong => 1, tt => 1, u => 1,                  strong => 1, tt => 1, u => 1,
5355                 }->{$token->{tag_name}}) {                 }->{$token->{tag_name}}) {
5356          !!!cp ('t427');          !!!cp ('t427');
5357          $formatting_end_tag->($token);          $formatting_end_tag->($token);
5358          redo B;          next B;
5359        } elsif ($token->{tag_name} eq 'br') {        } elsif ($token->{tag_name} eq 'br') {
5360          !!!cp ('t428');          !!!cp ('t428');
5361          !!!parse-error (type => 'unmatched end tag:br', token => $token);          !!!parse-error (type => 'unmatched end tag',
5362                            text => 'br', token => $token);
5363    
5364          ## As if <br>          ## As if <br>
5365          $reconstruct_active_formatting_elements->($insert_to_current);          $reconstruct_active_formatting_elements->($insert_to_current);
5366                    
5367          my $el;          my $el;
5368          !!!create-element ($el, 'br',, $token);          !!!create-element ($el, $HTML_NS, 'br',, $token);
5369          $insert->($el);          $insert->($el);
5370                    
5371          ## Ignore the token.          ## Ignore the token.
5372          !!!next-token;          !!!next-token;
5373          redo B;          next B;
       } elsif ({  
                 caption => 1, col => 1, colgroup => 1, frame => 1,  
                 frameset => 1, head => 1, option => 1, optgroup => 1,  
                 tbody => 1, td => 1, tfoot => 1, th => 1,  
                 thead => 1, tr => 1,  
                 area => 1, basefont => 1, bgsound => 1,  
                 embed => 1, hr => 1, iframe => 1, image => 1,  
                 img => 1, input => 1, isindex => 1, noembed => 1,  
                 noframes => 1, param => 1, select => 1, spacer => 1,  
                 table => 1, textarea => 1, wbr => 1,  
                 noscript => 0, ## TODO: if scripting is enabled  
                }->{$token->{tag_name}}) {  
         !!!cp ('t429');  
         !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);  
         ## Ignore the token  
         !!!next-token;  
         redo B;  
           
         ## ISSUE: Issue on HTML5 new elements in spec  
           
5374        } else {        } else {
5375            if ($token->{tag_name} eq 'sarcasm') {
5376              sleep 0.001; # take a deep breath
5377            }
5378    
5379          ## Step 1          ## Step 1
5380          my $node_i = -1;          my $node_i = -1;
5381          my $node = $self->{open_elements}->[$node_i];          my $node = $self->{open_elements}->[$node_i];
5382    
5383          ## Step 2          ## Step 2
5384          S2: {          S2: {
5385            if ($node->[1] eq $token->{tag_name}) {            my $node_tag_name = $node->[0]->manakai_local_name;
5386              $node_tag_name =~ tr/A-Z/a-z/; # for SVG camelCase tag names
5387              if ($node_tag_name eq $token->{tag_name}) {
5388              ## Step 1              ## Step 1
5389              ## generate implied end tags              ## generate implied end tags
5390              while ({              while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) {
                     dd => 1, dt => 1, li => 1, p => 1,  
                    }->{$self->{open_elements}->[-1]->[1]}) {  
5391                !!!cp ('t430');                !!!cp ('t430');
5392                ## ISSUE: Can this case be reached?                ## NOTE: |<ruby><rt></ruby>|.
5393                  ## ISSUE: <ruby><rt></rt> will also take this code path,
5394                  ## which seems wrong.
5395                pop @{$self->{open_elements}};                pop @{$self->{open_elements}};
5396                  $node_i++;
5397              }              }
5398                    
5399              ## Step 2              ## Step 2
5400              if ($token->{tag_name} ne $self->{open_elements}->[-1]->[1]) {              my $current_tag_name
5401                    = $self->{open_elements}->[-1]->[0]->manakai_local_name;
5402                $current_tag_name =~ tr/A-Z/a-z/;
5403                if ($current_tag_name ne $token->{tag_name}) {
5404                !!!cp ('t431');                !!!cp ('t431');
5405                ## NOTE: <x><y></x>                ## NOTE: <x><y></x>
5406                !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1], token => $token);                !!!parse-error (type => 'not closed',
5407                                  text => $self->{open_elements}->[-1]->[0]
5408                                      ->manakai_local_name,
5409                                  token => $token);
5410              } else {              } else {
5411                !!!cp ('t432');                !!!cp ('t432');
5412              }              }
5413                            
5414              ## Step 3              ## Step 3
5415              splice @{$self->{open_elements}}, $node_i;              splice @{$self->{open_elements}}, $node_i if $node_i < 0;
5416    
5417              !!!next-token;              !!!next-token;
5418              last S2;              last S2;
5419            } else {            } else {
5420              ## Step 3              ## Step 3
5421              if (not $formatting_category->{$node->[1]} and              if (not ($node->[1] & FORMATTING_EL) and
5422                  #not $phrasing_category->{$node->[1]} and                  #not $phrasing_category->{$node->[1]} and
5423                  ($special_category->{$node->[1]} or                  ($node->[1] & SPECIAL_EL or
5424                   $scoping_category->{$node->[1]})) {                   $node->[1] & SCOPING_EL)) {
5425                !!!cp ('t433');                !!!cp ('t433');
5426                !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}, token => $token);                !!!parse-error (type => 'unmatched end tag',
5427                                  text => $token->{tag_name}, token => $token);
5428                ## Ignore the token                ## Ignore the token
5429                !!!next-token;                !!!next-token;
5430                last S2;                last S2;
             }  
5431    
5432                  ## NOTE: |<span><dd></span>a|: In Safari 3.1.2 and Opera
5433                  ## 9.27, "a" is a child of <dd> (conforming).  In
5434                  ## Firefox 3.0.2, "a" is a child of <body>.  In WinIE 7,
5435                  ## "a" is a child of both <body> and <dd>.
5436                }
5437                
5438              !!!cp ('t434');              !!!cp ('t434');
5439            }            }
5440                        
# Line 6434  sub _tree_construction_main ($) { Line 5445  sub _tree_construction_main ($) {
5445            ## Step 5;            ## Step 5;
5446            redo S2;            redo S2;
5447          } # S2          } # S2
5448          redo B;          next B;
5449        }        }
5450      }      }
5451      redo B;      next B;
5452      } continue { # B
5453        if ($self->{insertion_mode} & IN_FOREIGN_CONTENT_IM) {
5454          ## NOTE: The code below is executed in cases where it does not have
5455          ## to be, but it it is harmless even in those cases.
5456          ## has an element in scope
5457          INSCOPE: {
5458            for (reverse 0..$#{$self->{open_elements}}) {
5459              my $node = $self->{open_elements}->[$_];
5460              if ($node->[1] & FOREIGN_EL) {
5461                last INSCOPE;
5462              } elsif ($node->[1] & SCOPING_EL) {
5463                last;
5464              }
5465            }
5466            
5467            ## NOTE: No foreign element in scope.
5468            $self->{insertion_mode} &= ~ IN_FOREIGN_CONTENT_IM;
5469          } # INSCOPE
5470        }
5471    } # B    } # B
5472    
5473    ## Stop parsing # MUST    ## Stop parsing # MUST
# Line 6445  sub _tree_construction_main ($) { Line 5475  sub _tree_construction_main ($) {
5475    ## TODO: script stuffs    ## TODO: script stuffs
5476  } # _tree_construct_main  } # _tree_construct_main
5477    
5478  sub set_inner_html ($$$) {  ## XXX: How this method is organized is somewhat out of date, although
5479    ## it still does what the current spec documents.
5480    sub set_inner_html ($$$$;$) {
5481    my $class = shift;    my $class = shift;
5482    my $node = shift;    my $node = shift; # /context/
5483    my $s = \$_[0];    #my $s = \$_[0];
5484    my $onerror = $_[1];    my $onerror = $_[1];
5485      my $get_wrapper = $_[2] || sub ($) { return $_[0] };
   ## ISSUE: Should {confident} be true?  
5486    
5487    my $nt = $node->node_type;    my $nt = $node->node_type;
5488    if ($nt == 9) {    if ($nt == 9) { # Document (invoke the algorithm with no /context/ element)
5489      # MUST      # MUST
5490            
5491      ## Step 1 # MUST      ## Step 1 # MUST
# Line 6468  sub set_inner_html ($$$) { Line 5499  sub set_inner_html ($$$) {
5499      }      }
5500    
5501      ## Step 3, 4, 5 # MUST      ## Step 3, 4, 5 # MUST
5502      $class->parse_string ($$s => $node, $onerror);      $class->parse_char_string ($_[0] => $node, $onerror, $get_wrapper);
5503    } elsif ($nt == 1) {    } elsif ($nt == 1) { # Element (invoke the algorithm with /context/ element)
5504      ## TODO: If non-html element      ## TODO: If non-html element
5505    
5506      ## NOTE: Most of this code is copied from |parse_string|      ## NOTE: Most of this code is copied from |parse_string|
5507    
5508      ## Step 1 # MUST  ## TODO: Support for $get_wrapper
5509    
5510        ## F1. Create an HTML document.
5511      my $this_doc = $node->owner_document;      my $this_doc = $node->owner_document;
5512      my $doc = $this_doc->implementation->create_document;      my $doc = $this_doc->implementation->create_document;
5513      $doc->manakai_is_html (1);      $doc->manakai_is_html (1);
5514    
5515        ## F2. Propagate quirkness flag
5516        my $node_doc = $node->owner_document;
5517        $doc->manakai_compat_mode ($node_doc->manakai_compat_mode);
5518    
5519        ## F3. Create an HTML parser
5520      my $p = $class->new;      my $p = $class->new;
5521      $p->{document} = $doc;      $p->{document} = $doc;
5522    
# Line 6485  sub set_inner_html ($$$) { Line 5524  sub set_inner_html ($$$) {
5524      my $i = 0;      my $i = 0;
5525      $p->{line_prev} = $p->{line} = 1;      $p->{line_prev} = $p->{line} = 1;
5526      $p->{column_prev} = $p->{column} = 0;      $p->{column_prev} = $p->{column} = 0;
5527      $p->{set_next_char} = sub {      require Whatpm::Charset::DecodeHandle;
5528        my $input = Whatpm::Charset::DecodeHandle::CharString->new (\($_[0]));
5529        $input = $get_wrapper->($input);
5530        $p->{set_nc} = sub {
5531        my $self = shift;        my $self = shift;
5532    
5533        pop @{$self->{prev_char}};        my $char = '';
5534        unshift @{$self->{prev_char}}, $self->{next_char};        if (defined $self->{next_nc}) {
5535            $char = $self->{next_nc};
5536        $self->{next_char} = -1 and return if $i >= length $$s;          delete $self->{next_nc};
5537        $self->{next_char} = ord substr $$s, $i++, 1;          $self->{nc} = ord $char;
5538          } else {
5539            $self->{char_buffer} = '';
5540            $self->{char_buffer_pos} = 0;
5541            
5542            my $count = $input->manakai_read_until
5543                ($self->{char_buffer}, qr/[^\x00\x0A\x0D]/,
5544                 $self->{char_buffer_pos});
5545            if ($count) {
5546              $self->{line_prev} = $self->{line};
5547              $self->{column_prev} = $self->{column};
5548              $self->{column}++;
5549              $self->{nc}
5550                  = ord substr ($self->{char_buffer},
5551                                $self->{char_buffer_pos}++, 1);
5552              return;
5553            }
5554            
5555            if ($input->read ($char, 1)) {
5556              $self->{nc} = ord $char;
5557            } else {
5558              $self->{nc} = -1;
5559              return;
5560            }
5561          }
5562    
5563        ($p->{line_prev}, $p->{column_prev}) = ($p->{line}, $p->{column});        ($p->{line_prev}, $p->{column_prev}) = ($p->{line}, $p->{column});
5564        $p->{column}++;        $p->{column}++;
5565    
5566        if ($self->{next_char} == 0x000A) { # LF        if ($self->{nc} == 0x000A) { # LF
5567          $p->{line}++;          $p->{line}++;
5568          $p->{column} = 0;          $p->{column} = 0;
5569          !!!cp ('i1');          !!!cp ('i1');
5570        } elsif ($self->{next_char} == 0x000D) { # CR        } elsif ($self->{nc} == 0x000D) { # CR
5571          $i++ if substr ($$s, $i, 1) eq "\x0A";  ## TODO: support for abort/streaming
5572          $self->{next_char} = 0x000A; # LF # MUST          my $next = '';
5573            if ($input->read ($next, 1) and $next ne "\x0A") {
5574              $self->{next_nc} = $next;
5575            }
5576            $self->{nc} = 0x000A; # LF # MUST
5577          $p->{line}++;          $p->{line}++;
5578          $p->{column} = 0;          $p->{column} = 0;
5579          !!!cp ('i2');          !!!cp ('i2');
5580        } elsif ($self->{next_char} > 0x10FFFF) {        } elsif ($self->{nc} == 0x0000) { # NULL
         $self->{next_char} = 0xFFFD; # REPLACEMENT CHARACTER # MUST  
         !!!cp ('i3');  
       } elsif ($self->{next_char} == 0x0000) { # NULL  
5581          !!!cp ('i4');          !!!cp ('i4');
5582          !!!parse-error (type => 'NULL');          !!!parse-error (type => 'NULL');
5583          $self->{next_char} = 0xFFFD; # REPLACEMENT CHARACTER # MUST          $self->{nc} = 0xFFFD; # REPLACEMENT CHARACTER # MUST
5584        }        }
5585      };      };
5586      $p->{prev_char} = [-1, -1, -1];  
5587      $p->{next_char} = -1;      $p->{read_until} = sub {
5588              #my ($scalar, $specials_range, $offset) = @_;
5589          return 0 if defined $p->{next_nc};
5590    
5591          my $pattern = qr/[^$_[1]\x00\x0A\x0D]/;
5592          my $offset = $_[2] || 0;
5593          
5594          if ($p->{char_buffer_pos} < length $p->{char_buffer}) {
5595            pos ($p->{char_buffer}) = $p->{char_buffer_pos};
5596            if ($p->{char_buffer} =~ /\G(?>$pattern)+/) {
5597              substr ($_[0], $offset)
5598                  = substr ($p->{char_buffer}, $-[0], $+[0] - $-[0]);
5599              my $count = $+[0] - $-[0];
5600              if ($count) {
5601                $p->{column} += $count;
5602                $p->{char_buffer_pos} += $count;
5603                $p->{line_prev} = $p->{line};
5604                $p->{column_prev} = $p->{column} - 1;
5605                $p->{nc} = -1;
5606              }
5607              return $count;
5608            } else {
5609              return 0;
5610            }
5611          } else {
5612            my $count = $input->manakai_read_until ($_[0], $pattern, $_[2]);
5613            if ($count) {
5614              $p->{column} += $count;
5615              $p->{column_prev} += $count;
5616              $p->{nc} = -1;
5617            }
5618            return $count;
5619          }
5620        }; # $p->{read_until}
5621    
5622      my $ponerror = $onerror || sub {      my $ponerror = $onerror || sub {
5623        my (%opt) = @_;        my (%opt) = @_;
5624        my $line = $opt{line};        my $line = $opt{line};
# Line 6533  sub set_inner_html ($$$) { Line 5633  sub set_inner_html ($$$) {
5633        $ponerror->(line => $p->{line}, column => $p->{column}, @_);        $ponerror->(line => $p->{line}, column => $p->{column}, @_);
5634      };      };
5635            
5636        my $char_onerror = sub {
5637          my (undef, $type, %opt) = @_;
5638          $ponerror->(layer => 'encode',
5639                      line => $p->{line}, column => $p->{column} + 1,
5640                      %opt, type => $type);
5641        }; # $char_onerror
5642        $input->onerror ($char_onerror);
5643    
5644      $p->_initialize_tokenizer;      $p->_initialize_tokenizer;
5645      $p->_initialize_tree_constructor;      $p->_initialize_tree_constructor;
5646    
5647      ## Step 2      ## F4. If /context/ is not undef...
5648    
5649        ## F4.1. content model flag
5650      my $node_ln = $node->manakai_local_name;      my $node_ln = $node->manakai_local_name;
5651      $p->{content_model} = {      $p->{content_model} = {
5652        title => RCDATA_CONTENT_MODEL,        title => RCDATA_CONTENT_MODEL,
# Line 6552  sub set_inner_html ($$$) { Line 5662  sub set_inner_html ($$$) {
5662      }->{$node_ln};      }->{$node_ln};
5663      $p->{content_model} = PCDATA_CONTENT_MODEL      $p->{content_model} = PCDATA_CONTENT_MODEL
5664          unless defined $p->{content_model};          unless defined $p->{content_model};
         ## ISSUE: What is "the name of the element"? local name?  
5665    
5666      $p->{inner_html_node} = [$node, $node_ln];      $p->{inner_html_node} = [$node, $el_category->{$node_ln}];
5667          ## TODO: Foreign element OK?
5668    
5669      ## Step 3      ## F4.2. Root |html| element
5670      my $root = $doc->create_element_ns      my $root = $doc->create_element_ns
5671        ('http://www.w3.org/1999/xhtml', [undef, 'html']);        ('http://www.w3.org/1999/xhtml', [undef, 'html']);
5672    
5673      ## Step 4 # MUST      ## F4.3.
5674      $doc->append_child ($root);      $doc->append_child ($root);
5675    
5676      ## Step 5 # MUST      ## F4.4.
5677      push @{$p->{open_elements}}, [$root, 'html'];      push @{$p->{open_elements}}, [$root, $el_category->{html}];
5678    
5679      undef $p->{head_element};      undef $p->{head_element};
5680        undef $p->{head_element_inserted};
5681    
5682      ## Step 6 # MUST      ## F4.5.
5683      $p->_reset_insertion_mode;      $p->_reset_insertion_mode;
5684    
5685      ## Step 7 # MUST      ## F4.6.
5686      my $anode = $node;      my $anode = $node;
5687      AN: while (defined $anode) {      AN: while (defined $anode) {
5688        if ($anode->node_type == 1) {        if ($anode->node_type == 1) {
# Line 6586  sub set_inner_html ($$$) { Line 5697  sub set_inner_html ($$$) {
5697        }        }
5698        $anode = $anode->parent_node;        $anode = $anode->parent_node;
5699      } # AN      } # AN
5700        
5701      ## Step 9 # MUST      ## F.5. Set the input stream.
5702        $p->{confident} = 1; ## Confident: irrelevant.
5703    
5704        ## F.6. Start the parser.
5705      {      {
5706        my $self = $p;        my $self = $p;
5707        !!!next-token;        !!!next-token;
5708      }      }
5709      $p->_tree_construction_main;      $p->_tree_construction_main;
5710    
5711      ## Step 10 # MUST      ## F.7.
5712      my @cn = @{$node->child_nodes};      my @cn = @{$node->child_nodes};
5713      for (@cn) {      for (@cn) {
5714        $node->remove_child ($_);        $node->remove_child ($_);
Legend:
Removed from v.1.121  
changed lines
  Added in v.1.243
admin@suikawiki.org
 ViewVC Help
Powered by ViewVC 1.1.24