Parent Directory
| 
Revision Log
| 
Patch
| revision 1.112 by wakaba, Sun Mar 16 06:39:57 2008 UTC | revision 1.211 by wakaba, Mon Oct 27 05:44:47 2008 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 | eventsource => MISC_SPECIAL_EL, | |
| 183 | fieldset => MISC_SPECIAL_EL, | |
| 184 | figure => MISC_SPECIAL_EL, | |
| 185 | font => FORMATTING_EL, | |
| 186 | footer => MISC_SPECIAL_EL, | |
| 187 | form => FORM_EL, | |
| 188 | frame => MISC_SPECIAL_EL, | |
| 189 | frameset => FRAMESET_EL, | |
| 190 | h1 => HEADING_EL, | |
| 191 | h2 => HEADING_EL, | |
| 192 | h3 => HEADING_EL, | |
| 193 | h4 => HEADING_EL, | |
| 194 | h5 => HEADING_EL, | |
| 195 | h6 => HEADING_EL, | |
| 196 | head => MISC_SPECIAL_EL, | |
| 197 | header => 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 | li => LI_EL, | |
| 207 | link => MISC_SPECIAL_EL, | |
| 208 | listing => MISC_SPECIAL_EL, | |
| 209 | marquee => MISC_SCOPING_EL, | |
| 210 | menu => MISC_SPECIAL_EL, | |
| 211 | meta => MISC_SPECIAL_EL, | |
| 212 | nav => MISC_SPECIAL_EL, | |
| 213 | nobr => NOBR_EL, | |
| 214 | noembed => MISC_SPECIAL_EL, | |
| 215 | noframes => MISC_SPECIAL_EL, | |
| 216 | noscript => MISC_SPECIAL_EL, | |
| 217 | object => MISC_SCOPING_EL, | |
| 218 | ol => MISC_SPECIAL_EL, | |
| 219 | optgroup => OPTGROUP_EL, | |
| 220 | option => OPTION_EL, | |
| 221 | p => P_EL, | |
| 222 | param => MISC_SPECIAL_EL, | |
| 223 | plaintext => MISC_SPECIAL_EL, | |
| 224 | pre => MISC_SPECIAL_EL, | |
| 225 | rp => RUBY_COMPONENT_EL, | |
| 226 | rt => RUBY_COMPONENT_EL, | |
| 227 | ruby => RUBY_EL, | |
| 228 | s => FORMATTING_EL, | |
| 229 | script => MISC_SPECIAL_EL, | |
| 230 | select => SELECT_EL, | |
| 231 | section => MISC_SPECIAL_EL, | |
| 232 | small => FORMATTING_EL, | |
| 233 | spacer => MISC_SPECIAL_EL, | |
| 234 | strike => FORMATTING_EL, | |
| 235 | strong => FORMATTING_EL, | |
| 236 | style => MISC_SPECIAL_EL, | |
| 237 | table => TABLE_EL, | |
| 238 | tbody => TABLE_ROW_GROUP_EL, | |
| 239 | td => TABLE_CELL_EL, | |
| 240 | textarea => MISC_SPECIAL_EL, | |
| 241 | tfoot => TABLE_ROW_GROUP_EL, | |
| 242 | th => TABLE_CELL_EL, | |
| 243 | thead => TABLE_ROW_GROUP_EL, | |
| 244 | title => MISC_SPECIAL_EL, | |
| 245 | tr => TABLE_ROW_EL, | |
| 246 | tt => FORMATTING_EL, | |
| 247 | u => FORMATTING_EL, | |
| 248 | ul => MISC_SPECIAL_EL, | |
| 249 | wbr => MISC_SPECIAL_EL, | |
| 250 | }; | }; |
| 251 | ||
| 252 | my $c1_entity_char = { | my $el_category_f = { |
| 253 | 0x80 => 0x20AC, | $MML_NS => { |
| 254 | 0x81 => 0xFFFD, | 'annotation-xml' => MML_AXML_EL, |
| 255 | 0x82 => 0x201A, | mi => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL, |
| 256 | 0x83 => 0x0192, | mo => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL, |
| 257 | 0x84 => 0x201E, | mn => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL, |
| 258 | 0x85 => 0x2026, | ms => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL, |
| 259 | 0x86 => 0x2020, | mtext => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL, |
| 260 | 0x87 => 0x2021, | }, |
| 261 | 0x88 => 0x02C6, | $SVG_NS => { |
| 262 | 0x89 => 0x2030, | foreignObject => SCOPING_EL | FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL, |
| 263 | 0x8A => 0x0160, | desc => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL, |
| 264 | 0x8B => 0x2039, | title => FOREIGN_EL | FOREIGN_FLOW_CONTENT_EL, |
| 265 | 0x8C => 0x0152, | }, |
| 266 | 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, | ||
| 267 | }; | }; |
| 268 | my $scoping_category = { | |
| 269 | applet => 1, button => 1, caption => 1, html => 1, marquee => 1, object => 1, | my $svg_attr_name = { |
| 270 | table => 1, td => 1, th => 1, | attributename => 'attributeName', |
| 271 | attributetype => 'attributeType', | |
| 272 | basefrequency => 'baseFrequency', | |
| 273 | baseprofile => 'baseProfile', | |
| 274 | calcmode => 'calcMode', | |
| 275 | clippathunits => 'clipPathUnits', | |
| 276 | contentscripttype => 'contentScriptType', | |
| 277 | contentstyletype => 'contentStyleType', | |
| 278 | diffuseconstant => 'diffuseConstant', | |
| 279 | edgemode => 'edgeMode', | |
| 280 | externalresourcesrequired => 'externalResourcesRequired', | |
| 281 | filterres => 'filterRes', | |
| 282 | filterunits => 'filterUnits', | |
| 283 | glyphref => 'glyphRef', | |
| 284 | gradienttransform => 'gradientTransform', | |
| 285 | gradientunits => 'gradientUnits', | |
| 286 | kernelmatrix => 'kernelMatrix', | |
| 287 | kernelunitlength => 'kernelUnitLength', | |
| 288 | keypoints => 'keyPoints', | |
| 289 | keysplines => 'keySplines', | |
| 290 | keytimes => 'keyTimes', | |
| 291 | lengthadjust => 'lengthAdjust', | |
| 292 | limitingconeangle => 'limitingConeAngle', | |
| 293 | markerheight => 'markerHeight', | |
| 294 | markerunits => 'markerUnits', | |
| 295 | markerwidth => 'markerWidth', | |
| 296 | maskcontentunits => 'maskContentUnits', | |
| 297 | maskunits => 'maskUnits', | |
| 298 | numoctaves => 'numOctaves', | |
| 299 | pathlength => 'pathLength', | |
| 300 | patterncontentunits => 'patternContentUnits', | |
| 301 | patterntransform => 'patternTransform', | |
| 302 | patternunits => 'patternUnits', | |
| 303 | pointsatx => 'pointsAtX', | |
| 304 | pointsaty => 'pointsAtY', | |
| 305 | pointsatz => 'pointsAtZ', | |
| 306 | preservealpha => 'preserveAlpha', | |
| 307 | preserveaspectratio => 'preserveAspectRatio', | |
| 308 | primitiveunits => 'primitiveUnits', | |
| 309 | refx => 'refX', | |
| 310 | refy => 'refY', | |
| 311 | repeatcount => 'repeatCount', | |
| 312 | repeatdur => 'repeatDur', | |
| 313 | requiredextensions => 'requiredExtensions', | |
| 314 | requiredfeatures => 'requiredFeatures', | |
| 315 | specularconstant => 'specularConstant', | |
| 316 | specularexponent => 'specularExponent', | |
| 317 | spreadmethod => 'spreadMethod', | |
| 318 | startoffset => 'startOffset', | |
| 319 | stddeviation => 'stdDeviation', | |
| 320 | stitchtiles => 'stitchTiles', | |
| 321 | surfacescale => 'surfaceScale', | |
| 322 | systemlanguage => 'systemLanguage', | |
| 323 | tablevalues => 'tableValues', | |
| 324 | targetx => 'targetX', | |
| 325 | targety => 'targetY', | |
| 326 | textlength => 'textLength', | |
| 327 | viewbox => 'viewBox', | |
| 328 | viewtarget => 'viewTarget', | |
| 329 | xchannelselector => 'xChannelSelector', | |
| 330 | ychannelselector => 'yChannelSelector', | |
| 331 | zoomandpan => 'zoomAndPan', | |
| 332 | }; | }; |
| 333 | my $formatting_category = { | |
| 334 | a => 1, b => 1, big => 1, em => 1, font => 1, i => 1, nobr => 1, | my $foreign_attr_xname = { |
| 335 | s => 1, small => 1, strile => 1, strong => 1, tt => 1, u => 1, | 'xlink:actuate' => [$XLINK_NS, ['xlink', 'actuate']], |
| 336 | 'xlink:arcrole' => [$XLINK_NS, ['xlink', 'arcrole']], | |
| 337 | 'xlink:href' => [$XLINK_NS, ['xlink', 'href']], | |
| 338 | 'xlink:role' => [$XLINK_NS, ['xlink', 'role']], | |
| 339 | 'xlink:show' => [$XLINK_NS, ['xlink', 'show']], | |
| 340 | 'xlink:title' => [$XLINK_NS, ['xlink', 'title']], | |
| 341 | 'xlink:type' => [$XLINK_NS, ['xlink', 'type']], | |
| 342 | 'xml:base' => [$XML_NS, ['xml', 'base']], | |
| 343 | 'xml:lang' => [$XML_NS, ['xml', 'lang']], | |
| 344 | 'xml:space' => [$XML_NS, ['xml', 'space']], | |
| 345 | 'xmlns' => [$XMLNS_NS, [undef, 'xmlns']], | |
| 346 | 'xmlns:xlink' => [$XMLNS_NS, ['xmlns', 'xlink']], | |
| 347 | }; | }; |
| 348 | # $phrasing_category: all other elements | |
| 349 | ## ISSUE: xmlns:xlink="non-xlink-ns" is not an error. | |
| 350 | ||
| 351 | ## TODO: Invoke the reset algorithm when a resettable element is | |
| 352 | ## created (cf. HTML5 revision 2259). | |
| 353 | ||
| 354 | sub parse_byte_string ($$$$;$) { | sub parse_byte_string ($$$$;$) { |
| 355 | my $self = shift; | |
| 356 | my $charset_name = shift; | |
| 357 | open my $input, '<', ref $_[0] ? $_[0] : \($_[0]); | |
| 358 | return $self->parse_byte_stream ($charset_name, $input, @_[1..$#_]); | |
| 359 | } # parse_byte_string | |
| 360 | ||
| 361 | sub parse_byte_stream ($$$$;$$) { | |
| 362 | # my ($self, $charset_name, $byte_stream, $doc, $onerror, $get_wrapper) = @_; | |
| 363 | my $self = ref $_[0] ? shift : shift->new; | my $self = ref $_[0] ? shift : shift->new; |
| 364 | my $charset = shift; | my $charset_name = shift; |
| 365 | my $bytes_s = ref $_[0] ? $_[0] : \($_[0]); | my $byte_stream = $_[0]; |
| my $s; | ||
| if (defined $charset) { | ||
| require Encode; ## TODO: decode(utf8) don't delete BOM | ||
| $s = \ (Encode::decode ($charset, $$bytes_s)); | ||
| $self->{input_encoding} = lc $charset; ## TODO: normalize name | ||
| $self->{confident} = 1; | ||
| } else { | ||
| ## TODO: Implement HTML5 detection algorithm | ||
| require Whatpm::Charset::UniversalCharDet; | ||
| $charset = Whatpm::Charset::UniversalCharDet->detect_byte_string | ||
| (substr ($$bytes_s, 0, 1024)); | ||
| $charset ||= 'windows-1252'; | ||
| $s = \ (Encode::decode ($charset, $$bytes_s)); | ||
| $self->{input_encoding} = $charset; | ||
| $self->{confident} = 0; | ||
| } | ||
| 366 | ||
| 367 | $self->{change_encoding} = sub { | my $onerror = $_[2] || sub { |
| 368 | my $self = shift; | my (%opt) = @_; |
| 369 | my $charset = lc shift; | warn "Parse error ($opt{type})\n"; |
| 370 | ## TODO: if $charset is supported | }; |
| 371 | ## TODO: normalize charset name | $self->{parse_error} = $onerror; # updated later by parse_char_string |
| 372 | ||
| 373 | ## "Change the encoding" algorithm: | my $get_wrapper = $_[3] || sub ($) { |
| 374 | return $_[0]; # $_[0] = byte stream handle, returned = arg to char handle | |
| 375 | ## Step 1 | }; |
| 376 | if ($charset eq 'utf-16') { ## ISSUE: UTF-16BE -> UTF-8? UTF-16LE -> UTF-8? | |
| 377 | $charset = 'utf-8'; | ## HTML5 encoding sniffing algorithm |
| 378 | require Message::Charset::Info; | |
| 379 | my $charset; | |
| 380 | my $buffer; | |
| 381 | my ($char_stream, $e_status); | |
| 382 | ||
| 383 | SNIFFING: { | |
| 384 | ## NOTE: By setting |allow_fallback| option true when the | |
| 385 | ## |get_decode_handle| method is invoked, we ignore what the HTML5 | |
| 386 | ## spec requires, i.e. unsupported encoding should be ignored. | |
| 387 | ## TODO: We should not do this unless the parser is invoked | |
| 388 | ## in the conformance checking mode, in which this behavior | |
| 389 | ## would be useful. | |
| 390 | ||
| 391 | ## Step 1 | |
| 392 | if (defined $charset_name) { | |
| 393 | $charset = Message::Charset::Info->get_by_html_name ($charset_name); | |
| 394 | ## TODO: Is this ok? Transfer protocol's parameter should be | |
| 395 | ## interpreted in its semantics? | |
| 396 | ||
| 397 | ($char_stream, $e_status) = $charset->get_decode_handle | |
| 398 | ($byte_stream, allow_error_reporting => 1, | |
| 399 | allow_fallback => 1); | |
| 400 | if ($char_stream) { | |
| 401 | $self->{confident} = 1; | |
| 402 | last SNIFFING; | |
| 403 | } else { | |
| 404 | !!!parse-error (type => 'charset:not supported', | |
| 405 | layer => 'encode', | |
| 406 | line => 1, column => 1, | |
| 407 | value => $charset_name, | |
| 408 | level => $self->{level}->{uncertain}); | |
| 409 | } | |
| 410 | } | } |
| 411 | ||
| 412 | ## Step 2 | ## Step 2 |
| 413 | if (defined $self->{input_encoding} and | my $byte_buffer = ''; |
| 414 | $self->{input_encoding} eq $charset) { | for (1..1024) { |
| 415 | my $char = $byte_stream->getc; | |
| 416 | last unless defined $char; | |
| 417 | $byte_buffer .= $char; | |
| 418 | } ## TODO: timeout | |
| 419 | ||
| 420 | ## Step 3 | |
| 421 | if ($byte_buffer =~ /^\xFE\xFF/) { | |
| 422 | $charset = Message::Charset::Info->get_by_html_name ('utf-16be'); | |
| 423 | ($char_stream, $e_status) = $charset->get_decode_handle | |
| 424 | ($byte_stream, allow_error_reporting => 1, | |
| 425 | allow_fallback => 1, byte_buffer => \$byte_buffer); | |
| 426 | $self->{confident} = 1; | $self->{confident} = 1; |
| 427 | return; | last SNIFFING; |
| 428 | } elsif ($byte_buffer =~ /^\xFF\xFE/) { | |
| 429 | $charset = Message::Charset::Info->get_by_html_name ('utf-16le'); | |
| 430 | ($char_stream, $e_status) = $charset->get_decode_handle | |
| 431 | ($byte_stream, allow_error_reporting => 1, | |
| 432 | allow_fallback => 1, byte_buffer => \$byte_buffer); | |
| 433 | $self->{confident} = 1; | |
| 434 | last SNIFFING; | |
| 435 | } elsif ($byte_buffer =~ /^\xEF\xBB\xBF/) { | |
| 436 | $charset = Message::Charset::Info->get_by_html_name ('utf-8'); | |
| 437 | ($char_stream, $e_status) = $charset->get_decode_handle | |
| 438 | ($byte_stream, allow_error_reporting => 1, | |
| 439 | allow_fallback => 1, byte_buffer => \$byte_buffer); | |
| 440 | $self->{confident} = 1; | |
| 441 | last SNIFFING; | |
| 442 | } | } |
| 443 | ||
| 444 | !!!parse-error (type => 'charset label detected:'.$self->{input_encoding}. | ## Step 4 |
| 445 | ':'.$charset, level => 'w'); | ## TODO: <meta charset> |
| 446 | ||
| 447 | ## Step 3 | ## Step 5 |
| 448 | # if (can) { | ## TODO: from history |
| ## change the encoding on the fly. | ||
| #$self->{confident} = 1; | ||
| #return; | ||
| # } | ||
| 449 | ||
| 450 | ## Step 4 | ## Step 6 |
| 451 | throw Whatpm::HTML::RestartParser (charset => $charset); | require Whatpm::Charset::UniversalCharDet; |
| 452 | $charset_name = Whatpm::Charset::UniversalCharDet->detect_byte_string | |
| 453 | ($byte_buffer); | |
| 454 | if (defined $charset_name) { | |
| 455 | $charset = Message::Charset::Info->get_by_html_name ($charset_name); | |
| 456 | ||
| 457 | require Whatpm::Charset::DecodeHandle; | |
| 458 | $buffer = Whatpm::Charset::DecodeHandle::ByteBuffer->new | |
| 459 | ($byte_stream); | |
| 460 | ($char_stream, $e_status) = $charset->get_decode_handle | |
| 461 | ($buffer, allow_error_reporting => 1, | |
| 462 | allow_fallback => 1, byte_buffer => \$byte_buffer); | |
| 463 | if ($char_stream) { | |
| 464 | $buffer->{buffer} = $byte_buffer; | |
| 465 | !!!parse-error (type => 'sniffing:chardet', | |
| 466 | text => $charset_name, | |
| 467 | level => $self->{level}->{info}, | |
| 468 | layer => 'encode', | |
| 469 | line => 1, column => 1); | |
| 470 | $self->{confident} = 0; | |
| 471 | last SNIFFING; | |
| 472 | } | |
| 473 | } | |
| 474 | ||
| 475 | ## Step 7: default | |
| 476 | ## TODO: Make this configurable. | |
| 477 | $charset = Message::Charset::Info->get_by_html_name ('windows-1252'); | |
| 478 | ## NOTE: We choose |windows-1252| here, since |utf-8| should be | |
| 479 | ## detectable in the step 6. | |
| 480 | require Whatpm::Charset::DecodeHandle; | |
| 481 | $buffer = Whatpm::Charset::DecodeHandle::ByteBuffer->new | |
| 482 | ($byte_stream); | |
| 483 | ($char_stream, $e_status) | |
| 484 | = $charset->get_decode_handle ($buffer, | |
| 485 | allow_error_reporting => 1, | |
| 486 | allow_fallback => 1, | |
| 487 | byte_buffer => \$byte_buffer); | |
| 488 | $buffer->{buffer} = $byte_buffer; | |
| 489 | !!!parse-error (type => 'sniffing:default', | |
| 490 | text => 'windows-1252', | |
| 491 | level => $self->{level}->{info}, | |
| 492 | line => 1, column => 1, | |
| 493 | layer => 'encode'); | |
| 494 | $self->{confident} = 0; | |
| 495 | } # SNIFFING | |
| 496 | ||
| 497 | if ($e_status & Message::Charset::Info::FALLBACK_ENCODING_IMPL ()) { | |
| 498 | $self->{input_encoding} = $charset->get_iana_name; ## TODO: Should we set actual charset decoder's encoding name? | |
| 499 | !!!parse-error (type => 'chardecode:fallback', | |
| 500 | #text => $self->{input_encoding}, | |
| 501 | level => $self->{level}->{uncertain}, | |
| 502 | line => 1, column => 1, | |
| 503 | layer => 'encode'); | |
| 504 | } elsif (not ($e_status & | |
| 505 | Message::Charset::Info::ERROR_REPORTING_ENCODING_IMPL ())) { | |
| 506 | $self->{input_encoding} = $charset->get_iana_name; | |
| 507 | !!!parse-error (type => 'chardecode:no error', | |
| 508 | text => $self->{input_encoding}, | |
| 509 | level => $self->{level}->{uncertain}, | |
| 510 | line => 1, column => 1, | |
| 511 | layer => 'encode'); | |
| 512 | } else { | |
| 513 | $self->{input_encoding} = $charset->get_iana_name; | |
| 514 | } | |
| 515 | ||
| 516 | $self->{change_encoding} = sub { | |
| 517 | my $self = shift; | |
| 518 | $charset_name = shift; | |
| 519 | my $token = shift; | |
| 520 | ||
| 521 | $charset = Message::Charset::Info->get_by_html_name ($charset_name); | |
| 522 | ($char_stream, $e_status) = $charset->get_decode_handle | |
| 523 | ($byte_stream, allow_error_reporting => 1, allow_fallback => 1, | |
| 524 | byte_buffer => \ $buffer->{buffer}); | |
| 525 | ||
| 526 | if ($char_stream) { # if supported | |
| 527 | ## "Change the encoding" algorithm: | |
| 528 | ||
| 529 | ## Step 1 | |
| 530 | if ($charset->{category} & | |
| 531 | Message::Charset::Info::CHARSET_CATEGORY_UTF16 ()) { | |
| 532 | $charset = Message::Charset::Info->get_by_html_name ('utf-8'); | |
| 533 | ($char_stream, $e_status) = $charset->get_decode_handle | |
| 534 | ($byte_stream, | |
| 535 | byte_buffer => \ $buffer->{buffer}); | |
| 536 | } | |
| 537 | $charset_name = $charset->get_iana_name; | |
| 538 | ||
| 539 | ## Step 2 | |
| 540 | if (defined $self->{input_encoding} and | |
| 541 | $self->{input_encoding} eq $charset_name) { | |
| 542 | !!!parse-error (type => 'charset label:matching', | |
| 543 | text => $charset_name, | |
| 544 | level => $self->{level}->{info}); | |
| 545 | $self->{confident} = 1; | |
| 546 | return; | |
| 547 | } | |
| 548 | ||
| 549 | !!!parse-error (type => 'charset label detected', | |
| 550 | text => $self->{input_encoding}, | |
| 551 | value => $charset_name, | |
| 552 | level => $self->{level}->{warn}, | |
| 553 | token => $token); | |
| 554 | ||
| 555 | ## Step 3 | |
| 556 | # if (can) { | |
| 557 | ## change the encoding on the fly. | |
| 558 | #$self->{confident} = 1; | |
| 559 | #return; | |
| 560 | # } | |
| 561 | ||
| 562 | ## Step 4 | |
| 563 | throw Whatpm::HTML::RestartParser (); | |
| 564 | } | |
| 565 | }; # $self->{change_encoding} | }; # $self->{change_encoding} |
| 566 | ||
| 567 | my @args = @_; shift @args; # $s | my $char_onerror = sub { |
| 568 | my (undef, $type, %opt) = @_; | |
| 569 | !!!parse-error (layer => 'encode', | |
| 570 | line => $self->{line}, column => $self->{column} + 1, | |
| 571 | %opt, type => $type); | |
| 572 | if ($opt{octets}) { | |
| 573 | ${$opt{octets}} = "\x{FFFD}"; # relacement character | |
| 574 | } | |
| 575 | }; | |
| 576 | ||
| 577 | my $wrapped_char_stream = $get_wrapper->($char_stream); | |
| 578 | $wrapped_char_stream->onerror ($char_onerror); | |
| 579 | ||
| 580 | my @args = ($_[1], $_[2]); # $doc, $onerror - $get_wrapper = undef; | |
| 581 | my $return; | my $return; |
| 582 | try { | try { |
| 583 | $return = $self->parse_char_string ($s, @args); | $return = $self->parse_char_stream ($wrapped_char_stream, @args); |
| 584 | } catch Whatpm::HTML::RestartParser with { | } catch Whatpm::HTML::RestartParser with { |
| 585 | my $charset = shift->{charset}; | ## NOTE: Invoked after {change_encoding}. |
| 586 | $s = \ (Encode::decode ($charset, $$bytes_s)); | |
| 587 | $self->{input_encoding} = $charset; ## TODO: normalize | if ($e_status & Message::Charset::Info::FALLBACK_ENCODING_IMPL ()) { |
| 588 | $self->{input_encoding} = $charset->get_iana_name; ## TODO: Should we set actual charset decoder's encoding name? | |
| 589 | !!!parse-error (type => 'chardecode:fallback', | |
| 590 | level => $self->{level}->{uncertain}, | |
| 591 | #text => $self->{input_encoding}, | |
| 592 | line => 1, column => 1, | |
| 593 | layer => 'encode'); | |
| 594 | } elsif (not ($e_status & | |
| 595 | Message::Charset::Info::ERROR_REPORTING_ENCODING_IMPL ())) { | |
| 596 | $self->{input_encoding} = $charset->get_iana_name; | |
| 597 | !!!parse-error (type => 'chardecode:no error', | |
| 598 | text => $self->{input_encoding}, | |
| 599 | level => $self->{level}->{uncertain}, | |
| 600 | line => 1, column => 1, | |
| 601 | layer => 'encode'); | |
| 602 | } else { | |
| 603 | $self->{input_encoding} = $charset->get_iana_name; | |
| 604 | } | |
| 605 | $self->{confident} = 1; | $self->{confident} = 1; |
| 606 | $return = $self->parse_char_string ($s, @args); | |
| 607 | $wrapped_char_stream = $get_wrapper->($char_stream); | |
| 608 | $wrapped_char_stream->onerror ($char_onerror); | |
| 609 | ||
| 610 | $return = $self->parse_char_stream ($wrapped_char_stream, @args); | |
| 611 | }; | }; |
| 612 | return $return; | return $return; |
| 613 | } # parse_byte_string | } # parse_byte_stream |
| 614 | ||
| 615 | ## NOTE: HTML5 spec says that the encoding layer MUST NOT strip BOM | ## NOTE: HTML5 spec says that the encoding layer MUST NOT strip BOM |
| 616 | ## 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 162 sub parse_byte_string ($$$$;$) { | Line 621 sub parse_byte_string ($$$$;$) { |
| 621 | ## 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 |
| 622 | ## strip the BOM and never strip any ZWNBSP. | ## strip the BOM and never strip any ZWNBSP. |
| 623 | ||
| 624 | *parse_char_string = \&parse_string; | sub parse_char_string ($$$;$$) { |
| 625 | #my ($self, $s, $doc, $onerror, $get_wrapper) = @_; | |
| 626 | my $self = shift; | |
| 627 | my $s = ref $_[0] ? $_[0] : \($_[0]); | |
| 628 | require Whatpm::Charset::DecodeHandle; | |
| 629 | my $input = Whatpm::Charset::DecodeHandle::CharString->new ($s); | |
| 630 | return $self->parse_char_stream ($input, @_[1..$#_]); | |
| 631 | } # parse_char_string | |
| 632 | *parse_string = \&parse_char_string; ## NOTE: Alias for backward compatibility. | |
| 633 | ||
| 634 | sub parse_string ($$$;$) { | sub parse_char_stream ($$$;$$) { |
| 635 | my $self = ref $_[0] ? shift : shift->new; | my $self = ref $_[0] ? shift : shift->new; |
| 636 | my $s = ref $_[0] ? $_[0] : \($_[0]); | my $input = $_[0]; |
| 637 | $self->{document} = $_[1]; | $self->{document} = $_[1]; |
| 638 | @{$self->{document}->child_nodes} = (); | @{$self->{document}->child_nodes} = (); |
| 639 | ||
| # | Line 175 sub parse_string ($$$;$) { | Line 642 sub parse_string ($$$;$) { |
| 642 | $self->{confident} = 1 unless exists $self->{confident}; | $self->{confident} = 1 unless exists $self->{confident}; |
| 643 | $self->{document}->input_encoding ($self->{input_encoding}) | $self->{document}->input_encoding ($self->{input_encoding}) |
| 644 | if defined $self->{input_encoding}; | if defined $self->{input_encoding}; |
| 645 | ## TODO: |{input_encoding}| is needless? | |
| 646 | ||
| my $i = 0; | ||
| 647 | $self->{line_prev} = $self->{line} = 1; | $self->{line_prev} = $self->{line} = 1; |
| 648 | $self->{column_prev} = $self->{column} = 0; | $self->{column_prev} = -1; |
| 649 | $self->{set_next_char} = sub { | $self->{column} = 0; |
| 650 | $self->{set_nc} = sub { | |
| 651 | my $self = shift; | my $self = shift; |
| 652 | ||
| 653 | pop @{$self->{prev_char}}; | my $char = ''; |
| 654 | unshift @{$self->{prev_char}}, $self->{next_char}; | if (defined $self->{next_nc}) { |
| 655 | $char = $self->{next_nc}; | |
| 656 | delete $self->{next_nc}; | |
| 657 | $self->{nc} = ord $char; | |
| 658 | } else { | |
| 659 | $self->{char_buffer} = ''; | |
| 660 | $self->{char_buffer_pos} = 0; | |
| 661 | ||
| 662 | $self->{next_char} = -1 and return if $i >= length $$s; | my $count = $input->manakai_read_until |
| 663 | $self->{next_char} = ord substr $$s, $i++, 1; | ($self->{char_buffer}, qr/[^\x00\x0A\x0D]/, $self->{char_buffer_pos}); |
| 664 | if ($count) { | |
| 665 | $self->{line_prev} = $self->{line}; | |
| 666 | $self->{column_prev} = $self->{column}; | |
| 667 | $self->{column}++; | |
| 668 | $self->{nc} | |
| 669 | = ord substr ($self->{char_buffer}, $self->{char_buffer_pos}++, 1); | |
| 670 | return; | |
| 671 | } | |
| 672 | ||
| 673 | if ($input->read ($char, 1)) { | |
| 674 | $self->{nc} = ord $char; | |
| 675 | } else { | |
| 676 | $self->{nc} = -1; | |
| 677 | return; | |
| 678 | } | |
| 679 | } | |
| 680 | ||
| 681 | ($self->{line_prev}, $self->{column_prev}) | ($self->{line_prev}, $self->{column_prev}) |
| 682 | = ($self->{line}, $self->{column}); | = ($self->{line}, $self->{column}); |
| 683 | $self->{column}++; | $self->{column}++; |
| 684 | ||
| 685 | if ($self->{next_char} == 0x000A) { # LF | if ($self->{nc} == 0x000A) { # LF |
| 686 | !!!cp ('j1'); | |
| 687 | $self->{line}++; | $self->{line}++; |
| 688 | $self->{column} = 0; | $self->{column} = 0; |
| 689 | } elsif ($self->{next_char} == 0x000D) { # CR | } elsif ($self->{nc} == 0x000D) { # CR |
| 690 | $i++ if substr ($$s, $i, 1) eq "\x0A"; | !!!cp ('j2'); |
| 691 | $self->{next_char} = 0x000A; # LF # MUST | ## TODO: support for abort/streaming |
| 692 | my $next = ''; | |
| 693 | if ($input->read ($next, 1) and $next ne "\x0A") { | |
| 694 | $self->{next_nc} = $next; | |
| 695 | } | |
| 696 | $self->{nc} = 0x000A; # LF # MUST | |
| 697 | $self->{line}++; | $self->{line}++; |
| 698 | $self->{column} = 0; | $self->{column} = 0; |
| 699 | } elsif ($self->{next_char} > 0x10FFFF) { | } elsif ($self->{nc} == 0x0000) { # NULL |
| 700 | $self->{next_char} = 0xFFFD; # REPLACEMENT CHARACTER # MUST | !!!cp ('j4'); |
| } elsif ($self->{next_char} == 0x0000) { # NULL | ||
| 701 | !!!parse-error (type => 'NULL'); | !!!parse-error (type => 'NULL'); |
| 702 | $self->{next_char} = 0xFFFD; # REPLACEMENT CHARACTER # MUST | $self->{nc} = 0xFFFD; # REPLACEMENT CHARACTER # MUST |
| 703 | } | } |
| 704 | }; | }; |
| 705 | $self->{prev_char} = [-1, -1, -1]; | |
| 706 | $self->{next_char} = -1; | $self->{read_until} = sub { |
| 707 | #my ($scalar, $specials_range, $offset) = @_; | |
| 708 | return 0 if defined $self->{next_nc}; | |
| 709 | ||
| 710 | my $pattern = qr/[^$_[1]\x00\x0A\x0D]/; | |
| 711 | my $offset = $_[2] || 0; | |
| 712 | ||
| 713 | if ($self->{char_buffer_pos} < length $self->{char_buffer}) { | |
| 714 | pos ($self->{char_buffer}) = $self->{char_buffer_pos}; | |
| 715 | if ($self->{char_buffer} =~ /\G(?>$pattern)+/) { | |
| 716 | substr ($_[0], $offset) | |
| 717 | = substr ($self->{char_buffer}, $-[0], $+[0] - $-[0]); | |
| 718 | my $count = $+[0] - $-[0]; | |
| 719 | if ($count) { | |
| 720 | $self->{column} += $count; | |
| 721 | $self->{char_buffer_pos} += $count; | |
| 722 | $self->{line_prev} = $self->{line}; | |
| 723 | $self->{column_prev} = $self->{column} - 1; | |
| 724 | $self->{nc} = -1; | |
| 725 | } | |
| 726 | return $count; | |
| 727 | } else { | |
| 728 | return 0; | |
| 729 | } | |
| 730 | } else { | |
| 731 | my $count = $input->manakai_read_until ($_[0], $pattern, $_[2]); | |
| 732 | if ($count) { | |
| 733 | $self->{column} += $count; | |
| 734 | $self->{line_prev} = $self->{line}; | |
| 735 | $self->{column_prev} = $self->{column} - 1; | |
| 736 | $self->{nc} = -1; | |
| 737 | } | |
| 738 | return $count; | |
| 739 | } | |
| 740 | }; # $self->{read_until} | |
| 741 | ||
| 742 | my $onerror = $_[2] || sub { | my $onerror = $_[2] || sub { |
| 743 | my (%opt) = @_; | my (%opt) = @_; |
| # | Line 220 sub parse_string ($$$;$) { | Line 749 sub parse_string ($$$;$) { |
| 749 | $onerror->(line => $self->{line}, column => $self->{column}, @_); | $onerror->(line => $self->{line}, column => $self->{column}, @_); |
| 750 | }; | }; |
| 751 | ||
| 752 | my $char_onerror = sub { | |
| 753 | my (undef, $type, %opt) = @_; | |
| 754 | !!!parse-error (layer => 'encode', | |
| 755 | line => $self->{line}, column => $self->{column} + 1, | |
| 756 | %opt, type => $type); | |
| 757 | }; # $char_onerror | |
| 758 | ||
| 759 | if ($_[3]) { | |
| 760 | $input = $_[3]->($input); | |
| 761 | $input->onerror ($char_onerror); | |
| 762 | } else { | |
| 763 | $input->onerror ($char_onerror) unless defined $input->onerror; | |
| 764 | } | |
| 765 | ||
| 766 | $self->_initialize_tokenizer; | $self->_initialize_tokenizer; |
| 767 | $self->_initialize_tree_constructor; | $self->_initialize_tree_constructor; |
| 768 | $self->_construct_tree; | $self->_construct_tree; |
| # | Line 228 sub parse_string ($$$;$) { | Line 771 sub parse_string ($$$;$) { |
| 771 | delete $self->{parse_error}; # remove loop | delete $self->{parse_error}; # remove loop |
| 772 | ||
| 773 | return $self->{document}; | return $self->{document}; |
| 774 | } # parse_string | } # parse_char_stream |
| 775 | ||
| 776 | sub new ($) { | sub new ($) { |
| 777 | my $class = shift; | my $class = shift; |
| 778 | my $self = bless {}, $class; | my $self = bless { |
| 779 | $self->{set_next_char} = sub { | level => {must => 'm', |
| 780 | $self->{next_char} = -1; | should => 's', |
| 781 | warn => 'w', | |
| 782 | info => 'i', | |
| 783 | uncertain => 'u'}, | |
| 784 | }, $class; | |
| 785 | $self->{set_nc} = sub { | |
| 786 | $self->{nc} = -1; | |
| 787 | }; | }; |
| 788 | $self->{parse_error} = sub { | $self->{parse_error} = sub { |
| 789 | # | # |
| # | Line 251 sub new ($) { | Line 800 sub new ($) { |
| 800 | return $self; | return $self; |
| 801 | } # new | } # new |
| 802 | ||
| 803 | 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 } | ||
| 804 | ||
| 805 | sub AFTER_HTML_IMS () { 0b100 } | sub AFTER_HTML_IMS () { 0b100 } |
| 806 | sub HEAD_IMS () { 0b1000 } | sub HEAD_IMS () { 0b1000 } |
| # | Line 311 sub ROW_IMS () { 0b10000000 } | Line 811 sub ROW_IMS () { 0b10000000 } |
| 811 | sub BODY_AFTER_IMS () { 0b100000000 } | sub BODY_AFTER_IMS () { 0b100000000 } |
| 812 | sub FRAME_IMS () { 0b1000000000 } | sub FRAME_IMS () { 0b1000000000 } |
| 813 | sub SELECT_IMS () { 0b10000000000 } | sub SELECT_IMS () { 0b10000000000 } |
| 814 | #sub IN_FOREIGN_CONTENT_IM () { 0b100000000000 } # see Whatpm::HTML::Tokenizer | |
| 815 | ## NOTE: "in foreign content" insertion mode is special; it is combined | |
| 816 | ## with the secondary insertion mode. In this parser, they are stored | |
| 817 | ## together in the bit-or'ed form. | |
| 818 | sub IN_CDATA_RCDATA_IM () { 0b1000000000000 } | |
| 819 | ## NOTE: "in CDATA/RCDATA" insertion mode is also special; it is | |
| 820 | ## combined with the original insertion mode. In thie parser, | |
| 821 | ## they are stored together in the bit-or'ed form. | |
| 822 | ||
| 823 | sub IM_MASK () { 0b11111111111 } | |
| 824 | ||
| 825 | ## NOTE: "initial" and "before html" insertion modes have no constants. | ## NOTE: "initial" and "before html" insertion modes have no constants. |
| 826 | ||
| # | Line 337 sub IN_SELECT_IM () { SELECT_IMS | 0b01 | Line 847 sub IN_SELECT_IM () { SELECT_IMS | 0b01 |
| 847 | sub IN_SELECT_IN_TABLE_IM () { SELECT_IMS | 0b10 } | sub IN_SELECT_IN_TABLE_IM () { SELECT_IMS | 0b10 } |
| 848 | sub IN_COLUMN_GROUP_IM () { 0b10 } | sub IN_COLUMN_GROUP_IM () { 0b10 } |
| 849 | ||
| ## 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'); | ||
| $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'); | ||
| $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}); | ||
| 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'); | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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 => ''}; | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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 => ''}; | ||
| $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}); | ||
| ## 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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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 => ''}; | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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 => ''}; | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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->{current_token}->{first_start_tag} | ||
| = not defined $self->{last_emitted_start_tag_name}; | ||
| $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'); | ||
| $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'); | ||
| $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 | ||
| 850 | sub _initialize_tree_constructor ($) { | sub _initialize_tree_constructor ($) { |
| 851 | my $self = shift; | my $self = shift; |
| 852 | ## NOTE: $self->{document} MUST be specified before this method is called | ## NOTE: $self->{document} MUST be specified before this method is called |
| # | Line 2452 sub _initialize_tree_constructor ($) { | Line 854 sub _initialize_tree_constructor ($) { |
| 854 | ## TODO: Turn mutation events off # MUST | ## TODO: Turn mutation events off # MUST |
| 855 | ## TODO: Turn loose Document option (manakai extension) on | ## TODO: Turn loose Document option (manakai extension) on |
| 856 | $self->{document}->manakai_is_html (1); # MUST | $self->{document}->manakai_is_html (1); # MUST |
| 857 | $self->{document}->set_user_data (manakai_source_line => 1); | |
| 858 | $self->{document}->set_user_data (manakai_source_column => 1); | |
| 859 | } # _initialize_tree_constructor | } # _initialize_tree_constructor |
| 860 | ||
| 861 | sub _terminate_tree_constructor ($) { | sub _terminate_tree_constructor ($) { |
| # | Line 2471 sub _construct_tree ($) { | Line 875 sub _construct_tree ($) { |
| 875 | ## When an interactive UA render the $self->{document} available | ## When an interactive UA render the $self->{document} available |
| 876 | ## to the user, or when it begin accepting user input, are | ## to the user, or when it begin accepting user input, are |
| 877 | ## 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 | ||
| 878 | ||
| 879 | !!!next-token; | !!!next-token; |
| 880 | ||
| 881 | undef $self->{form_element}; | undef $self->{form_element}; |
| 882 | undef $self->{head_element}; | undef $self->{head_element}; |
| 883 | undef $self->{head_element_inserted}; | |
| 884 | $self->{open_elements} = []; | $self->{open_elements} = []; |
| 885 | undef $self->{inner_html_node}; | undef $self->{inner_html_node}; |
| 886 | undef $self->{ignore_newline}; | |
| 887 | ||
| 888 | ## NOTE: The "initial" insertion mode. | ## NOTE: The "initial" insertion mode. |
| 889 | $self->_tree_construction_initial; # MUST | $self->_tree_construction_initial; # MUST |
| # | Line 2506 sub _tree_construction_initial ($) { | Line 908 sub _tree_construction_initial ($) { |
| 908 | ## language. | ## language. |
| 909 | my $doctype_name = $token->{name}; | my $doctype_name = $token->{name}; |
| 910 | $doctype_name = '' unless defined $doctype_name; | $doctype_name = '' unless defined $doctype_name; |
| 911 | $doctype_name =~ tr/a-z/A-Z/; | $doctype_name =~ tr/a-z/A-Z/; # ASCII case-insensitive |
| 912 | if (not defined $token->{name} or # <!DOCTYPE> | if (not defined $token->{name} or # <!DOCTYPE> |
| 913 | defined $token->{public_identifier} or | defined $token->{sysid}) { |
| defined $token->{system_identifier}) { | ||
| 914 | !!!cp ('t1'); | !!!cp ('t1'); |
| 915 | !!!parse-error (type => 'not HTML5'); | !!!parse-error (type => 'not HTML5', token => $token); |
| 916 | } elsif ($doctype_name ne 'HTML') { | } elsif ($doctype_name ne 'HTML') { |
| 917 | !!!cp ('t2'); | !!!cp ('t2'); |
| 918 | ## ISSUE: ASCII case-insensitive? (in fact it does not matter) | !!!parse-error (type => 'not HTML5', token => $token); |
| 919 | !!!parse-error (type => 'not HTML5'); | } elsif (defined $token->{pubid}) { |
| 920 | if ($token->{pubid} eq 'XSLT-compat') { | |
| 921 | !!!cp ('t1.2'); | |
| 922 | !!!parse-error (type => 'XSLT-compat', token => $token, | |
| 923 | level => $self->{level}->{should}); | |
| 924 | } else { | |
| 925 | !!!parse-error (type => 'not HTML5', token => $token); | |
| 926 | } | |
| 927 | } else { | } else { |
| 928 | !!!cp ('t3'); | !!!cp ('t3'); |
| 929 | # | |
| 930 | } | } |
| 931 | ||
| 932 | my $doctype = $self->{document}->create_document_type_definition | my $doctype = $self->{document}->create_document_type_definition |
| 933 | ($token->{name}); ## ISSUE: If name is missing (e.g. <!DOCTYPE>)? | ($token->{name}); ## ISSUE: If name is missing (e.g. <!DOCTYPE>)? |
| 934 | $doctype->public_id ($token->{public_identifier}) | ## NOTE: Default value for both |public_id| and |system_id| attributes |
| 935 | if defined $token->{public_identifier}; | ## are empty strings, so that we don't set any value in missing cases. |
| 936 | $doctype->system_id ($token->{system_identifier}) | $doctype->public_id ($token->{pubid}) if defined $token->{pubid}; |
| 937 | if defined $token->{system_identifier}; | $doctype->system_id ($token->{sysid}) if defined $token->{sysid}; |
| 938 | ## NOTE: Other DocumentType attributes are null or empty lists. | ## NOTE: Other DocumentType attributes are null or empty lists. |
| 939 | ## ISSUE: internalSubset = null?? | ## In Firefox3, |internalSubset| attribute is set to the empty |
| 940 | ## string, while |null| is an allowed value for the attribute | |
| 941 | ## according to DOM3 Core. | |
| 942 | $self->{document}->append_child ($doctype); | $self->{document}->append_child ($doctype); |
| 943 | ||
| 944 | if ($token->{quirks} or $doctype_name ne 'HTML') { | if ($token->{quirks} or $doctype_name ne 'HTML') { |
| 945 | !!!cp ('t4'); | !!!cp ('t4'); |
| 946 | $self->{document}->manakai_compat_mode ('quirks'); | $self->{document}->manakai_compat_mode ('quirks'); |
| 947 | } elsif (defined $token->{public_identifier}) { | } elsif (defined $token->{pubid}) { |
| 948 | my $pubid = $token->{public_identifier}; | my $pubid = $token->{pubid}; |
| 949 | $pubid =~ tr/a-z/A-z/; | $pubid =~ tr/a-z/A-z/; |
| 950 | if ({ | my $prefix = [ |
| 951 | "+//SILMARIL//DTD HTML PRO V0R11 19970101//EN" => 1, | "+//SILMARIL//DTD HTML PRO V0R11 19970101//", |
| 952 | "-//ADVASOFT LTD//DTD HTML 3.0 ASWEDIT + EXTENSIONS//EN" => 1, | "-//ADVASOFT LTD//DTD HTML 3.0 ASWEDIT + EXTENSIONS//", |
| 953 | "-//AS//DTD HTML 3.0 ASWEDIT + EXTENSIONS//EN" => 1, | "-//AS//DTD HTML 3.0 ASWEDIT + EXTENSIONS//", |
| 954 | "-//IETF//DTD HTML 2.0 LEVEL 1//EN" => 1, | "-//IETF//DTD HTML 2.0 LEVEL 1//", |
| 955 | "-//IETF//DTD HTML 2.0 LEVEL 2//EN" => 1, | "-//IETF//DTD HTML 2.0 LEVEL 2//", |
| 956 | "-//IETF//DTD HTML 2.0 STRICT LEVEL 1//EN" => 1, | "-//IETF//DTD HTML 2.0 STRICT LEVEL 1//", |
| 957 | "-//IETF//DTD HTML 2.0 STRICT LEVEL 2//EN" => 1, | "-//IETF//DTD HTML 2.0 STRICT LEVEL 2//", |
| 958 | "-//IETF//DTD HTML 2.0 STRICT//EN" => 1, | "-//IETF//DTD HTML 2.0 STRICT//", |
| 959 | "-//IETF//DTD HTML 2.0//EN" => 1, | "-//IETF//DTD HTML 2.0//", |
| 960 | "-//IETF//DTD HTML 2.1E//EN" => 1, | "-//IETF//DTD HTML 2.1E//", |
| 961 | "-//IETF//DTD HTML 3.0//EN" => 1, | "-//IETF//DTD HTML 3.0//", |
| 962 | "-//IETF//DTD HTML 3.0//EN//" => 1, | "-//IETF//DTD HTML 3.2 FINAL//", |
| 963 | "-//IETF//DTD HTML 3.2 FINAL//EN" => 1, | "-//IETF//DTD HTML 3.2//", |
| 964 | "-//IETF//DTD HTML 3.2//EN" => 1, | "-//IETF//DTD HTML 3//", |
| 965 | "-//IETF//DTD HTML 3//EN" => 1, | "-//IETF//DTD HTML LEVEL 0//", |
| 966 | "-//IETF//DTD HTML LEVEL 0//EN" => 1, | "-//IETF//DTD HTML LEVEL 1//", |
| 967 | "-//IETF//DTD HTML LEVEL 0//EN//2.0" => 1, | "-//IETF//DTD HTML LEVEL 2//", |
| 968 | "-//IETF//DTD HTML LEVEL 1//EN" => 1, | "-//IETF//DTD HTML LEVEL 3//", |
| 969 | "-//IETF//DTD HTML LEVEL 1//EN//2.0" => 1, | "-//IETF//DTD HTML STRICT LEVEL 0//", |
| 970 | "-//IETF//DTD HTML LEVEL 2//EN" => 1, | "-//IETF//DTD HTML STRICT LEVEL 1//", |
| 971 | "-//IETF//DTD HTML LEVEL 2//EN//2.0" => 1, | "-//IETF//DTD HTML STRICT LEVEL 2//", |
| 972 | "-//IETF//DTD HTML LEVEL 3//EN" => 1, | "-//IETF//DTD HTML STRICT LEVEL 3//", |
| 973 | "-//IETF//DTD HTML LEVEL 3//EN//3.0" => 1, | "-//IETF//DTD HTML STRICT//", |
| 974 | "-//IETF//DTD HTML STRICT LEVEL 0//EN" => 1, | "-//IETF//DTD HTML//", |
| 975 | "-//IETF//DTD HTML STRICT LEVEL 0//EN//2.0" => 1, | "-//METRIUS//DTD METRIUS PRESENTATIONAL//", |
| 976 | "-//IETF//DTD HTML STRICT LEVEL 1//EN" => 1, | "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML STRICT//", |
| 977 | "-//IETF//DTD HTML STRICT LEVEL 1//EN//2.0" => 1, | "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML//", |
| 978 | "-//IETF//DTD HTML STRICT LEVEL 2//EN" => 1, | "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 TABLES//", |
| 979 | "-//IETF//DTD HTML STRICT LEVEL 2//EN//2.0" => 1, | "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML STRICT//", |
| 980 | "-//IETF//DTD HTML STRICT LEVEL 3//EN" => 1, | "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML//", |
| 981 | "-//IETF//DTD HTML STRICT LEVEL 3//EN//3.0" => 1, | "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 TABLES//", |
| 982 | "-//IETF//DTD HTML STRICT//EN" => 1, | "-//NETSCAPE COMM. CORP.//DTD HTML//", |
| 983 | "-//IETF//DTD HTML STRICT//EN//2.0" => 1, | "-//NETSCAPE COMM. CORP.//DTD STRICT HTML//", |
| 984 | "-//IETF//DTD HTML STRICT//EN//3.0" => 1, | "-//O'REILLY AND ASSOCIATES//DTD HTML 2.0//", |
| 985 | "-//IETF//DTD HTML//EN" => 1, | "-//O'REILLY AND ASSOCIATES//DTD HTML EXTENDED 1.0//", |
| 986 | "-//IETF//DTD HTML//EN//2.0" => 1, | "-//O'REILLY AND ASSOCIATES//DTD HTML EXTENDED RELAXED 1.0//", |
| 987 | "-//IETF//DTD HTML//EN//3.0" => 1, | "-//SOFTQUAD SOFTWARE//DTD HOTMETAL PRO 6.0::19990601::EXTENSIONS TO HTML 4.0//", |
| 988 | "-//METRIUS//DTD METRIUS PRESENTATIONAL//EN" => 1, | "-//SOFTQUAD//DTD HOTMETAL PRO 4.0::19971010::EXTENSIONS TO HTML 4.0//", |
| 989 | "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML STRICT//EN" => 1, | "-//SPYGLASS//DTD HTML 2.0 EXTENDED//", |
| 990 | "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 HTML//EN" => 1, | "-//SQ//DTD HTML 2.0 HOTMETAL + EXTENSIONS//", |
| 991 | "-//MICROSOFT//DTD INTERNET EXPLORER 2.0 TABLES//EN" => 1, | "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA HTML//", |
| 992 | "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML STRICT//EN" => 1, | "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA STRICT HTML//", |
| 993 | "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 HTML//EN" => 1, | "-//W3C//DTD HTML 3 1995-03-24//", |
| 994 | "-//MICROSOFT//DTD INTERNET EXPLORER 3.0 TABLES//EN" => 1, | "-//W3C//DTD HTML 3.2 DRAFT//", |
| 995 | "-//NETSCAPE COMM. CORP.//DTD HTML//EN" => 1, | "-//W3C//DTD HTML 3.2 FINAL//", |
| 996 | "-//NETSCAPE COMM. CORP.//DTD STRICT HTML//EN" => 1, | "-//W3C//DTD HTML 3.2//", |
| 997 | "-//O'REILLY AND ASSOCIATES//DTD HTML 2.0//EN" => 1, | "-//W3C//DTD HTML 3.2S DRAFT//", |
| 998 | "-//O'REILLY AND ASSOCIATES//DTD HTML EXTENDED 1.0//EN" => 1, | "-//W3C//DTD HTML 4.0 FRAMESET//", |
| 999 | "-//O'REILLY AND ASSOCIATES//DTD HTML EXTENDED RELAXED 1.0//EN" => 1, | "-//W3C//DTD HTML 4.0 TRANSITIONAL//", |
| 1000 | "-//SOFTQUAD SOFTWARE//DTD HOTMETAL PRO 6.0::19990601::EXTENSIONS TO HTML 4.0//EN" => 1, | "-//W3C//DTD HTML EXPERIMETNAL 19960712//", |
| 1001 | "-//SOFTQUAD//DTD HOTMETAL PRO 4.0::19971010::EXTENSIONS TO HTML 4.0//EN" => 1, | "-//W3C//DTD HTML EXPERIMENTAL 970421//", |
| 1002 | "-//SPYGLASS//DTD HTML 2.0 EXTENDED//EN" => 1, | "-//W3C//DTD W3 HTML//", |
| 1003 | "-//SQ//DTD HTML 2.0 HOTMETAL + EXTENSIONS//EN" => 1, | "-//W3O//DTD W3 HTML 3.0//", |
| 1004 | "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA HTML//EN" => 1, | "-//WEBTECHS//DTD MOZILLA HTML 2.0//", |
| 1005 | "-//SUN MICROSYSTEMS CORP.//DTD HOTJAVA STRICT HTML//EN" => 1, | "-//WEBTECHS//DTD MOZILLA HTML//", |
| 1006 | "-//W3C//DTD HTML 3 1995-03-24//EN" => 1, | ]; # $prefix |
| 1007 | "-//W3C//DTD HTML 3.2 DRAFT//EN" => 1, | my $match; |
| 1008 | "-//W3C//DTD HTML 3.2 FINAL//EN" => 1, | for (@$prefix) { |
| 1009 | "-//W3C//DTD HTML 3.2//EN" => 1, | if (substr ($prefix, 0, length $_) eq $_) { |
| 1010 | "-//W3C//DTD HTML 3.2S DRAFT//EN" => 1, | $match = 1; |
| 1011 | "-//W3C//DTD HTML 4.0 FRAMESET//EN" => 1, | last; |
| 1012 | "-//W3C//DTD HTML 4.0 TRANSITIONAL//EN" => 1, | } |
| 1013 | "-//W3C//DTD HTML EXPERIMETNAL 19960712//EN" => 1, | } |
| 1014 | "-//W3C//DTD HTML EXPERIMENTAL 970421//EN" => 1, | if ($match or |
| 1015 | "-//W3C//DTD W3 HTML//EN" => 1, | $pubid eq "-//W3O//DTD W3 HTML STRICT 3.0//EN//" or |
| 1016 | "-//W3O//DTD W3 HTML 3.0//EN" => 1, | $pubid eq "-/W3C/DTD HTML 4.0 TRANSITIONAL/EN" or |
| 1017 | "-//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}) { | ||
| 1018 | !!!cp ('t5'); | !!!cp ('t5'); |
| 1019 | $self->{document}->manakai_compat_mode ('quirks'); | $self->{document}->manakai_compat_mode ('quirks'); |
| 1020 | } elsif ($pubid eq "-//W3C//DTD HTML 4.01 FRAMESET//EN" or | } elsif ($pubid =~ m[^-//W3C//DTD HTML 4.01 FRAMESET//] or |
| 1021 | $pubid eq "-//W3C//DTD HTML 4.01 TRANSITIONAL//EN") { | $pubid =~ m[^-//W3C//DTD HTML 4.01 TRANSITIONAL//]) { |
| 1022 | if (defined $token->{system_identifier}) { | if (defined $token->{sysid}) { |
| 1023 | !!!cp ('t6'); | !!!cp ('t6'); |
| 1024 | $self->{document}->manakai_compat_mode ('quirks'); | $self->{document}->manakai_compat_mode ('quirks'); |
| 1025 | } else { | } else { |
| 1026 | !!!cp ('t7'); | !!!cp ('t7'); |
| 1027 | $self->{document}->manakai_compat_mode ('limited quirks'); | $self->{document}->manakai_compat_mode ('limited quirks'); |
| 1028 | } | } |
| 1029 | } elsif ($pubid eq "-//W3C//DTD XHTML 1.0 FRAMESET//EN" or | } elsif ($pubid =~ m[^-//W3C//DTD XHTML 1.0 FRAMESET//] or |
| 1030 | $pubid eq "-//W3C//DTD XHTML 1.0 TRANSITIONAL//EN") { | $pubid =~ m[^-//W3C//DTD XHTML 1.0 TRANSITIONAL//]) { |
| 1031 | !!!cp ('t8'); | !!!cp ('t8'); |
| 1032 | $self->{document}->manakai_compat_mode ('limited quirks'); | $self->{document}->manakai_compat_mode ('limited quirks'); |
| 1033 | } else { | } else { |
| # | Line 2631 sub _tree_construction_initial ($) { | Line 1036 sub _tree_construction_initial ($) { |
| 1036 | } else { | } else { |
| 1037 | !!!cp ('t10'); | !!!cp ('t10'); |
| 1038 | } | } |
| 1039 | if (defined $token->{system_identifier}) { | if (defined $token->{sysid}) { |
| 1040 | my $sysid = $token->{system_identifier}; | my $sysid = $token->{sysid}; |
| 1041 | $sysid =~ tr/A-Z/a-z/; | $sysid =~ tr/A-Z/a-z/; |
| 1042 | 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") { |
| 1043 | ## TODO: Check the spec: PUBLIC "(limited quirks)" "(quirks)" | ## NOTE: Ensure that |PUBLIC "(limited quirks)" "(quirks)"| is |
| 1044 | ## marked as quirks. | |
| 1045 | $self->{document}->manakai_compat_mode ('quirks'); | $self->{document}->manakai_compat_mode ('quirks'); |
| 1046 | !!!cp ('t11'); | !!!cp ('t11'); |
| 1047 | } else { | } else { |
| # | Line 2654 sub _tree_construction_initial ($) { | Line 1060 sub _tree_construction_initial ($) { |
| 1060 | END_OF_FILE_TOKEN, 1, | END_OF_FILE_TOKEN, 1, |
| 1061 | }->{$token->{type}}) { | }->{$token->{type}}) { |
| 1062 | !!!cp ('t14'); | !!!cp ('t14'); |
| 1063 | !!!parse-error (type => 'no DOCTYPE'); | !!!parse-error (type => 'no DOCTYPE', token => $token); |
| 1064 | $self->{document}->manakai_compat_mode ('quirks'); | $self->{document}->manakai_compat_mode ('quirks'); |
| 1065 | ## Go to the "before html" insertion mode. | ## Go to the "before html" insertion mode. |
| 1066 | ## reprocess | ## reprocess |
| 1067 | !!!ack-later; | |
| 1068 | return; | return; |
| 1069 | } elsif ($token->{type} == CHARACTER_TOKEN) { | } elsif ($token->{type} == CHARACTER_TOKEN) { |
| 1070 | if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D | if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) { |
| 1071 | ## Ignore the token | ## Ignore the token |
| 1072 | ||
| 1073 | unless (length $token->{data}) { | unless (length $token->{data}) { |
| # | Line 2675 sub _tree_construction_initial ($) { | Line 1082 sub _tree_construction_initial ($) { |
| 1082 | !!!cp ('t17'); | !!!cp ('t17'); |
| 1083 | } | } |
| 1084 | ||
| 1085 | !!!parse-error (type => 'no DOCTYPE'); | !!!parse-error (type => 'no DOCTYPE', token => $token); |
| 1086 | $self->{document}->manakai_compat_mode ('quirks'); | $self->{document}->manakai_compat_mode ('quirks'); |
| 1087 | ## Go to the "before html" insertion mode. | ## Go to the "before html" insertion mode. |
| 1088 | ## reprocess | ## reprocess |
| # | Line 2704 sub _tree_construction_root_element ($) | Line 1111 sub _tree_construction_root_element ($) |
| 1111 | B: { | B: { |
| 1112 | if ($token->{type} == DOCTYPE_TOKEN) { | if ($token->{type} == DOCTYPE_TOKEN) { |
| 1113 | !!!cp ('t19'); | !!!cp ('t19'); |
| 1114 | !!!parse-error (type => 'in html:#DOCTYPE'); | !!!parse-error (type => 'in html:#DOCTYPE', token => $token); |
| 1115 | ## Ignore the token | ## Ignore the token |
| 1116 | ## Stay in the insertion mode. | ## Stay in the insertion mode. |
| 1117 | !!!next-token; | !!!next-token; |
| # | Line 2717 sub _tree_construction_root_element ($) | Line 1124 sub _tree_construction_root_element ($) |
| 1124 | !!!next-token; | !!!next-token; |
| 1125 | redo B; | redo B; |
| 1126 | } elsif ($token->{type} == CHARACTER_TOKEN) { | } elsif ($token->{type} == CHARACTER_TOKEN) { |
| 1127 | if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { # \x0D | if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) { |
| 1128 | ## Ignore the token. | ## Ignore the token. |
| 1129 | ||
| 1130 | unless (length $token->{data}) { | unless (length $token->{data}) { |
| # | Line 2738 sub _tree_construction_root_element ($) | Line 1145 sub _tree_construction_root_element ($) |
| 1145 | } elsif ($token->{type} == START_TAG_TOKEN) { | } elsif ($token->{type} == START_TAG_TOKEN) { |
| 1146 | if ($token->{tag_name} eq 'html') { | if ($token->{tag_name} eq 'html') { |
| 1147 | my $root_element; | my $root_element; |
| 1148 | !!!create-element ($root_element, $token->{tag_name}, $token->{attributes}); | !!!create-element ($root_element, $HTML_NS, $token->{tag_name}, $token->{attributes}, $token); |
| 1149 | $self->{document}->append_child ($root_element); | $self->{document}->append_child ($root_element); |
| 1150 | push @{$self->{open_elements}}, [$root_element, 'html']; | push @{$self->{open_elements}}, |
| 1151 | [$root_element, $el_category->{html}]; | |
| 1152 | ||
| 1153 | if ($token->{attributes}->{manifest}) { | if ($token->{attributes}->{manifest}) { |
| 1154 | !!!cp ('t24'); | !!!cp ('t24'); |
| 1155 | $self->{application_cache_selection} | $self->{application_cache_selection} |
| 1156 | ->($token->{attributes}->{manifest}->{value}); | ->($token->{attributes}->{manifest}->{value}); |
| 1157 | ## ISSUE: No relative reference resolution? | ## ISSUE: Spec is unclear on relative references. |
| 1158 | ## According to Hixie (#whatwg 2008-03-19), it should be | |
| 1159 | ## resolved against the base URI of the document in HTML | |
| 1160 | ## or xml:base of the element in XHTML. | |
| 1161 | } else { | } else { |
| 1162 | !!!cp ('t25'); | !!!cp ('t25'); |
| 1163 | $self->{application_cache_selection}->(undef); | $self->{application_cache_selection}->(undef); |
| 1164 | } | } |
| 1165 | ||
| 1166 | !!!nack ('t25c'); | |
| 1167 | ||
| 1168 | !!!next-token; | !!!next-token; |
| 1169 | return; ## Go to the "before head" insertion mode. | return; ## Go to the "before head" insertion mode. |
| 1170 | } else { | } else { |
| # | Line 2768 sub _tree_construction_root_element ($) | Line 1181 sub _tree_construction_root_element ($) |
| 1181 | die "$0: $token->{type}: Unknown token type"; | die "$0: $token->{type}: Unknown token type"; |
| 1182 | } | } |
| 1183 | ||
| 1184 | my $root_element; !!!create-element ($root_element, 'html'); | my $root_element; |
| 1185 | !!!create-element ($root_element, $HTML_NS, 'html',, $token); | |
| 1186 | $self->{document}->append_child ($root_element); | $self->{document}->append_child ($root_element); |
| 1187 | push @{$self->{open_elements}}, [$root_element, 'html']; | push @{$self->{open_elements}}, [$root_element, $el_category->{html}]; |
| 1188 | ||
| 1189 | $self->{application_cache_selection}->(undef); | $self->{application_cache_selection}->(undef); |
| 1190 | ||
| 1191 | ## NOTE: Reprocess the token. | ## NOTE: Reprocess the token. |
| 1192 | !!!ack-later; | |
| 1193 | return; ## Go to the "before head" insertion mode. | return; ## Go to the "before head" insertion mode. |
| ## ISSUE: There is an issue in the spec | ||
| 1194 | } # B | } # B |
| 1195 | ||
| 1196 | die "$0: _tree_construction_root_element: This should never be reached"; | die "$0: _tree_construction_root_element: This should never be reached"; |
| # | Line 2798 sub _reset_insertion_mode ($) { | Line 1211 sub _reset_insertion_mode ($) { |
| 1211 | if ($self->{open_elements}->[0]->[0] eq $node->[0]) { | if ($self->{open_elements}->[0]->[0] eq $node->[0]) { |
| 1212 | $last = 1; | $last = 1; |
| 1213 | if (defined $self->{inner_html_node}) { | if (defined $self->{inner_html_node}) { |
| 1214 | if ($self->{inner_html_node}->[1] eq 'td' or | !!!cp ('t28'); |
| 1215 | $self->{inner_html_node}->[1] eq 'th') { | $node = $self->{inner_html_node}; |
| 1216 | !!!cp ('t27'); | } else { |
| 1217 | # | die "_reset_insertion_mode: t27"; |
| } else { | ||
| !!!cp ('t28'); | ||
| $node = $self->{inner_html_node}; | ||
| } | ||
| 1218 | } | } |
| 1219 | } | } |
| 1220 | ||
| 1221 | ## Step 4..13 | ## Step 4..14 |
| 1222 | my $new_mode = { | my $new_mode; |
| 1223 | if ($node->[1] & FOREIGN_EL) { | |
| 1224 | !!!cp ('t28.1'); | |
| 1225 | ## NOTE: Strictly spaking, the line below only applies to MathML and | |
| 1226 | ## SVG elements. Currently the HTML syntax supports only MathML and | |
| 1227 | ## SVG elements as foreigners. | |
| 1228 | $new_mode = IN_BODY_IM | IN_FOREIGN_CONTENT_IM; | |
| 1229 | } elsif ($node->[1] == TABLE_CELL_EL) { | |
| 1230 | if ($last) { | |
| 1231 | !!!cp ('t28.2'); | |
| 1232 | # | |
| 1233 | } else { | |
| 1234 | !!!cp ('t28.3'); | |
| 1235 | $new_mode = IN_CELL_IM; | |
| 1236 | } | |
| 1237 | } else { | |
| 1238 | !!!cp ('t28.4'); | |
| 1239 | $new_mode = { | |
| 1240 | select => IN_SELECT_IM, | select => IN_SELECT_IM, |
| 1241 | ## NOTE: |option| and |optgroup| do not set | ## NOTE: |option| and |optgroup| do not set |
| 1242 | ## insertion mode to "in select" by themselves. | ## insertion mode to "in select" by themselves. |
| td => IN_CELL_IM, | ||
| th => IN_CELL_IM, | ||
| 1243 | tr => IN_ROW_IM, | tr => IN_ROW_IM, |
| 1244 | tbody => IN_TABLE_BODY_IM, | tbody => IN_TABLE_BODY_IM, |
| 1245 | thead => IN_TABLE_BODY_IM, | thead => IN_TABLE_BODY_IM, |
| # | Line 2826 sub _reset_insertion_mode ($) { | Line 1250 sub _reset_insertion_mode ($) { |
| 1250 | head => IN_BODY_IM, # not in head! | head => IN_BODY_IM, # not in head! |
| 1251 | body => IN_BODY_IM, | body => IN_BODY_IM, |
| 1252 | frameset => IN_FRAMESET_IM, | frameset => IN_FRAMESET_IM, |
| 1253 | }->{$node->[1]}; | }->{$node->[0]->manakai_local_name}; |
| 1254 | } | |
| 1255 | $self->{insertion_mode} = $new_mode and return if defined $new_mode; | $self->{insertion_mode} = $new_mode and return if defined $new_mode; |
| 1256 | ||
| 1257 | ## Step 14 | ## Step 15 |
| 1258 | if ($node->[1] eq 'html') { | if ($node->[1] == HTML_EL) { |
| 1259 | unless (defined $self->{head_element}) { | unless (defined $self->{head_element}) { |
| 1260 | !!!cp ('t29'); | !!!cp ('t29'); |
| 1261 | $self->{insertion_mode} = BEFORE_HEAD_IM; | $self->{insertion_mode} = BEFORE_HEAD_IM; |
| # | Line 2844 sub _reset_insertion_mode ($) { | Line 1269 sub _reset_insertion_mode ($) { |
| 1269 | !!!cp ('t31'); | !!!cp ('t31'); |
| 1270 | } | } |
| 1271 | ||
| 1272 | ## Step 15 | ## Step 16 |
| 1273 | $self->{insertion_mode} = IN_BODY_IM and return if $last; | $self->{insertion_mode} = IN_BODY_IM and return if $last; |
| 1274 | ||
| 1275 | ## Step 16 | ## Step 17 |
| 1276 | $i--; | $i--; |
| 1277 | $node = $self->{open_elements}->[$i]; | $node = $self->{open_elements}->[$i]; |
| 1278 | ||
| 1279 | ## Step 17 | ## Step 18 |
| 1280 | redo S3; | redo S3; |
| 1281 | } # S3 | } # S3 |
| 1282 | ||
| # | Line 2962 sub _tree_construction_main ($) { | Line 1387 sub _tree_construction_main ($) { |
| 1387 | ||
| 1388 | ## Step 1 | ## Step 1 |
| 1389 | my $start_tag_name = $token->{tag_name}; | my $start_tag_name = $token->{tag_name}; |
| 1390 | my $el; | !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token); |
| !!!create-element ($el, $start_tag_name, $token->{attributes}); | ||
| 1391 | ||
| 1392 | ## Step 2 | ## Step 2 |
| $insert->($el); | ||
| ## Step 3 | ||
| 1393 | $self->{content_model} = $content_model_flag; # CDATA or RCDATA | $self->{content_model} = $content_model_flag; # CDATA or RCDATA |
| 1394 | delete $self->{escape}; # MUST | delete $self->{escape}; # MUST |
| 1395 | ||
| 1396 | ## Step 4 | ## Step 3, 4 |
| 1397 | 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; | ||
| } | ||
| 1398 | ||
| 1399 | ## 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}); | ||
| } elsif ($content_model_flag == RCDATA_CONTENT_MODEL) { | ||
| !!!cp ('t44'); | ||
| !!!parse-error (type => 'in RCDATA:#'.$token->{type}); | ||
| } else { | ||
| die "$0: $content_model_flag in parse_rcdata"; | ||
| } | ||
| } | ||
| 1400 | !!!next-token; | !!!next-token; |
| 1401 | }; # $parse_rcdata | }; # $parse_rcdata |
| 1402 | ||
| 1403 | my $script_start_tag = sub () { | my $script_start_tag = sub () { |
| 1404 | ## Step 1 | |
| 1405 | my $script_el; | my $script_el; |
| 1406 | !!!create-element ($script_el, 'script', $token->{attributes}); | !!!create-element ($script_el, $HTML_NS, 'script', $token->{attributes}, $token); |
| 1407 | ||
| 1408 | ## Step 2 | |
| 1409 | ## TODO: mark as "parser-inserted" | ## TODO: mark as "parser-inserted" |
| 1410 | ||
| 1411 | ## Step 3 | |
| 1412 | ## TODO: Mark as "already executed", if ... | |
| 1413 | ||
| 1414 | ## Step 4 | |
| 1415 | $insert->($script_el); | |
| 1416 | ||
| 1417 | ## ISSUE: $script_el is not put into the stack | |
| 1418 | push @{$self->{open_elements}}, [$script_el, $el_category->{script}]; | |
| 1419 | ||
| 1420 | ## Step 5 | |
| 1421 | $self->{content_model} = CDATA_CONTENT_MODEL; | $self->{content_model} = CDATA_CONTENT_MODEL; |
| 1422 | 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; | ||
| 1423 | ||
| 1424 | if ($token->{type} == END_TAG_TOKEN and | ## Step 6-7 |
| 1425 | $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}); | ||
| ## 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 | ||
| 1426 | ||
| 1427 | $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... | ||
| } | ||
| 1428 | !!!next-token; | !!!next-token; |
| 1429 | }; # $script_start_tag | }; # $script_start_tag |
| 1430 | ||
| 1431 | ## NOTE: $open_tables->[-1]->[0] is the "current table" element node. | ## NOTE: $open_tables->[-1]->[0] is the "current table" element node. |
| 1432 | ## NOTE: $open_tables->[-1]->[1] is the "tainted" flag. | ## NOTE: $open_tables->[-1]->[1] is the "tainted" flag. |
| 1433 | ## NOTE: $open_tables->[-1]->[2] is set false when non-Text node inserted. | |
| 1434 | my $open_tables = [[$self->{open_elements}->[0]->[0]]]; | my $open_tables = [[$self->{open_elements}->[0]->[0]]]; |
| 1435 | ||
| 1436 | my $formatting_end_tag = sub { | my $formatting_end_tag = sub { |
| 1437 | my $tag_name = shift; | my $end_tag_token = shift; |
| 1438 | my $tag_name = $end_tag_token->{tag_name}; | |
| 1439 | ||
| 1440 | ## NOTE: The adoption agency algorithm (AAA). | ## NOTE: The adoption agency algorithm (AAA). |
| 1441 | ||
| # | Line 3076 sub _tree_construction_main ($) { | Line 1444 sub _tree_construction_main ($) { |
| 1444 | my $formatting_element; | my $formatting_element; |
| 1445 | my $formatting_element_i_in_active; | my $formatting_element_i_in_active; |
| 1446 | AFE: for (reverse 0..$#$active_formatting_elements) { | AFE: for (reverse 0..$#$active_formatting_elements) { |
| 1447 | if ($active_formatting_elements->[$_]->[1] eq $tag_name) { | if ($active_formatting_elements->[$_]->[0] eq '#marker') { |
| 1448 | !!!cp ('t52'); | |
| 1449 | last AFE; | |
| 1450 | } elsif ($active_formatting_elements->[$_]->[0]->manakai_local_name | |
| 1451 | eq $tag_name) { | |
| 1452 | !!!cp ('t51'); | !!!cp ('t51'); |
| 1453 | $formatting_element = $active_formatting_elements->[$_]; | $formatting_element = $active_formatting_elements->[$_]; |
| 1454 | $formatting_element_i_in_active = $_; | $formatting_element_i_in_active = $_; |
| 1455 | last AFE; | last AFE; |
| } elsif ($active_formatting_elements->[$_]->[0] eq '#marker') { | ||
| !!!cp ('t52'); | ||
| last AFE; | ||
| 1456 | } | } |
| 1457 | } # AFE | } # AFE |
| 1458 | unless (defined $formatting_element) { | unless (defined $formatting_element) { |
| 1459 | !!!cp ('t53'); | !!!cp ('t53'); |
| 1460 | !!!parse-error (type => 'unmatched end tag:'.$tag_name); | !!!parse-error (type => 'unmatched end tag', text => $tag_name, token => $end_tag_token); |
| 1461 | ## Ignore the token | ## Ignore the token |
| 1462 | !!!next-token; | !!!next-token; |
| 1463 | return; | return; |
| # | Line 3105 sub _tree_construction_main ($) { | Line 1474 sub _tree_construction_main ($) { |
| 1474 | last INSCOPE; | last INSCOPE; |
| 1475 | } else { # in open elements but not in scope | } else { # in open elements but not in scope |
| 1476 | !!!cp ('t55'); | !!!cp ('t55'); |
| 1477 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 1478 | text => $token->{tag_name}, | |
| 1479 | token => $end_tag_token); | |
| 1480 | ## Ignore the token | ## Ignore the token |
| 1481 | !!!next-token; | !!!next-token; |
| 1482 | return; | return; |
| 1483 | } | } |
| 1484 | } 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]}) { | ||
| 1485 | !!!cp ('t56'); | !!!cp ('t56'); |
| 1486 | $in_scope = 0; | $in_scope = 0; |
| 1487 | } | } |
| 1488 | } # INSCOPE | } # INSCOPE |
| 1489 | unless (defined $formatting_element_i_in_open) { | unless (defined $formatting_element_i_in_open) { |
| 1490 | !!!cp ('t57'); | !!!cp ('t57'); |
| 1491 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 1492 | text => $token->{tag_name}, | |
| 1493 | token => $end_tag_token); | |
| 1494 | pop @$active_formatting_elements; # $formatting_element | pop @$active_formatting_elements; # $formatting_element |
| 1495 | !!!next-token; ## TODO: ok? | !!!next-token; ## TODO: ok? |
| 1496 | return; | return; |
| 1497 | } | } |
| 1498 | if (not $self->{open_elements}->[-1]->[0] eq $formatting_element->[0]) { | if (not $self->{open_elements}->[-1]->[0] eq $formatting_element->[0]) { |
| 1499 | !!!cp ('t58'); | !!!cp ('t58'); |
| 1500 | !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]); | !!!parse-error (type => 'not closed', |
| 1501 | text => $self->{open_elements}->[-1]->[0] | |
| 1502 | ->manakai_local_name, | |
| 1503 | token => $end_tag_token); | |
| 1504 | } | } |
| 1505 | ||
| 1506 | ## Step 2 | ## Step 2 |
| # | Line 3135 sub _tree_construction_main ($) { | Line 1508 sub _tree_construction_main ($) { |
| 1508 | my $furthest_block_i_in_open; | my $furthest_block_i_in_open; |
| 1509 | OE: for (reverse 0..$#{$self->{open_elements}}) { | OE: for (reverse 0..$#{$self->{open_elements}}) { |
| 1510 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 1511 | if (not $formatting_category->{$node->[1]} and | if (not ($node->[1] & FORMATTING_EL) and |
| 1512 | #not $phrasing_category->{$node->[1]} and | #not $phrasing_category->{$node->[1]} and |
| 1513 | ($special_category->{$node->[1]} or | ($node->[1] & SPECIAL_EL or |
| 1514 | $scoping_category->{$node->[1]})) { ## Scoping is redundant, maybe | $node->[1] & SCOPING_EL)) { ## Scoping is redundant, maybe |
| 1515 | !!!cp ('t59'); | !!!cp ('t59'); |
| 1516 | $furthest_block = $node; | $furthest_block = $node; |
| 1517 | $furthest_block_i_in_open = $_; | $furthest_block_i_in_open = $_; |
| 1518 | ## NOTE: The topmost (eldest) node. | |
| 1519 | } elsif ($node->[0] eq $formatting_element->[0]) { | } elsif ($node->[0] eq $formatting_element->[0]) { |
| 1520 | !!!cp ('t60'); | !!!cp ('t60'); |
| 1521 | last OE; | last OE; |
| # | Line 3224 sub _tree_construction_main ($) { | Line 1598 sub _tree_construction_main ($) { |
| 1598 | } # S7 | } # S7 |
| 1599 | ||
| 1600 | ## Step 8 | ## Step 8 |
| 1601 | if ({ | if ($common_ancestor_node->[1] & TABLE_ROWS_EL) { |
| table => 1, tbody => 1, tfoot => 1, thead => 1, tr => 1, | ||
| }->{$common_ancestor_node->[1]}) { | ||
| 1602 | my $foster_parent_element; | my $foster_parent_element; |
| 1603 | my $next_sibling; | my $next_sibling; |
| 1604 | OE: for (reverse 0..$#{$self->{open_elements}}) { | OE: for (reverse 0..$#{$self->{open_elements}}) { |
| 1605 | if ($self->{open_elements}->[$_]->[1] eq 'table') { | if ($self->{open_elements}->[$_]->[1] == TABLE_EL) { |
| 1606 | my $parent = $self->{open_elements}->[$_]->[0]->parent_node; | my $parent = $self->{open_elements}->[$_]->[0]->parent_node; |
| 1607 | if (defined $parent and $parent->node_type == 1) { | if (defined $parent and $parent->node_type == 1) { |
| 1608 | !!!cp ('t65.1'); | !!!cp ('t65.1'); |
| # | Line 3290 sub _tree_construction_main ($) { | Line 1662 sub _tree_construction_main ($) { |
| 1662 | $i = $_; | $i = $_; |
| 1663 | } | } |
| 1664 | } # OE | } # OE |
| 1665 | splice @{$self->{open_elements}}, $i + 1, 1, $clone; | splice @{$self->{open_elements}}, $i + 1, 0, $clone; |
| 1666 | ||
| 1667 | ## Step 14 | ## Step 14 |
| 1668 | redo FET; | redo FET; |
| # | Line 3303 sub _tree_construction_main ($) { | Line 1675 sub _tree_construction_main ($) { |
| 1675 | ||
| 1676 | my $insert_to_foster = sub { | my $insert_to_foster = sub { |
| 1677 | my $child = shift; | my $child = shift; |
| 1678 | 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]}) { | ||
| 1679 | # MUST | # MUST |
| 1680 | my $foster_parent_element; | my $foster_parent_element; |
| 1681 | my $next_sibling; | my $next_sibling; |
| 1682 | OE: for (reverse 0..$#{$self->{open_elements}}) { | OE: for (reverse 0..$#{$self->{open_elements}}) { |
| 1683 | if ($self->{open_elements}->[$_]->[1] eq 'table') { | if ($self->{open_elements}->[$_]->[1] == TABLE_EL) { |
| 1684 | my $parent = $self->{open_elements}->[$_]->[0]->parent_node; | my $parent = $self->{open_elements}->[$_]->[0]->parent_node; |
| 1685 | if (defined $parent and $parent->node_type == 1) { | if (defined $parent and $parent->node_type == 1) { |
| 1686 | !!!cp ('t70'); | !!!cp ('t70'); |
| # | Line 3335 sub _tree_construction_main ($) { | Line 1705 sub _tree_construction_main ($) { |
| 1705 | } | } |
| 1706 | }; # $insert_to_foster | }; # $insert_to_foster |
| 1707 | ||
| 1708 | B: { | ## NOTE: Insert a character (MUST): When a character is inserted, if |
| 1709 | ## the last node that was inserted by the parser is a Text node and | |
| 1710 | ## the character has to be inserted after that node, then the | |
| 1711 | ## character is appended to the Text node. However, if any other | |
| 1712 | ## node is inserted by the parser, then a new Text node is created | |
| 1713 | ## and the character is appended as that Text node. If I'm not | |
| 1714 | ## wrong, for a parser with scripting disabled, there are only two | |
| 1715 | ## cases where this occurs. One is the case where an element node | |
| 1716 | ## is inserted to the |head| element. This is covered by using the | |
| 1717 | ## |$self->{head_element_inserted}| flag. Another is the case where | |
| 1718 | ## an element or comment is inserted into the |table| subtree while | |
| 1719 | ## foster parenting happens. This is covered by using the [2] flag | |
| 1720 | ## of the |$open_tables| structure. All other cases are handled | |
| 1721 | ## simply by calling |manakai_append_text| method. | |
| 1722 | ||
| 1723 | ## TODO: |<body><script>document.write("a<br>"); | |
| 1724 | ## document.body.removeChild (document.body.lastChild); | |
| 1725 | ## document.write ("b")</script>| | |
| 1726 | ||
| 1727 | B: while (1) { | |
| 1728 | if ($token->{type} == DOCTYPE_TOKEN) { | if ($token->{type} == DOCTYPE_TOKEN) { |
| 1729 | !!!cp ('t73'); | !!!cp ('t73'); |
| 1730 | !!!parse-error (type => 'DOCTYPE in the middle'); | !!!parse-error (type => 'in html:#DOCTYPE', token => $token); |
| 1731 | ## Ignore the token | ## Ignore the token |
| 1732 | ## Stay in the phase | ## Stay in the phase |
| 1733 | !!!next-token; | !!!next-token; |
| 1734 | redo B; | next B; |
| 1735 | } elsif ($token->{type} == START_TAG_TOKEN and | } elsif ($token->{type} == START_TAG_TOKEN and |
| 1736 | $token->{tag_name} eq 'html') { | $token->{tag_name} eq 'html') { |
| 1737 | if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) { | if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) { |
| 1738 | !!!cp ('t79'); | !!!cp ('t79'); |
| 1739 | !!!parse-error (type => 'after html:html'); | !!!parse-error (type => 'after html', text => 'html', token => $token); |
| 1740 | $self->{insertion_mode} = AFTER_BODY_IM; | $self->{insertion_mode} = AFTER_BODY_IM; |
| 1741 | } elsif ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) { | } elsif ($self->{insertion_mode} == AFTER_HTML_FRAMESET_IM) { |
| 1742 | !!!cp ('t80'); | !!!cp ('t80'); |
| 1743 | !!!parse-error (type => 'after html:html'); | !!!parse-error (type => 'after html', text => 'html', token => $token); |
| 1744 | $self->{insertion_mode} = AFTER_FRAMESET_IM; | $self->{insertion_mode} = AFTER_FRAMESET_IM; |
| 1745 | } else { | } else { |
| 1746 | !!!cp ('t81'); | !!!cp ('t81'); |
| 1747 | } | } |
| 1748 | ||
| 1749 | !!!cp ('t82'); | !!!cp ('t82'); |
| 1750 | !!!parse-error (type => 'not first start tag'); | !!!parse-error (type => 'not first start tag', token => $token); |
| 1751 | my $top_el = $self->{open_elements}->[0]->[0]; | my $top_el = $self->{open_elements}->[0]->[0]; |
| 1752 | for my $attr_name (keys %{$token->{attributes}}) { | for my $attr_name (keys %{$token->{attributes}}) { |
| 1753 | unless ($top_el->has_attribute_ns (undef, $attr_name)) { | unless ($top_el->has_attribute_ns (undef, $attr_name)) { |
| # | Line 3368 sub _tree_construction_main ($) { | Line 1757 sub _tree_construction_main ($) { |
| 1757 | $token->{attributes}->{$attr_name}->{value}); | $token->{attributes}->{$attr_name}->{value}); |
| 1758 | } | } |
| 1759 | } | } |
| 1760 | !!!nack ('t84.1'); | |
| 1761 | !!!next-token; | !!!next-token; |
| 1762 | redo B; | next B; |
| 1763 | } elsif ($token->{type} == COMMENT_TOKEN) { | } elsif ($token->{type} == COMMENT_TOKEN) { |
| 1764 | my $comment = $self->{document}->create_comment ($token->{data}); | my $comment = $self->{document}->create_comment ($token->{data}); |
| 1765 | if ($self->{insertion_mode} & AFTER_HTML_IMS) { | if ($self->{insertion_mode} & AFTER_HTML_IMS) { |
| # | Line 3381 sub _tree_construction_main ($) { | Line 1771 sub _tree_construction_main ($) { |
| 1771 | } else { | } else { |
| 1772 | !!!cp ('t87'); | !!!cp ('t87'); |
| 1773 | $self->{open_elements}->[-1]->[0]->append_child ($comment); | $self->{open_elements}->[-1]->[0]->append_child ($comment); |
| 1774 | $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted | |
| 1775 | } | } |
| 1776 | !!!next-token; | !!!next-token; |
| 1777 | redo B; | next B; |
| 1778 | } elsif ($self->{insertion_mode} & HEAD_IMS) { | } elsif ($self->{insertion_mode} & IN_CDATA_RCDATA_IM) { |
| 1779 | if ($token->{type} == CHARACTER_TOKEN) { | |
| 1780 | $token->{data} =~ s/^\x0A// if $self->{ignore_newline}; | |
| 1781 | delete $self->{ignore_newline}; | |
| 1782 | ||
| 1783 | if (length $token->{data}) { | |
| 1784 | !!!cp ('t43'); | |
| 1785 | $self->{open_elements}->[-1]->[0]->manakai_append_text | |
| 1786 | ($token->{data}); | |
| 1787 | } else { | |
| 1788 | !!!cp ('t43.1'); | |
| 1789 | } | |
| 1790 | !!!next-token; | |
| 1791 | next B; | |
| 1792 | } elsif ($token->{type} == END_TAG_TOKEN) { | |
| 1793 | delete $self->{ignore_newline}; | |
| 1794 | ||
| 1795 | if ($token->{tag_name} eq 'script') { | |
| 1796 | !!!cp ('t50'); | |
| 1797 | ||
| 1798 | ## Para 1-2 | |
| 1799 | my $script = pop @{$self->{open_elements}}; | |
| 1800 | ||
| 1801 | ## Para 3 | |
| 1802 | $self->{insertion_mode} &= ~ IN_CDATA_RCDATA_IM; | |
| 1803 | ||
| 1804 | ## Para 4 | |
| 1805 | ## TODO: $old_insertion_point = $current_insertion_point; | |
| 1806 | ## TODO: $current_insertion_point = just before $self->{nc}; | |
| 1807 | ||
| 1808 | ## Para 5 | |
| 1809 | ## TODO: Run the $script->[0]. | |
| 1810 | ||
| 1811 | ## Para 6 | |
| 1812 | ## TODO: $current_insertion_point = $old_insertion_point; | |
| 1813 | ||
| 1814 | ## Para 7 | |
| 1815 | ## TODO: if ($pending_external_script) { | |
| 1816 | ## TODO: ... | |
| 1817 | ## TODO: } | |
| 1818 | ||
| 1819 | !!!next-token; | |
| 1820 | next B; | |
| 1821 | } else { | |
| 1822 | !!!cp ('t42'); | |
| 1823 | ||
| 1824 | pop @{$self->{open_elements}}; | |
| 1825 | ||
| 1826 | $self->{insertion_mode} &= ~ IN_CDATA_RCDATA_IM; | |
| 1827 | !!!next-token; | |
| 1828 | next B; | |
| 1829 | } | |
| 1830 | } elsif ($token->{type} == END_OF_FILE_TOKEN) { | |
| 1831 | delete $self->{ignore_newline}; | |
| 1832 | ||
| 1833 | !!!cp ('t44'); | |
| 1834 | !!!parse-error (type => 'not closed', | |
| 1835 | text => $self->{open_elements}->[-1]->[0] | |
| 1836 | ->manakai_local_name, | |
| 1837 | token => $token); | |
| 1838 | ||
| 1839 | #if ($self->{open_elements}->[-1]->[1] == SCRIPT_EL) { | |
| 1840 | # ## TODO: Mark as "already executed" | |
| 1841 | #} | |
| 1842 | ||
| 1843 | pop @{$self->{open_elements}}; | |
| 1844 | ||
| 1845 | $self->{insertion_mode} &= ~ IN_CDATA_RCDATA_IM; | |
| 1846 | ## Reprocess. | |
| 1847 | next B; | |
| 1848 | } else { | |
| 1849 | die "$0: $token->{type}: In CDATA/RCDATA: Unknown token type"; | |
| 1850 | } | |
| 1851 | } elsif ($self->{insertion_mode} & IN_FOREIGN_CONTENT_IM) { | |
| 1852 | if ($token->{type} == CHARACTER_TOKEN) { | |
| 1853 | !!!cp ('t87.1'); | |
| 1854 | $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data}); | |
| 1855 | !!!next-token; | |
| 1856 | next B; | |
| 1857 | } elsif ($token->{type} == START_TAG_TOKEN) { | |
| 1858 | if ((not {mglyph => 1, malignmark => 1}->{$token->{tag_name}} and | |
| 1859 | $self->{open_elements}->[-1]->[1] & FOREIGN_FLOW_CONTENT_EL) or | |
| 1860 | not ($self->{open_elements}->[-1]->[1] & FOREIGN_EL) or | |
| 1861 | ($token->{tag_name} eq 'svg' and | |
| 1862 | $self->{open_elements}->[-1]->[1] == MML_AXML_EL)) { | |
| 1863 | ## NOTE: "using the rules for secondary insertion mode"then"continue" | |
| 1864 | !!!cp ('t87.2'); | |
| 1865 | # | |
| 1866 | } elsif ({ | |
| 1867 | b => 1, big => 1, blockquote => 1, body => 1, br => 1, | |
| 1868 | center => 1, code => 1, dd => 1, div => 1, dl => 1, dt => 1, | |
| 1869 | em => 1, embed => 1, font => 1, h1 => 1, h2 => 1, h3 => 1, | |
| 1870 | h4 => 1, h5 => 1, h6 => 1, head => 1, hr => 1, i => 1, | |
| 1871 | img => 1, li => 1, listing => 1, menu => 1, meta => 1, | |
| 1872 | nobr => 1, ol => 1, p => 1, pre => 1, ruby => 1, s => 1, | |
| 1873 | small => 1, span => 1, strong => 1, strike => 1, sub => 1, | |
| 1874 | sup => 1, table => 1, tt => 1, u => 1, ul => 1, var => 1, | |
| 1875 | }->{$token->{tag_name}}) { | |
| 1876 | !!!cp ('t87.2'); | |
| 1877 | !!!parse-error (type => 'not closed', | |
| 1878 | text => $self->{open_elements}->[-1]->[0] | |
| 1879 | ->manakai_local_name, | |
| 1880 | token => $token); | |
| 1881 | ||
| 1882 | pop @{$self->{open_elements}} | |
| 1883 | while $self->{open_elements}->[-1]->[1] & FOREIGN_EL; | |
| 1884 | ||
| 1885 | $self->{insertion_mode} &= ~ IN_FOREIGN_CONTENT_IM; | |
| 1886 | ## Reprocess. | |
| 1887 | next B; | |
| 1888 | } else { | |
| 1889 | my $nsuri = $self->{open_elements}->[-1]->[0]->namespace_uri; | |
| 1890 | my $tag_name = $token->{tag_name}; | |
| 1891 | if ($nsuri eq $SVG_NS) { | |
| 1892 | $tag_name = { | |
| 1893 | altglyph => 'altGlyph', | |
| 1894 | altglyphdef => 'altGlyphDef', | |
| 1895 | altglyphitem => 'altGlyphItem', | |
| 1896 | animatecolor => 'animateColor', | |
| 1897 | animatemotion => 'animateMotion', | |
| 1898 | animatetransform => 'animateTransform', | |
| 1899 | clippath => 'clipPath', | |
| 1900 | feblend => 'feBlend', | |
| 1901 | fecolormatrix => 'feColorMatrix', | |
| 1902 | fecomponenttransfer => 'feComponentTransfer', | |
| 1903 | fecomposite => 'feComposite', | |
| 1904 | feconvolvematrix => 'feConvolveMatrix', | |
| 1905 | fediffuselighting => 'feDiffuseLighting', | |
| 1906 | fedisplacementmap => 'feDisplacementMap', | |
| 1907 | fedistantlight => 'feDistantLight', | |
| 1908 | feflood => 'feFlood', | |
| 1909 | fefunca => 'feFuncA', | |
| 1910 | fefuncb => 'feFuncB', | |
| 1911 | fefuncg => 'feFuncG', | |
| 1912 | fefuncr => 'feFuncR', | |
| 1913 | fegaussianblur => 'feGaussianBlur', | |
| 1914 | feimage => 'feImage', | |
| 1915 | femerge => 'feMerge', | |
| 1916 | femergenode => 'feMergeNode', | |
| 1917 | femorphology => 'feMorphology', | |
| 1918 | feoffset => 'feOffset', | |
| 1919 | fepointlight => 'fePointLight', | |
| 1920 | fespecularlighting => 'feSpecularLighting', | |
| 1921 | fespotlight => 'feSpotLight', | |
| 1922 | fetile => 'feTile', | |
| 1923 | feturbulence => 'feTurbulence', | |
| 1924 | foreignobject => 'foreignObject', | |
| 1925 | glyphref => 'glyphRef', | |
| 1926 | lineargradient => 'linearGradient', | |
| 1927 | radialgradient => 'radialGradient', | |
| 1928 | #solidcolor => 'solidColor', ## NOTE: Commented in spec (SVG1.2) | |
| 1929 | textpath => 'textPath', | |
| 1930 | }->{$tag_name} || $tag_name; | |
| 1931 | } | |
| 1932 | ||
| 1933 | ## "adjust SVG attributes" (SVG only) - done in insert-element-f | |
| 1934 | ||
| 1935 | ## "adjust foreign attributes" - done in insert-element-f | |
| 1936 | ||
| 1937 | !!!insert-element-f ($nsuri, $tag_name, $token->{attributes}, $token); | |
| 1938 | ||
| 1939 | if ($self->{self_closing}) { | |
| 1940 | pop @{$self->{open_elements}}; | |
| 1941 | !!!ack ('t87.3'); | |
| 1942 | } else { | |
| 1943 | !!!cp ('t87.4'); | |
| 1944 | } | |
| 1945 | ||
| 1946 | !!!next-token; | |
| 1947 | next B; | |
| 1948 | } | |
| 1949 | } elsif ($token->{type} == END_TAG_TOKEN) { | |
| 1950 | ## NOTE: "using the rules for secondary insertion mode" then "continue" | |
| 1951 | !!!cp ('t87.5'); | |
| 1952 | # | |
| 1953 | } elsif ($token->{type} == END_OF_FILE_TOKEN) { | |
| 1954 | !!!cp ('t87.6'); | |
| 1955 | !!!parse-error (type => 'not closed', | |
| 1956 | text => $self->{open_elements}->[-1]->[0] | |
| 1957 | ->manakai_local_name, | |
| 1958 | token => $token); | |
| 1959 | ||
| 1960 | pop @{$self->{open_elements}} | |
| 1961 | while $self->{open_elements}->[-1]->[1] & FOREIGN_EL; | |
| 1962 | ||
| 1963 | ## NOTE: |<span><svg>| ... two parse errors, |<svg>| ... a parse error. | |
| 1964 | ||
| 1965 | $self->{insertion_mode} &= ~ IN_FOREIGN_CONTENT_IM; | |
| 1966 | ## Reprocess. | |
| 1967 | next B; | |
| 1968 | } else { | |
| 1969 | die "$0: $token->{type}: Unknown token type"; | |
| 1970 | } | |
| 1971 | } | |
| 1972 | ||
| 1973 | if ($self->{insertion_mode} & HEAD_IMS) { | |
| 1974 | if ($token->{type} == CHARACTER_TOKEN) { | if ($token->{type} == CHARACTER_TOKEN) { |
| 1975 | if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { | if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) { |
| 1976 | unless ($self->{insertion_mode} == BEFORE_HEAD_IM) { | unless ($self->{insertion_mode} == BEFORE_HEAD_IM) { |
| 1977 | !!!cp ('t88.2'); | if ($self->{head_element_inserted}) { |
| 1978 | $self->{open_elements}->[-1]->[0]->manakai_append_text ($1); | !!!cp ('t88.3'); |
| 1979 | $self->{open_elements}->[-1]->[0]->append_child | |
| 1980 | ($self->{document}->create_text_node ($1)); | |
| 1981 | delete $self->{head_element_inserted}; | |
| 1982 | ## NOTE: |</head> <link> | | |
| 1983 | # | |
| 1984 | } else { | |
| 1985 | !!!cp ('t88.2'); | |
| 1986 | $self->{open_elements}->[-1]->[0]->manakai_append_text ($1); | |
| 1987 | ## NOTE: |</head>  | | |
| 1988 | # | |
| 1989 | } | |
| 1990 | } else { | } else { |
| 1991 | !!!cp ('t88.1'); | !!!cp ('t88.1'); |
| 1992 | ## Ignore the token. | ## Ignore the token. |
| 1993 | !!!next-token; | # |
| redo B; | ||
| 1994 | } | } |
| 1995 | unless (length $token->{data}) { | unless (length $token->{data}) { |
| 1996 | !!!cp ('t88'); | !!!cp ('t88'); |
| 1997 | !!!next-token; | !!!next-token; |
| 1998 | redo B; | next B; |
| 1999 | } | } |
| 2000 | ## TODO: set $token->{column} appropriately | |
| 2001 | } | } |
| 2002 | ||
| 2003 | if ($self->{insertion_mode} == BEFORE_HEAD_IM) { | if ($self->{insertion_mode} == BEFORE_HEAD_IM) { |
| 2004 | !!!cp ('t89'); | !!!cp ('t89'); |
| 2005 | ## As if <head> | ## As if <head> |
| 2006 | !!!create-element ($self->{head_element}, 'head'); | !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token); |
| 2007 | $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element}); | $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element}); |
| 2008 | push @{$self->{open_elements}}, [$self->{head_element}, 'head']; | push @{$self->{open_elements}}, |
| 2009 | [$self->{head_element}, $el_category->{head}]; | |
| 2010 | ||
| 2011 | ## Reprocess in the "in head" insertion mode... | ## Reprocess in the "in head" insertion mode... |
| 2012 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| # | Line 3418 sub _tree_construction_main ($) { | Line 2016 sub _tree_construction_main ($) { |
| 2016 | !!!cp ('t90'); | !!!cp ('t90'); |
| 2017 | ## As if </noscript> | ## As if </noscript> |
| 2018 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2019 | !!!parse-error (type => 'in noscript:#character'); | !!!parse-error (type => 'in noscript:#text', token => $token); |
| 2020 | ||
| 2021 | ## Reprocess in the "in head" insertion mode... | ## Reprocess in the "in head" insertion mode... |
| 2022 | ## As if </head> | ## As if </head> |
| # | Line 3434 sub _tree_construction_main ($) { | Line 2032 sub _tree_construction_main ($) { |
| 2032 | !!!cp ('t92'); | !!!cp ('t92'); |
| 2033 | } | } |
| 2034 | ||
| 2035 | ## "after head" insertion mode | ## "after head" insertion mode |
| 2036 | ## As if <body> | ## As if <body> |
| 2037 | !!!insert-element ('body'); | !!!insert-element ('body',, $token); |
| 2038 | $self->{insertion_mode} = IN_BODY_IM; | $self->{insertion_mode} = IN_BODY_IM; |
| 2039 | ## reprocess | ## reprocess |
| 2040 | redo B; | next B; |
| 2041 | } elsif ($token->{type} == START_TAG_TOKEN) { | } elsif ($token->{type} == START_TAG_TOKEN) { |
| 2042 | if ($token->{tag_name} eq 'head') { | if ($token->{tag_name} eq 'head') { |
| 2043 | if ($self->{insertion_mode} == BEFORE_HEAD_IM) { | if ($self->{insertion_mode} == BEFORE_HEAD_IM) { |
| 2044 | !!!cp ('t93'); | !!!cp ('t93'); |
| 2045 | !!!create-element ($self->{head_element}, $token->{tag_name}, $token->{attributes}); | !!!create-element ($self->{head_element}, $HTML_NS, $token->{tag_name}, $token->{attributes}, $token); |
| 2046 | $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element}); | $self->{open_elements}->[-1]->[0]->append_child |
| 2047 | push @{$self->{open_elements}}, [$self->{head_element}, $token->{tag_name}]; | ($self->{head_element}); |
| 2048 | $self->{insertion_mode} = IN_HEAD_IM; | push @{$self->{open_elements}}, |
| 2049 | !!!next-token; | [$self->{head_element}, $el_category->{head}]; |
| 2050 | redo B; | $self->{insertion_mode} = IN_HEAD_IM; |
| 2051 | } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) { | !!!nack ('t93.1'); |
| 2052 | !!!cp ('t94'); | !!!next-token; |
| 2053 | # | next B; |
| 2054 | } else { | } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) { |
| 2055 | !!!cp ('t95'); | !!!cp ('t93.2'); |
| 2056 | !!!parse-error (type => 'in head:head'); # or in head noscript | !!!parse-error (type => 'after head', text => 'head', |
| 2057 | ## Ignore the token | token => $token); |
| 2058 | !!!next-token; | ## Ignore the token |
| 2059 | redo B; | !!!nack ('t93.3'); |
| 2060 | } | !!!next-token; |
| 2061 | } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) { | next B; |
| 2062 | !!!cp ('t96'); | } else { |
| 2063 | ## As if <head> | !!!cp ('t95'); |
| 2064 | !!!create-element ($self->{head_element}, 'head'); | !!!parse-error (type => 'in head:head', |
| 2065 | $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element}); | token => $token); # or in head noscript |
| 2066 | push @{$self->{open_elements}}, [$self->{head_element}, 'head']; | ## Ignore the token |
| 2067 | !!!nack ('t95.1'); | |
| 2068 | !!!next-token; | |
| 2069 | next B; | |
| 2070 | } | |
| 2071 | } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) { | |
| 2072 | !!!cp ('t96'); | |
| 2073 | ## As if <head> | |
| 2074 | !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token); | |
| 2075 | $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element}); | |
| 2076 | push @{$self->{open_elements}}, | |
| 2077 | [$self->{head_element}, $el_category->{head}]; | |
| 2078 | ||
| 2079 | $self->{insertion_mode} = IN_HEAD_IM; | $self->{insertion_mode} = IN_HEAD_IM; |
| 2080 | ## Reprocess in the "in head" insertion mode... | ## Reprocess in the "in head" insertion mode... |
| 2081 | } else { | } else { |
| 2082 | !!!cp ('t97'); | !!!cp ('t97'); |
| 2083 | } | } |
| 2084 | ||
| 2085 | if ($token->{tag_name} eq 'base') { | if ($token->{tag_name} eq 'base') { |
| 2086 | if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { | if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { |
| 2087 | !!!cp ('t98'); | !!!cp ('t98'); |
| 2088 | ## As if </noscript> | ## As if </noscript> |
| 2089 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2090 | !!!parse-error (type => 'in noscript:base'); | !!!parse-error (type => 'in noscript', text => 'base', |
| 2091 | token => $token); | |
| 2092 | $self->{insertion_mode} = IN_HEAD_IM; | |
| 2093 | ## Reprocess in the "in head" insertion mode... | $self->{insertion_mode} = IN_HEAD_IM; |
| 2094 | } else { | ## Reprocess in the "in head" insertion mode... |
| 2095 | !!!cp ('t99'); | } else { |
| 2096 | } | !!!cp ('t99'); |
| 2097 | } | |
| 2098 | ||
| 2099 | ## NOTE: There is a "as if in head" code clone. | ## NOTE: There is a "as if in head" code clone. |
| 2100 | if ($self->{insertion_mode} == AFTER_HEAD_IM) { | if ($self->{insertion_mode} == AFTER_HEAD_IM) { |
| 2101 | !!!cp ('t100'); | !!!cp ('t100'); |
| 2102 | !!!parse-error (type => 'after head:'.$token->{tag_name}); | !!!parse-error (type => 'after head', |
| 2103 | push @{$self->{open_elements}}, [$self->{head_element}, 'head']; | text => $token->{tag_name}, token => $token); |
| 2104 | } else { | push @{$self->{open_elements}}, |
| 2105 | !!!cp ('t101'); | [$self->{head_element}, $el_category->{head}]; |
| 2106 | } | $self->{head_element_inserted} = 1; |
| 2107 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | } else { |
| 2108 | pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec. | !!!cp ('t101'); |
| 2109 | pop @{$self->{open_elements}} # <head> | } |
| 2110 | if $self->{insertion_mode} == AFTER_HEAD_IM; | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); |
| 2111 | !!!next-token; | pop @{$self->{open_elements}}; |
| 2112 | redo B; | pop @{$self->{open_elements}} # <head> |
| 2113 | } elsif ($token->{tag_name} eq 'link') { | if $self->{insertion_mode} == AFTER_HEAD_IM; |
| 2114 | ## NOTE: There is a "as if in head" code clone. | !!!nack ('t101.1'); |
| 2115 | if ($self->{insertion_mode} == AFTER_HEAD_IM) { | !!!next-token; |
| 2116 | !!!cp ('t102'); | next B; |
| 2117 | !!!parse-error (type => 'after head:'.$token->{tag_name}); | } elsif ($token->{tag_name} eq 'link') { |
| 2118 | push @{$self->{open_elements}}, [$self->{head_element}, 'head']; | ## NOTE: There is a "as if in head" code clone. |
| 2119 | } else { | if ($self->{insertion_mode} == AFTER_HEAD_IM) { |
| 2120 | !!!cp ('t103'); | !!!cp ('t102'); |
| 2121 | } | !!!parse-error (type => 'after head', |
| 2122 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | text => $token->{tag_name}, token => $token); |
| 2123 | pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec. | push @{$self->{open_elements}}, |
| 2124 | pop @{$self->{open_elements}} # <head> | [$self->{head_element}, $el_category->{head}]; |
| 2125 | if $self->{insertion_mode} == AFTER_HEAD_IM; | $self->{head_element_inserted} = 1; |
| 2126 | !!!next-token; | } else { |
| 2127 | redo B; | !!!cp ('t103'); |
| 2128 | } elsif ($token->{tag_name} eq 'meta') { | } |
| 2129 | ## NOTE: There is a "as if in head" code clone. | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); |
| 2130 | if ($self->{insertion_mode} == AFTER_HEAD_IM) { | pop @{$self->{open_elements}}; |
| 2131 | !!!cp ('t104'); | pop @{$self->{open_elements}} # <head> |
| 2132 | !!!parse-error (type => 'after head:'.$token->{tag_name}); | if $self->{insertion_mode} == AFTER_HEAD_IM; |
| 2133 | push @{$self->{open_elements}}, [$self->{head_element}, 'head']; | !!!ack ('t103.1'); |
| 2134 | } else { | !!!next-token; |
| 2135 | !!!cp ('t105'); | next B; |
| 2136 | } | } elsif ($token->{tag_name} eq 'command' or |
| 2137 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | $token->{tag_name} eq 'eventsource') { |
| 2138 | my $meta_el = pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec. | if ($self->{insertion_mode} == IN_HEAD_IM) { |
| 2139 | ## NOTE: If the insertion mode at the time of the emission | |
| 2140 | ## of the token was "before head", $self->{insertion_mode} | |
| 2141 | ## is already changed to |IN_HEAD_IM|. | |
| 2142 | ||
| 2143 | ## NOTE: There is a "as if in head" code clone. | |
| 2144 | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); | |
| 2145 | pop @{$self->{open_elements}}; | |
| 2146 | pop @{$self->{open_elements}} # <head> | |
| 2147 | if $self->{insertion_mode} == AFTER_HEAD_IM; | |
| 2148 | !!!ack ('t103.2'); | |
| 2149 | !!!next-token; | |
| 2150 | next B; | |
| 2151 | } else { | |
| 2152 | ## NOTE: "in head noscript" or "after head" insertion mode | |
| 2153 | ## - in these cases, these tags are treated as same as | |
| 2154 | ## normal in-body tags. | |
| 2155 | !!!cp ('t103.3'); | |
| 2156 | # | |
| 2157 | } | |
| 2158 | } elsif ($token->{tag_name} eq 'meta') { | |
| 2159 | ## NOTE: There is a "as if in head" code clone. | |
| 2160 | if ($self->{insertion_mode} == AFTER_HEAD_IM) { | |
| 2161 | !!!cp ('t104'); | |
| 2162 | !!!parse-error (type => 'after head', | |
| 2163 | text => $token->{tag_name}, token => $token); | |
| 2164 | push @{$self->{open_elements}}, | |
| 2165 | [$self->{head_element}, $el_category->{head}]; | |
| 2166 | $self->{head_element_inserted} = 1; | |
| 2167 | } else { | |
| 2168 | !!!cp ('t105'); | |
| 2169 | } | |
| 2170 | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); | |
| 2171 | my $meta_el = pop @{$self->{open_elements}}; | |
| 2172 | ||
| 2173 | unless ($self->{confident}) { | unless ($self->{confident}) { |
| 2174 | if ($token->{attributes}->{charset}) { ## TODO: And if supported | if ($token->{attributes}->{charset}) { |
| 2175 | !!!cp ('t106'); | !!!cp ('t106'); |
| 2176 | ## NOTE: Whether the encoding is supported or not is handled | |
| 2177 | ## in the {change_encoding} callback. | |
| 2178 | $self->{change_encoding} | $self->{change_encoding} |
| 2179 | ->($self, $token->{attributes}->{charset}->{value}); | ->($self, $token->{attributes}->{charset}->{value}, |
| 2180 | $token); | |
| 2181 | ||
| 2182 | $meta_el->[0]->get_attribute_node_ns (undef, 'charset') | $meta_el->[0]->get_attribute_node_ns (undef, 'charset') |
| 2183 | ->set_user_data (manakai_has_reference => | ->set_user_data (manakai_has_reference => |
| 2184 | $token->{attributes}->{charset} | $token->{attributes}->{charset} |
| 2185 | ->{has_reference}); | ->{has_reference}); |
| 2186 | } elsif ($token->{attributes}->{content}) { | } elsif ($token->{attributes}->{content}) { |
| ## ISSUE: Algorithm name in the spec was incorrect so that not linked to the definition. | ||
| 2187 | if ($token->{attributes}->{content}->{value} | if ($token->{attributes}->{content}->{value} |
| 2188 | =~ /\A[^;]*;[\x09-\x0D\x20]*[Cc][Hh][Aa][Rr][Ss][Ee][Tt] | =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt] |
| 2189 | [\x09-\x0D\x20]*= | [\x09\x0A\x0C\x0D\x20]*= |
| 2190 | [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'| | [\x09\x0A\x0C\x0D\x20]*(?>"([^"]*)"|'([^']*)'| |
| 2191 | ([^"'\x09-\x0D\x20][^\x09-\x0D\x20]*))/x) { | ([^"'\x09\x0A\x0C\x0D\x20] |
| 2192 | [^\x09\x0A\x0C\x0D\x20\x3B]*))/x) { | |
| 2193 | !!!cp ('t107'); | !!!cp ('t107'); |
| 2194 | ## NOTE: Whether the encoding is supported or not is handled | |
| 2195 | ## in the {change_encoding} callback. | |
| 2196 | $self->{change_encoding} | $self->{change_encoding} |
| 2197 | ->($self, defined $1 ? $1 : defined $2 ? $2 : $3); | ->($self, defined $1 ? $1 : defined $2 ? $2 : $3, |
| 2198 | $token); | |
| 2199 | $meta_el->[0]->get_attribute_node_ns (undef, 'content') | $meta_el->[0]->get_attribute_node_ns (undef, 'content') |
| 2200 | ->set_user_data (manakai_has_reference => | ->set_user_data (manakai_has_reference => |
| 2201 | $token->{attributes}->{content} | $token->{attributes}->{content} |
| # | Line 3574 sub _tree_construction_main ($) { | Line 2223 sub _tree_construction_main ($) { |
| 2223 | ||
| 2224 | pop @{$self->{open_elements}} # <head> | pop @{$self->{open_elements}} # <head> |
| 2225 | if $self->{insertion_mode} == AFTER_HEAD_IM; | if $self->{insertion_mode} == AFTER_HEAD_IM; |
| 2226 | !!!ack ('t110.1'); | |
| 2227 | !!!next-token; | !!!next-token; |
| 2228 | redo B; | next B; |
| 2229 | } elsif ($token->{tag_name} eq 'title') { | } elsif ($token->{tag_name} eq 'title') { |
| 2230 | if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { | if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { |
| 2231 | !!!cp ('t111'); | !!!cp ('t111'); |
| 2232 | ## As if </noscript> | ## As if </noscript> |
| 2233 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2234 | !!!parse-error (type => 'in noscript:title'); | !!!parse-error (type => 'in noscript', text => 'title', |
| 2235 | token => $token); | |
| 2236 | $self->{insertion_mode} = IN_HEAD_IM; | |
| 2237 | ## Reprocess in the "in head" insertion mode... | $self->{insertion_mode} = IN_HEAD_IM; |
| 2238 | } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) { | ## Reprocess in the "in head" insertion mode... |
| 2239 | !!!cp ('t112'); | } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) { |
| 2240 | !!!parse-error (type => 'after head:'.$token->{tag_name}); | !!!cp ('t112'); |
| 2241 | push @{$self->{open_elements}}, [$self->{head_element}, 'head']; | !!!parse-error (type => 'after head', |
| 2242 | } else { | text => $token->{tag_name}, token => $token); |
| 2243 | !!!cp ('t113'); | push @{$self->{open_elements}}, |
| 2244 | } | [$self->{head_element}, $el_category->{head}]; |
| 2245 | $self->{head_element_inserted} = 1; | |
| 2246 | ## NOTE: There is a "as if in head" code clone. | } else { |
| 2247 | my $parent = defined $self->{head_element} ? $self->{head_element} | !!!cp ('t113'); |
| 2248 | : $self->{open_elements}->[-1]->[0]; | } |
| 2249 | $parse_rcdata->(RCDATA_CONTENT_MODEL); | |
| 2250 | pop @{$self->{open_elements}} # <head> | ## NOTE: There is a "as if in head" code clone. |
| 2251 | if $self->{insertion_mode} == AFTER_HEAD_IM; | $parse_rcdata->(RCDATA_CONTENT_MODEL); |
| 2252 | redo B; | ## ISSUE: A spec bug [Bug 6038] |
| 2253 | } elsif ($token->{tag_name} eq 'style') { | splice @{$self->{open_elements}}, -2, 1, () # <head> |
| 2254 | ## NOTE: Or (scripting is enabled and tag_name eq 'noscript' and | if ($self->{insertion_mode} & IM_MASK) == AFTER_HEAD_IM; |
| 2255 | ## insertion mode IN_HEAD_IM) | next B; |
| 2256 | ## NOTE: There is a "as if in head" code clone. | } elsif ($token->{tag_name} eq 'style' or |
| 2257 | if ($self->{insertion_mode} == AFTER_HEAD_IM) { | $token->{tag_name} eq 'noframes') { |
| 2258 | !!!cp ('t114'); | ## NOTE: Or (scripting is enabled and tag_name eq 'noscript' and |
| 2259 | !!!parse-error (type => 'after head:'.$token->{tag_name}); | ## insertion mode IN_HEAD_IM) |
| 2260 | push @{$self->{open_elements}}, [$self->{head_element}, 'head']; | ## NOTE: There is a "as if in head" code clone. |
| 2261 | } else { | if ($self->{insertion_mode} == AFTER_HEAD_IM) { |
| 2262 | !!!cp ('t115'); | !!!cp ('t114'); |
| 2263 | } | !!!parse-error (type => 'after head', |
| 2264 | $parse_rcdata->(CDATA_CONTENT_MODEL); | text => $token->{tag_name}, token => $token); |
| 2265 | pop @{$self->{open_elements}} # <head> | push @{$self->{open_elements}}, |
| 2266 | if $self->{insertion_mode} == AFTER_HEAD_IM; | [$self->{head_element}, $el_category->{head}]; |
| 2267 | redo B; | $self->{head_element_inserted} = 1; |
| 2268 | } elsif ($token->{tag_name} eq 'noscript') { | } else { |
| 2269 | !!!cp ('t115'); | |
| 2270 | } | |
| 2271 | $parse_rcdata->(CDATA_CONTENT_MODEL); | |
| 2272 | ## ISSUE: A spec bug [Bug 6038] | |
| 2273 | splice @{$self->{open_elements}}, -2, 1, () # <head> | |
| 2274 | if ($self->{insertion_mode} & IM_MASK) == AFTER_HEAD_IM; | |
| 2275 | next B; | |
| 2276 | } elsif ($token->{tag_name} eq 'noscript') { | |
| 2277 | if ($self->{insertion_mode} == IN_HEAD_IM) { | if ($self->{insertion_mode} == IN_HEAD_IM) { |
| 2278 | !!!cp ('t116'); | !!!cp ('t116'); |
| 2279 | ## NOTE: and scripting is disalbed | ## NOTE: and scripting is disalbed |
| 2280 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); |
| 2281 | $self->{insertion_mode} = IN_HEAD_NOSCRIPT_IM; | $self->{insertion_mode} = IN_HEAD_NOSCRIPT_IM; |
| 2282 | !!!nack ('t116.1'); | |
| 2283 | !!!next-token; | !!!next-token; |
| 2284 | redo B; | next B; |
| 2285 | } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { | } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { |
| 2286 | !!!cp ('t117'); | !!!cp ('t117'); |
| 2287 | !!!parse-error (type => 'in noscript:noscript'); | !!!parse-error (type => 'in noscript', text => 'noscript', |
| 2288 | token => $token); | |
| 2289 | ## Ignore the token | ## Ignore the token |
| 2290 | !!!nack ('t117.1'); | |
| 2291 | !!!next-token; | !!!next-token; |
| 2292 | redo B; | next B; |
| 2293 | } else { | } else { |
| 2294 | !!!cp ('t118'); | !!!cp ('t118'); |
| 2295 | # | # |
| 2296 | } | } |
| 2297 | } elsif ($token->{tag_name} eq 'script') { | } elsif ($token->{tag_name} eq 'script') { |
| 2298 | if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { | if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { |
| 2299 | !!!cp ('t119'); | !!!cp ('t119'); |
| 2300 | ## As if </noscript> | ## As if </noscript> |
| 2301 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2302 | !!!parse-error (type => 'in noscript:script'); | !!!parse-error (type => 'in noscript', text => 'script', |
| 2303 | token => $token); | |
| 2304 | $self->{insertion_mode} = IN_HEAD_IM; | |
| 2305 | ## Reprocess in the "in head" insertion mode... | $self->{insertion_mode} = IN_HEAD_IM; |
| 2306 | } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) { | ## Reprocess in the "in head" insertion mode... |
| 2307 | !!!cp ('t120'); | } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) { |
| 2308 | !!!parse-error (type => 'after head:'.$token->{tag_name}); | !!!cp ('t120'); |
| 2309 | push @{$self->{open_elements}}, [$self->{head_element}, 'head']; | !!!parse-error (type => 'after head', |
| 2310 | } else { | text => $token->{tag_name}, token => $token); |
| 2311 | !!!cp ('t121'); | push @{$self->{open_elements}}, |
| 2312 | } | [$self->{head_element}, $el_category->{head}]; |
| 2313 | $self->{head_element_inserted} = 1; | |
| 2314 | ## NOTE: There is a "as if in head" code clone. | } else { |
| 2315 | $script_start_tag->(); | !!!cp ('t121'); |
| 2316 | pop @{$self->{open_elements}} # <head> | } |
| 2317 | if $self->{insertion_mode} == AFTER_HEAD_IM; | |
| 2318 | redo B; | ## NOTE: There is a "as if in head" code clone. |
| 2319 | } elsif ($token->{tag_name} eq 'body' or | $script_start_tag->(); |
| 2320 | $token->{tag_name} eq 'frameset') { | ## ISSUE: A spec bug [Bug 6038] |
| 2321 | splice @{$self->{open_elements}}, -2, 1 # <head> | |
| 2322 | if ($self->{insertion_mode} & IM_MASK) == AFTER_HEAD_IM; | |
| 2323 | next B; | |
| 2324 | } elsif ($token->{tag_name} eq 'body' or | |
| 2325 | $token->{tag_name} eq 'frameset') { | |
| 2326 | if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { | if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { |
| 2327 | !!!cp ('t122'); | !!!cp ('t122'); |
| 2328 | ## As if </noscript> | ## As if </noscript> |
| 2329 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2330 | !!!parse-error (type => 'in noscript:'.$token->{tag_name}); | !!!parse-error (type => 'in noscript', |
| 2331 | text => $token->{tag_name}, token => $token); | |
| 2332 | ||
| 2333 | ## Reprocess in the "in head" insertion mode... | ## Reprocess in the "in head" insertion mode... |
| 2334 | ## As if </head> | ## As if </head> |
| # | Line 3678 sub _tree_construction_main ($) { | Line 2345 sub _tree_construction_main ($) { |
| 2345 | } | } |
| 2346 | ||
| 2347 | ## "after head" insertion mode | ## "after head" insertion mode |
| 2348 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); |
| 2349 | if ($token->{tag_name} eq 'body') { | if ($token->{tag_name} eq 'body') { |
| 2350 | !!!cp ('t126'); | !!!cp ('t126'); |
| 2351 | $self->{insertion_mode} = IN_BODY_IM; | $self->{insertion_mode} = IN_BODY_IM; |
| # | Line 3688 sub _tree_construction_main ($) { | Line 2355 sub _tree_construction_main ($) { |
| 2355 | } else { | } else { |
| 2356 | die "$0: tag name: $self->{tag_name}"; | die "$0: tag name: $self->{tag_name}"; |
| 2357 | } | } |
| 2358 | !!!nack ('t127.1'); | |
| 2359 | !!!next-token; | !!!next-token; |
| 2360 | redo B; | next B; |
| 2361 | } else { | } else { |
| 2362 | !!!cp ('t128'); | !!!cp ('t128'); |
| 2363 | # | # |
| # | Line 3699 sub _tree_construction_main ($) { | Line 2367 sub _tree_construction_main ($) { |
| 2367 | !!!cp ('t129'); | !!!cp ('t129'); |
| 2368 | ## As if </noscript> | ## As if </noscript> |
| 2369 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2370 | !!!parse-error (type => 'in noscript:/'.$token->{tag_name}); | !!!parse-error (type => 'in noscript:/', |
| 2371 | text => $token->{tag_name}, token => $token); | |
| 2372 | ||
| 2373 | ## Reprocess in the "in head" insertion mode... | ## Reprocess in the "in head" insertion mode... |
| 2374 | ## As if </head> | ## As if </head> |
| # | Line 3718 sub _tree_construction_main ($) { | Line 2387 sub _tree_construction_main ($) { |
| 2387 | ||
| 2388 | ## "after head" insertion mode | ## "after head" insertion mode |
| 2389 | ## As if <body> | ## As if <body> |
| 2390 | !!!insert-element ('body'); | !!!insert-element ('body',, $token); |
| 2391 | $self->{insertion_mode} = IN_BODY_IM; | $self->{insertion_mode} = IN_BODY_IM; |
| 2392 | ## reprocess | ## reprocess |
| 2393 | redo B; | !!!ack-later; |
| 2394 | next B; | |
| 2395 | } elsif ($token->{type} == END_TAG_TOKEN) { | } elsif ($token->{type} == END_TAG_TOKEN) { |
| 2396 | if ($token->{tag_name} eq 'head') { | if ($token->{tag_name} eq 'head') { |
| 2397 | if ($self->{insertion_mode} == BEFORE_HEAD_IM) { | if ($self->{insertion_mode} == BEFORE_HEAD_IM) { |
| 2398 | !!!cp ('t132'); | !!!cp ('t132'); |
| 2399 | ## As if <head> | ## As if <head> |
| 2400 | !!!create-element ($self->{head_element}, 'head'); | !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token); |
| 2401 | $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element}); | $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element}); |
| 2402 | push @{$self->{open_elements}}, [$self->{head_element}, 'head']; | push @{$self->{open_elements}}, |
| 2403 | [$self->{head_element}, $el_category->{head}]; | |
| 2404 | ||
| 2405 | ## Reprocess in the "in head" insertion mode... | ## Reprocess in the "in head" insertion mode... |
| 2406 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2407 | $self->{insertion_mode} = AFTER_HEAD_IM; | $self->{insertion_mode} = AFTER_HEAD_IM; |
| 2408 | !!!next-token; | !!!next-token; |
| 2409 | redo B; | next B; |
| 2410 | } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { | } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { |
| 2411 | !!!cp ('t133'); | !!!cp ('t133'); |
| 2412 | ## As if </noscript> | ## As if </noscript> |
| 2413 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2414 | !!!parse-error (type => 'in noscript:/head'); | !!!parse-error (type => 'in noscript:/', |
| 2415 | text => 'head', token => $token); | |
| 2416 | ||
| 2417 | ## Reprocess in the "in head" insertion mode... | ## Reprocess in the "in head" insertion mode... |
| 2418 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2419 | $self->{insertion_mode} = AFTER_HEAD_IM; | $self->{insertion_mode} = AFTER_HEAD_IM; |
| 2420 | !!!next-token; | !!!next-token; |
| 2421 | redo B; | next B; |
| 2422 | } elsif ($self->{insertion_mode} == IN_HEAD_IM) { | } elsif ($self->{insertion_mode} == IN_HEAD_IM) { |
| 2423 | !!!cp ('t134'); | !!!cp ('t134'); |
| 2424 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2425 | $self->{insertion_mode} = AFTER_HEAD_IM; | $self->{insertion_mode} = AFTER_HEAD_IM; |
| 2426 | !!!next-token; | !!!next-token; |
| 2427 | redo B; | next B; |
| 2428 | } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) { | |
| 2429 | !!!cp ('t134.1'); | |
| 2430 | !!!parse-error (type => 'unmatched end tag', text => 'head', | |
| 2431 | token => $token); | |
| 2432 | ## Ignore the token | |
| 2433 | !!!next-token; | |
| 2434 | next B; | |
| 2435 | } else { | } else { |
| 2436 | !!!cp ('t135'); | die "$0: $self->{insertion_mode}: Unknown insertion mode"; |
| # | ||
| 2437 | } | } |
| 2438 | } elsif ($token->{tag_name} eq 'noscript') { | } elsif ($token->{tag_name} eq 'noscript') { |
| 2439 | if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { | if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { |
| # | Line 3763 sub _tree_construction_main ($) { | Line 2441 sub _tree_construction_main ($) { |
| 2441 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2442 | $self->{insertion_mode} = IN_HEAD_IM; | $self->{insertion_mode} = IN_HEAD_IM; |
| 2443 | !!!next-token; | !!!next-token; |
| 2444 | redo B; | next B; |
| 2445 | } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) { | } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM or |
| 2446 | $self->{insertion_mode} == AFTER_HEAD_IM) { | |
| 2447 | !!!cp ('t137'); | !!!cp ('t137'); |
| 2448 | !!!parse-error (type => 'unmatched end tag:noscript'); | !!!parse-error (type => 'unmatched end tag', |
| 2449 | text => 'noscript', token => $token); | |
| 2450 | ## Ignore the token ## ISSUE: An issue in the spec. | ## Ignore the token ## ISSUE: An issue in the spec. |
| 2451 | !!!next-token; | !!!next-token; |
| 2452 | redo B; | next B; |
| 2453 | } else { | } else { |
| 2454 | !!!cp ('t138'); | !!!cp ('t138'); |
| 2455 | # | # |
| # | Line 3777 sub _tree_construction_main ($) { | Line 2457 sub _tree_construction_main ($) { |
| 2457 | } elsif ({ | } elsif ({ |
| 2458 | body => 1, html => 1, | body => 1, html => 1, |
| 2459 | }->{$token->{tag_name}}) { | }->{$token->{tag_name}}) { |
| 2460 | if ($self->{insertion_mode} == BEFORE_HEAD_IM) { | ## TODO: This branch is entirely redundant. |
| 2461 | !!!cp ('t139'); | if ($self->{insertion_mode} == BEFORE_HEAD_IM or |
| 2462 | ## As if <head> | $self->{insertion_mode} == IN_HEAD_IM or |
| 2463 | !!!create-element ($self->{head_element}, 'head'); | $self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { |
| $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) { | ||
| 2464 | !!!cp ('t140'); | !!!cp ('t140'); |
| 2465 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 2466 | text => $token->{tag_name}, token => $token); | |
| 2467 | ## Ignore the token | ## Ignore the token |
| 2468 | !!!next-token; | !!!next-token; |
| 2469 | redo B; | next B; |
| 2470 | } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) { | |
| 2471 | !!!cp ('t140.1'); | |
| 2472 | !!!parse-error (type => 'unmatched end tag', | |
| 2473 | text => $token->{tag_name}, token => $token); | |
| 2474 | ## Ignore the token | |
| 2475 | !!!next-token; | |
| 2476 | next B; | |
| 2477 | } else { | } else { |
| 2478 | !!!cp ('t141'); | die "$0: $self->{insertion_mode}: Unknown insertion mode"; |
| 2479 | } | } |
| 2480 | } elsif ($token->{tag_name} eq 'p') { | |
| 2481 | # | !!!cp ('t142'); |
| 2482 | } elsif ({ | !!!parse-error (type => 'unmatched end tag', |
| 2483 | p => 1, br => 1, | text => $token->{tag_name}, token => $token); |
| 2484 | }->{$token->{tag_name}}) { | ## Ignore the token |
| 2485 | !!!next-token; | |
| 2486 | next B; | |
| 2487 | } elsif ($token->{tag_name} eq 'br') { | |
| 2488 | if ($self->{insertion_mode} == BEFORE_HEAD_IM) { | if ($self->{insertion_mode} == BEFORE_HEAD_IM) { |
| 2489 | !!!cp ('t142'); | !!!cp ('t142.2'); |
| 2490 | ## As if <head> | ## (before head) as if <head>, (in head) as if </head> |
| 2491 | !!!create-element ($self->{head_element}, 'head'); | !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token); |
| 2492 | $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element}); | $self->{open_elements}->[-1]->[0]->append_child ($self->{head_element}); |
| 2493 | push @{$self->{open_elements}}, [$self->{head_element}, 'head']; | $self->{insertion_mode} = AFTER_HEAD_IM; |
| 2494 | ||
| 2495 | ## Reprocess in the "after head" insertion mode... | |
| 2496 | } elsif ($self->{insertion_mode} == IN_HEAD_IM) { | |
| 2497 | !!!cp ('t143.2'); | |
| 2498 | ## As if </head> | |
| 2499 | pop @{$self->{open_elements}}; | |
| 2500 | $self->{insertion_mode} = AFTER_HEAD_IM; | |
| 2501 | ||
| 2502 | ## Reprocess in the "after head" insertion mode... | |
| 2503 | } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { | |
| 2504 | !!!cp ('t143.3'); | |
| 2505 | ## NOTE: Two parse errors for <head><noscript></br> | |
| 2506 | !!!parse-error (type => 'unmatched end tag', | |
| 2507 | text => 'br', token => $token); | |
| 2508 | ## As if </noscript> | |
| 2509 | pop @{$self->{open_elements}}; | |
| 2510 | $self->{insertion_mode} = IN_HEAD_IM; | $self->{insertion_mode} = IN_HEAD_IM; |
| 2511 | ||
| 2512 | ## Reprocess in the "in head" insertion mode... | ## Reprocess in the "in head" insertion mode... |
| 2513 | } else { | ## As if </head> |
| 2514 | !!!cp ('t143'); | pop @{$self->{open_elements}}; |
| 2515 | } | $self->{insertion_mode} = AFTER_HEAD_IM; |
| 2516 | ||
| 2517 | # | ## Reprocess in the "after head" insertion mode... |
| 2518 | } else { | } elsif ($self->{insertion_mode} == AFTER_HEAD_IM) { |
| 2519 | if ($self->{insertion_mode} == AFTER_HEAD_IM) { | !!!cp ('t143.4'); |
| !!!cp ('t144'); | ||
| 2520 | # | # |
| 2521 | } else { | } else { |
| 2522 | !!!cp ('t145'); | die "$0: $self->{insertion_mode}: Unknown insertion mode"; |
| !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | ||
| ## Ignore the token | ||
| !!!next-token; | ||
| redo B; | ||
| 2523 | } | } |
| 2524 | ||
| 2525 | ## ISSUE: does not agree with IE7 - it doesn't ignore </br>. | |
| 2526 | !!!parse-error (type => 'unmatched end tag', | |
| 2527 | text => 'br', token => $token); | |
| 2528 | ## Ignore the token | |
| 2529 | !!!next-token; | |
| 2530 | next B; | |
| 2531 | } else { | |
| 2532 | !!!cp ('t145'); | |
| 2533 | !!!parse-error (type => 'unmatched end tag', | |
| 2534 | text => $token->{tag_name}, token => $token); | |
| 2535 | ## Ignore the token | |
| 2536 | !!!next-token; | |
| 2537 | next B; | |
| 2538 | } | } |
| 2539 | ||
| 2540 | if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { | if ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { |
| 2541 | !!!cp ('t146'); | !!!cp ('t146'); |
| 2542 | ## As if </noscript> | ## As if </noscript> |
| 2543 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2544 | !!!parse-error (type => 'in noscript:/'.$token->{tag_name}); | !!!parse-error (type => 'in noscript:/', |
| 2545 | text => $token->{tag_name}, token => $token); | |
| 2546 | ||
| 2547 | ## Reprocess in the "in head" insertion mode... | ## Reprocess in the "in head" insertion mode... |
| 2548 | ## As if </head> | ## As if </head> |
| # | Line 3847 sub _tree_construction_main ($) { | Line 2558 sub _tree_construction_main ($) { |
| 2558 | } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) { | } elsif ($self->{insertion_mode} == BEFORE_HEAD_IM) { |
| 2559 | ## ISSUE: This case cannot be reached? | ## ISSUE: This case cannot be reached? |
| 2560 | !!!cp ('t148'); | !!!cp ('t148'); |
| 2561 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 2562 | text => $token->{tag_name}, token => $token); | |
| 2563 | ## Ignore the token ## ISSUE: An issue in the spec. | ## Ignore the token ## ISSUE: An issue in the spec. |
| 2564 | !!!next-token; | !!!next-token; |
| 2565 | redo B; | next B; |
| 2566 | } else { | } else { |
| 2567 | !!!cp ('t149'); | !!!cp ('t149'); |
| 2568 | } | } |
| 2569 | ||
| 2570 | ## "after head" insertion mode | ## "after head" insertion mode |
| 2571 | ## As if <body> | ## As if <body> |
| 2572 | !!!insert-element ('body'); | !!!insert-element ('body',, $token); |
| 2573 | $self->{insertion_mode} = IN_BODY_IM; | $self->{insertion_mode} = IN_BODY_IM; |
| 2574 | ## reprocess | ## reprocess |
| 2575 | redo B; | next B; |
| 2576 | } elsif ($token->{type} == END_OF_FILE_TOKEN) { | } elsif ($token->{type} == END_OF_FILE_TOKEN) { |
| 2577 | if ($self->{insertion_mode} == BEFORE_HEAD_IM) { | if ($self->{insertion_mode} == BEFORE_HEAD_IM) { |
| 2578 | !!!cp ('t149.1'); | !!!cp ('t149.1'); |
| 2579 | ||
| 2580 | ## NOTE: As if <head> | ## NOTE: As if <head> |
| 2581 | !!!create-element ($self->{head_element}, 'head'); | !!!create-element ($self->{head_element}, $HTML_NS, 'head',, $token); |
| 2582 | $self->{open_elements}->[-1]->[0]->append_child | $self->{open_elements}->[-1]->[0]->append_child |
| 2583 | ($self->{head_element}); | ($self->{head_element}); |
| 2584 | #push @{$self->{open_elements}}, [$self->{head_element}, 'head']; | #push @{$self->{open_elements}}, |
| 2585 | # [$self->{head_element}, $el_category->{head}]; | |
| 2586 | #$self->{insertion_mode} = IN_HEAD_IM; | #$self->{insertion_mode} = IN_HEAD_IM; |
| 2587 | ## NOTE: Reprocess. | ## NOTE: Reprocess. |
| 2588 | ||
| # | Line 3891 sub _tree_construction_main ($) { | Line 2604 sub _tree_construction_main ($) { |
| 2604 | } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { | } elsif ($self->{insertion_mode} == IN_HEAD_NOSCRIPT_IM) { |
| 2605 | !!!cp ('t149.3'); | !!!cp ('t149.3'); |
| 2606 | ||
| 2607 | !!!parse-error (type => 'in noscript:#eof'); | !!!parse-error (type => 'in noscript:#eof', token => $token); |
| 2608 | ||
| 2609 | ## As if </noscript> | ## As if </noscript> |
| 2610 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| # | Line 3910 sub _tree_construction_main ($) { | Line 2623 sub _tree_construction_main ($) { |
| 2623 | } | } |
| 2624 | ||
| 2625 | ## NOTE: As if <body> | ## NOTE: As if <body> |
| 2626 | !!!insert-element ('body'); | !!!insert-element ('body',, $token); |
| 2627 | $self->{insertion_mode} = IN_BODY_IM; | $self->{insertion_mode} = IN_BODY_IM; |
| 2628 | ## NOTE: Reprocess. | ## NOTE: Reprocess. |
| 2629 | redo B; | next B; |
| 2630 | } else { | } else { |
| 2631 | die "$0: $token->{type}: Unknown token type"; | die "$0: $token->{type}: Unknown token type"; |
| 2632 | } | } |
| ## ISSUE: An issue in the spec. | ||
| 2633 | } elsif ($self->{insertion_mode} & BODY_IMS) { | } elsif ($self->{insertion_mode} & BODY_IMS) { |
| 2634 | if ($token->{type} == CHARACTER_TOKEN) { | if ($token->{type} == CHARACTER_TOKEN) { |
| 2635 | !!!cp ('t150'); | !!!cp ('t150'); |
| # | Line 3928 sub _tree_construction_main ($) { | Line 2639 sub _tree_construction_main ($) { |
| 2639 | $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data}); | $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data}); |
| 2640 | ||
| 2641 | !!!next-token; | !!!next-token; |
| 2642 | redo B; | next B; |
| 2643 | } elsif ($token->{type} == START_TAG_TOKEN) { | } elsif ($token->{type} == START_TAG_TOKEN) { |
| 2644 | if ({ | if ({ |
| 2645 | caption => 1, col => 1, colgroup => 1, tbody => 1, | caption => 1, col => 1, colgroup => 1, tbody => 1, |
| 2646 | td => 1, tfoot => 1, th => 1, thead => 1, tr => 1, | td => 1, tfoot => 1, th => 1, thead => 1, tr => 1, |
| 2647 | }->{$token->{tag_name}}) { | }->{$token->{tag_name}}) { |
| 2648 | if ($self->{insertion_mode} == IN_CELL_IM) { | if (($self->{insertion_mode} & IM_MASK) == IN_CELL_IM) { |
| 2649 | ## have an element in table scope | ## have an element in table scope |
| 2650 | for (reverse 0..$#{$self->{open_elements}}) { | for (reverse 0..$#{$self->{open_elements}}) { |
| 2651 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 2652 | if ($node->[1] eq 'td' or $node->[1] eq 'th') { | if ($node->[1] == TABLE_CELL_EL) { |
| 2653 | !!!cp ('t151'); | !!!cp ('t151'); |
| 2654 | ||
| 2655 | ## Close the cell | ## Close the cell |
| 2656 | !!!back-token; # <?> | !!!back-token; # <x> |
| 2657 | $token = {type => END_TAG_TOKEN, tag_name => $node->[1]}; | $token = {type => END_TAG_TOKEN, |
| 2658 | redo B; | tag_name => $node->[0]->manakai_local_name, |
| 2659 | } elsif ({ | line => $token->{line}, |
| 2660 | table => 1, html => 1, | column => $token->{column}}; |
| 2661 | }->{$node->[1]}) { | next B; |
| 2662 | } elsif ($node->[1] & TABLE_SCOPING_EL) { | |
| 2663 | !!!cp ('t152'); | !!!cp ('t152'); |
| 2664 | ## ISSUE: This case can never be reached, maybe. | ## ISSUE: This case can never be reached, maybe. |
| 2665 | last; | last; |
| # | Line 3956 sub _tree_construction_main ($) { | Line 2668 sub _tree_construction_main ($) { |
| 2668 | ||
| 2669 | !!!cp ('t153'); | !!!cp ('t153'); |
| 2670 | !!!parse-error (type => 'start tag not allowed', | !!!parse-error (type => 'start tag not allowed', |
| 2671 | value => $token->{tag_name}); | text => $token->{tag_name}, token => $token); |
| 2672 | ## Ignore the token | ## Ignore the token |
| 2673 | !!!nack ('t153.1'); | |
| 2674 | !!!next-token; | !!!next-token; |
| 2675 | redo B; | next B; |
| 2676 | } elsif ($self->{insertion_mode} == IN_CAPTION_IM) { | } elsif (($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) { |
| 2677 | !!!parse-error (type => 'not closed:caption'); | !!!parse-error (type => 'not closed', text => 'caption', |
| 2678 | token => $token); | |
| 2679 | ||
| 2680 | ## NOTE: As if </caption>. | ## NOTE: As if </caption>. |
| 2681 | ## have a table element in table scope | ## have a table element in table scope |
| # | Line 3969 sub _tree_construction_main ($) { | Line 2683 sub _tree_construction_main ($) { |
| 2683 | INSCOPE: { | INSCOPE: { |
| 2684 | for (reverse 0..$#{$self->{open_elements}}) { | for (reverse 0..$#{$self->{open_elements}}) { |
| 2685 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 2686 | if ($node->[1] eq 'caption') { | if ($node->[1] == CAPTION_EL) { |
| 2687 | !!!cp ('t155'); | !!!cp ('t155'); |
| 2688 | $i = $_; | $i = $_; |
| 2689 | last INSCOPE; | last INSCOPE; |
| 2690 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 2691 | !!!cp ('t156'); | !!!cp ('t156'); |
| 2692 | last; | last; |
| 2693 | } | } |
| # | Line 3983 sub _tree_construction_main ($) { | Line 2695 sub _tree_construction_main ($) { |
| 2695 | ||
| 2696 | !!!cp ('t157'); | !!!cp ('t157'); |
| 2697 | !!!parse-error (type => 'start tag not allowed', | !!!parse-error (type => 'start tag not allowed', |
| 2698 | value => $token->{tag_name}); | text => $token->{tag_name}, token => $token); |
| 2699 | ## Ignore the token | ## Ignore the token |
| 2700 | !!!nack ('t157.1'); | |
| 2701 | !!!next-token; | !!!next-token; |
| 2702 | redo B; | next B; |
| 2703 | } # INSCOPE | } # INSCOPE |
| 2704 | ||
| 2705 | ## generate implied end tags | ## generate implied end tags |
| 2706 | while ({ | while ($self->{open_elements}->[-1]->[1] |
| 2707 | dd => 1, dt => 1, li => 1, p => 1, | & END_TAG_OPTIONAL_EL) { |
| }->{$self->{open_elements}->[-1]->[1]}) { | ||
| 2708 | !!!cp ('t158'); | !!!cp ('t158'); |
| 2709 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2710 | } | } |
| 2711 | ||
| 2712 | if ($self->{open_elements}->[-1]->[1] ne 'caption') { | unless ($self->{open_elements}->[-1]->[1] == CAPTION_EL) { |
| 2713 | !!!cp ('t159'); | !!!cp ('t159'); |
| 2714 | !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]); | !!!parse-error (type => 'not closed', |
| 2715 | text => $self->{open_elements}->[-1]->[0] | |
| 2716 | ->manakai_local_name, | |
| 2717 | token => $token); | |
| 2718 | } else { | } else { |
| 2719 | !!!cp ('t160'); | !!!cp ('t160'); |
| 2720 | } | } |
| # | Line 4011 sub _tree_construction_main ($) { | Line 2726 sub _tree_construction_main ($) { |
| 2726 | $self->{insertion_mode} = IN_TABLE_IM; | $self->{insertion_mode} = IN_TABLE_IM; |
| 2727 | ||
| 2728 | ## reprocess | ## reprocess |
| 2729 | redo B; | !!!ack-later; |
| 2730 | next B; | |
| 2731 | } else { | } else { |
| 2732 | !!!cp ('t161'); | !!!cp ('t161'); |
| 2733 | # | # |
| # | Line 4022 sub _tree_construction_main ($) { | Line 2738 sub _tree_construction_main ($) { |
| 2738 | } | } |
| 2739 | } elsif ($token->{type} == END_TAG_TOKEN) { | } elsif ($token->{type} == END_TAG_TOKEN) { |
| 2740 | if ($token->{tag_name} eq 'td' or $token->{tag_name} eq 'th') { | if ($token->{tag_name} eq 'td' or $token->{tag_name} eq 'th') { |
| 2741 | if ($self->{insertion_mode} == IN_CELL_IM) { | if (($self->{insertion_mode} & IM_MASK) == IN_CELL_IM) { |
| 2742 | ## have an element in table scope | ## have an element in table scope |
| 2743 | my $i; | my $i; |
| 2744 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 2745 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 2746 | if ($node->[1] eq $token->{tag_name}) { | if ($node->[0]->manakai_local_name eq $token->{tag_name}) { |
| 2747 | !!!cp ('t163'); | !!!cp ('t163'); |
| 2748 | $i = $_; | $i = $_; |
| 2749 | last INSCOPE; | last INSCOPE; |
| 2750 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 2751 | !!!cp ('t164'); | !!!cp ('t164'); |
| 2752 | last INSCOPE; | last INSCOPE; |
| 2753 | } | } |
| 2754 | } # INSCOPE | } # INSCOPE |
| 2755 | unless (defined $i) { | unless (defined $i) { |
| 2756 | !!!cp ('t165'); | !!!cp ('t165'); |
| 2757 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 2758 | text => $token->{tag_name}, | |
| 2759 | token => $token); | |
| 2760 | ## Ignore the token | ## Ignore the token |
| 2761 | !!!next-token; | !!!next-token; |
| 2762 | redo B; | next B; |
| 2763 | } | } |
| 2764 | ||
| 2765 | ## generate implied end tags | ## generate implied end tags |
| 2766 | while ({ | while ($self->{open_elements}->[-1]->[1] |
| 2767 | dd => 1, dt => 1, li => 1, p => 1, | & END_TAG_OPTIONAL_EL) { |
| }->{$self->{open_elements}->[-1]->[1]}) { | ||
| 2768 | !!!cp ('t166'); | !!!cp ('t166'); |
| 2769 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2770 | } | } |
| 2771 | ||
| 2772 | if ($self->{open_elements}->[-1]->[1] ne $token->{tag_name}) { | if ($self->{open_elements}->[-1]->[0]->manakai_local_name |
| 2773 | ne $token->{tag_name}) { | |
| 2774 | !!!cp ('t167'); | !!!cp ('t167'); |
| 2775 | !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]); | !!!parse-error (type => 'not closed', |
| 2776 | text => $self->{open_elements}->[-1]->[0] | |
| 2777 | ->manakai_local_name, | |
| 2778 | token => $token); | |
| 2779 | } else { | } else { |
| 2780 | !!!cp ('t168'); | !!!cp ('t168'); |
| 2781 | } | } |
| # | Line 4068 sub _tree_construction_main ($) { | Line 2787 sub _tree_construction_main ($) { |
| 2787 | $self->{insertion_mode} = IN_ROW_IM; | $self->{insertion_mode} = IN_ROW_IM; |
| 2788 | ||
| 2789 | !!!next-token; | !!!next-token; |
| 2790 | redo B; | next B; |
| 2791 | } elsif ($self->{insertion_mode} == IN_CAPTION_IM) { | } elsif (($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) { |
| 2792 | !!!cp ('t169'); | !!!cp ('t169'); |
| 2793 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 2794 | text => $token->{tag_name}, token => $token); | |
| 2795 | ## Ignore the token | ## Ignore the token |
| 2796 | !!!next-token; | !!!next-token; |
| 2797 | redo B; | next B; |
| 2798 | } else { | } else { |
| 2799 | !!!cp ('t170'); | !!!cp ('t170'); |
| 2800 | # | # |
| 2801 | } | } |
| 2802 | } elsif ($token->{tag_name} eq 'caption') { | } elsif ($token->{tag_name} eq 'caption') { |
| 2803 | if ($self->{insertion_mode} == IN_CAPTION_IM) { | if (($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) { |
| 2804 | ## have a table element in table scope | ## have a table element in table scope |
| 2805 | my $i; | my $i; |
| 2806 | INSCOPE: { | INSCOPE: { |
| 2807 | for (reverse 0..$#{$self->{open_elements}}) { | for (reverse 0..$#{$self->{open_elements}}) { |
| 2808 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 2809 | if ($node->[1] eq $token->{tag_name}) { | if ($node->[1] == CAPTION_EL) { |
| 2810 | !!!cp ('t171'); | !!!cp ('t171'); |
| 2811 | $i = $_; | $i = $_; |
| 2812 | last INSCOPE; | last INSCOPE; |
| 2813 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 2814 | !!!cp ('t172'); | !!!cp ('t172'); |
| 2815 | last; | last; |
| 2816 | } | } |
| # | Line 4100 sub _tree_construction_main ($) { | Line 2818 sub _tree_construction_main ($) { |
| 2818 | ||
| 2819 | !!!cp ('t173'); | !!!cp ('t173'); |
| 2820 | !!!parse-error (type => 'unmatched end tag', | !!!parse-error (type => 'unmatched end tag', |
| 2821 | value => $token->{tag_name}); | text => $token->{tag_name}, token => $token); |
| 2822 | ## Ignore the token | ## Ignore the token |
| 2823 | !!!next-token; | !!!next-token; |
| 2824 | redo B; | next B; |
| 2825 | } # INSCOPE | } # INSCOPE |
| 2826 | ||
| 2827 | ## generate implied end tags | ## generate implied end tags |
| 2828 | while ({ | while ($self->{open_elements}->[-1]->[1] |
| 2829 | dd => 1, dt => 1, li => 1, p => 1, | & END_TAG_OPTIONAL_EL) { |
| }->{$self->{open_elements}->[-1]->[1]}) { | ||
| 2830 | !!!cp ('t174'); | !!!cp ('t174'); |
| 2831 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2832 | } | } |
| 2833 | ||
| 2834 | if ($self->{open_elements}->[-1]->[1] ne 'caption') { | unless ($self->{open_elements}->[-1]->[1] == CAPTION_EL) { |
| 2835 | !!!cp ('t175'); | !!!cp ('t175'); |
| 2836 | !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]); | !!!parse-error (type => 'not closed', |
| 2837 | text => $self->{open_elements}->[-1]->[0] | |
| 2838 | ->manakai_local_name, | |
| 2839 | token => $token); | |
| 2840 | } else { | } else { |
| 2841 | !!!cp ('t176'); | !!!cp ('t176'); |
| 2842 | } | } |
| # | Line 4128 sub _tree_construction_main ($) { | Line 2848 sub _tree_construction_main ($) { |
| 2848 | $self->{insertion_mode} = IN_TABLE_IM; | $self->{insertion_mode} = IN_TABLE_IM; |
| 2849 | ||
| 2850 | !!!next-token; | !!!next-token; |
| 2851 | redo B; | next B; |
| 2852 | } elsif ($self->{insertion_mode} == IN_CELL_IM) { | } elsif (($self->{insertion_mode} & IM_MASK) == IN_CELL_IM) { |
| 2853 | !!!cp ('t177'); | !!!cp ('t177'); |
| 2854 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 2855 | text => $token->{tag_name}, token => $token); | |
| 2856 | ## Ignore the token | ## Ignore the token |
| 2857 | !!!next-token; | !!!next-token; |
| 2858 | redo B; | next B; |
| 2859 | } else { | } else { |
| 2860 | !!!cp ('t178'); | !!!cp ('t178'); |
| 2861 | # | # |
| # | Line 4143 sub _tree_construction_main ($) { | Line 2864 sub _tree_construction_main ($) { |
| 2864 | table => 1, tbody => 1, tfoot => 1, | table => 1, tbody => 1, tfoot => 1, |
| 2865 | thead => 1, tr => 1, | thead => 1, tr => 1, |
| 2866 | }->{$token->{tag_name}} and | }->{$token->{tag_name}} and |
| 2867 | $self->{insertion_mode} == IN_CELL_IM) { | ($self->{insertion_mode} & IM_MASK) == IN_CELL_IM) { |
| 2868 | ## have an element in table scope | ## have an element in table scope |
| 2869 | my $i; | my $i; |
| 2870 | my $tn; | my $tn; |
| 2871 | INSCOPE: { | INSCOPE: { |
| 2872 | for (reverse 0..$#{$self->{open_elements}}) { | for (reverse 0..$#{$self->{open_elements}}) { |
| 2873 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 2874 | if ($node->[1] eq $token->{tag_name}) { | if ($node->[0]->manakai_local_name eq $token->{tag_name}) { |
| 2875 | !!!cp ('t179'); | !!!cp ('t179'); |
| 2876 | $i = $_; | $i = $_; |
| 2877 | ||
| 2878 | ## Close the cell | ## Close the cell |
| 2879 | !!!back-token; # </?> | !!!back-token; # </x> |
| 2880 | $token = {type => END_TAG_TOKEN, tag_name => $tn}; | $token = {type => END_TAG_TOKEN, tag_name => $tn, |
| 2881 | redo B; | line => $token->{line}, |
| 2882 | } elsif ($node->[1] eq 'td' or $node->[1] eq 'th') { | column => $token->{column}}; |
| 2883 | next B; | |
| 2884 | } elsif ($node->[1] == TABLE_CELL_EL) { | |
| 2885 | !!!cp ('t180'); | !!!cp ('t180'); |
| 2886 | $tn = $node->[1]; | $tn = $node->[0]->manakai_local_name; |
| 2887 | ## NOTE: There is exactly one |td| or |th| element | ## NOTE: There is exactly one |td| or |th| element |
| 2888 | ## in scope in the stack of open elements by definition. | ## in scope in the stack of open elements by definition. |
| 2889 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 2890 | ## ISSUE: Can this be reached? | ## ISSUE: Can this be reached? |
| 2891 | !!!cp ('t181'); | !!!cp ('t181'); |
| 2892 | last; | last; |
| # | Line 4174 sub _tree_construction_main ($) { | Line 2895 sub _tree_construction_main ($) { |
| 2895 | ||
| 2896 | !!!cp ('t182'); | !!!cp ('t182'); |
| 2897 | !!!parse-error (type => 'unmatched end tag', | !!!parse-error (type => 'unmatched end tag', |
| 2898 | value => $token->{tag_name}); | text => $token->{tag_name}, token => $token); |
| 2899 | ## Ignore the token | ## Ignore the token |
| 2900 | !!!next-token; | !!!next-token; |
| 2901 | redo B; | next B; |
| 2902 | } # INSCOPE | } # INSCOPE |
| 2903 | } elsif ($token->{tag_name} eq 'table' and | } elsif ($token->{tag_name} eq 'table' and |
| 2904 | $self->{insertion_mode} == IN_CAPTION_IM) { | ($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) { |
| 2905 | !!!parse-error (type => 'not closed:caption'); | !!!parse-error (type => 'not closed', text => 'caption', |
| 2906 | token => $token); | |
| 2907 | ||
| 2908 | ## As if </caption> | ## As if </caption> |
| 2909 | ## have a table element in table scope | ## have a table element in table scope |
| 2910 | my $i; | my $i; |
| 2911 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 2912 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 2913 | if ($node->[1] eq 'caption') { | if ($node->[1] == CAPTION_EL) { |
| 2914 | !!!cp ('t184'); | !!!cp ('t184'); |
| 2915 | $i = $_; | $i = $_; |
| 2916 | last INSCOPE; | last INSCOPE; |
| 2917 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 2918 | !!!cp ('t185'); | !!!cp ('t185'); |
| 2919 | last INSCOPE; | last INSCOPE; |
| 2920 | } | } |
| 2921 | } # INSCOPE | } # INSCOPE |
| 2922 | unless (defined $i) { | unless (defined $i) { |
| 2923 | !!!cp ('t186'); | !!!cp ('t186'); |
| 2924 | !!!parse-error (type => 'unmatched end tag:caption'); | ## TODO: Wrong error type? |
| 2925 | !!!parse-error (type => 'unmatched end tag', | |
| 2926 | text => 'caption', token => $token); | |
| 2927 | ## Ignore the token | ## Ignore the token |
| 2928 | !!!next-token; | !!!next-token; |
| 2929 | redo B; | next B; |
| 2930 | } | } |
| 2931 | ||
| 2932 | ## generate implied end tags | ## generate implied end tags |
| 2933 | while ({ | while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) { |
| dd => 1, dt => 1, li => 1, p => 1, | ||
| }->{$self->{open_elements}->[-1]->[1]}) { | ||
| 2934 | !!!cp ('t187'); | !!!cp ('t187'); |
| 2935 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 2936 | } | } |
| 2937 | ||
| 2938 | if ($self->{open_elements}->[-1]->[1] ne 'caption') { | unless ($self->{open_elements}->[-1]->[1] == CAPTION_EL) { |
| 2939 | !!!cp ('t188'); | !!!cp ('t188'); |
| 2940 | !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]); | !!!parse-error (type => 'not closed', |
| 2941 | text => $self->{open_elements}->[-1]->[0] | |
| 2942 | ->manakai_local_name, | |
| 2943 | token => $token); | |
| 2944 | } else { | } else { |
| 2945 | !!!cp ('t189'); | !!!cp ('t189'); |
| 2946 | } | } |
| # | Line 4229 sub _tree_construction_main ($) { | Line 2952 sub _tree_construction_main ($) { |
| 2952 | $self->{insertion_mode} = IN_TABLE_IM; | $self->{insertion_mode} = IN_TABLE_IM; |
| 2953 | ||
| 2954 | ## reprocess | ## reprocess |
| 2955 | redo B; | next B; |
| 2956 | } elsif ({ | } elsif ({ |
| 2957 | body => 1, col => 1, colgroup => 1, html => 1, | body => 1, col => 1, colgroup => 1, html => 1, |
| 2958 | }->{$token->{tag_name}}) { | }->{$token->{tag_name}}) { |
| 2959 | if ($self->{insertion_mode} & BODY_TABLE_IMS) { | if ($self->{insertion_mode} & BODY_TABLE_IMS) { |
| 2960 | !!!cp ('t190'); | !!!cp ('t190'); |
| 2961 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 2962 | text => $token->{tag_name}, token => $token); | |
| 2963 | ## Ignore the token | ## Ignore the token |
| 2964 | !!!next-token; | !!!next-token; |
| 2965 | redo B; | next B; |
| 2966 | } else { | } else { |
| 2967 | !!!cp ('t191'); | !!!cp ('t191'); |
| 2968 | # | # |
| 2969 | } | } |
| 2970 | } elsif ({ | } elsif ({ |
| 2971 | tbody => 1, tfoot => 1, | tbody => 1, tfoot => 1, |
| 2972 | thead => 1, tr => 1, | thead => 1, tr => 1, |
| 2973 | }->{$token->{tag_name}} and | }->{$token->{tag_name}} and |
| 2974 | $self->{insertion_mode} == IN_CAPTION_IM) { | ($self->{insertion_mode} & IM_MASK) == IN_CAPTION_IM) { |
| 2975 | !!!cp ('t192'); | !!!cp ('t192'); |
| 2976 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 2977 | ## Ignore the token | text => $token->{tag_name}, token => $token); |
| 2978 | !!!next-token; | ## Ignore the token |
| 2979 | redo B; | !!!next-token; |
| 2980 | } else { | next B; |
| 2981 | !!!cp ('t193'); | } else { |
| 2982 | # | !!!cp ('t193'); |
| 2983 | } | # |
| 2984 | } | |
| 2985 | } elsif ($token->{type} == END_OF_FILE_TOKEN) { | } elsif ($token->{type} == END_OF_FILE_TOKEN) { |
| 2986 | for my $entry (@{$self->{open_elements}}) { | for my $entry (@{$self->{open_elements}}) { |
| 2987 | 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]}) { | ||
| 2988 | !!!cp ('t75'); | !!!cp ('t75'); |
| 2989 | !!!parse-error (type => 'in body:#eof'); | !!!parse-error (type => 'in body:#eof', token => $token); |
| 2990 | last; | last; |
| 2991 | } | } |
| 2992 | } | } |
| # | Line 4280 sub _tree_construction_main ($) { | Line 3002 sub _tree_construction_main ($) { |
| 3002 | } elsif ($self->{insertion_mode} & TABLE_IMS) { | } elsif ($self->{insertion_mode} & TABLE_IMS) { |
| 3003 | if ($token->{type} == CHARACTER_TOKEN) { | if ($token->{type} == CHARACTER_TOKEN) { |
| 3004 | if (not $open_tables->[-1]->[1] and # tainted | if (not $open_tables->[-1]->[1] and # tainted |
| 3005 | $token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { | $token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) { |
| 3006 | $self->{open_elements}->[-1]->[0]->manakai_append_text ($1); | $self->{open_elements}->[-1]->[0]->manakai_append_text ($1); |
| 3007 | ||
| 3008 | unless (length $token->{data}) { | unless (length $token->{data}) { |
| 3009 | !!!cp ('t194'); | !!!cp ('t194'); |
| 3010 | !!!next-token; | !!!next-token; |
| 3011 | redo B; | next B; |
| 3012 | } else { | } else { |
| 3013 | !!!cp ('t195'); | !!!cp ('t195'); |
| 3014 | } | } |
| 3015 | } | } |
| 3016 | ||
| 3017 | !!!parse-error (type => 'in table:#character'); | !!!parse-error (type => 'in table:#text', token => $token); |
| 3018 | ||
| 3019 | ## As if in body, but insert into foster parent element | ## NOTE: As if in body, but insert into the foster parent element. |
| 3020 | ## ISSUE: Spec says that "whenever a node would be inserted | $reconstruct_active_formatting_elements->($insert_to_foster); |
| ## into the current node" while characters might not be | ||
| ## result in a new Text node. | ||
| $reconstruct_active_formatting_elements->($insert_to_foster); | ||
| 3021 | ||
| 3022 | if ({ | if ($self->{open_elements}->[-1]->[1] & TABLE_ROWS_EL) { |
| 3023 | table => 1, tbody => 1, tfoot => 1, | # MUST |
| 3024 | thead => 1, tr => 1, | my $foster_parent_element; |
| 3025 | }->{$self->{open_elements}->[-1]->[1]}) { | my $next_sibling; |
| 3026 | # MUST | my $prev_sibling; |
| 3027 | my $foster_parent_element; | OE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3028 | my $next_sibling; | if ($self->{open_elements}->[$_]->[1] == TABLE_EL) { |
| 3029 | my $prev_sibling; | my $parent = $self->{open_elements}->[$_]->[0]->parent_node; |
| 3030 | OE: for (reverse 0..$#{$self->{open_elements}}) { | if (defined $parent and $parent->node_type == 1) { |
| 3031 | if ($self->{open_elements}->[$_]->[1] eq 'table') { | $foster_parent_element = $parent; |
| 3032 | my $parent = $self->{open_elements}->[$_]->[0]->parent_node; | !!!cp ('t196'); |
| 3033 | if (defined $parent and $parent->node_type == 1) { | $next_sibling = $self->{open_elements}->[$_]->[0]; |
| 3034 | !!!cp ('t196'); | $prev_sibling = $next_sibling->previous_sibling; |
| 3035 | $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}); | ||
| 3036 | } else { | } else { |
| 3037 | !!!cp ('t199'); | !!!cp ('t197'); |
| 3038 | $foster_parent_element->insert_before | $foster_parent_element = $self->{open_elements}->[$_ - 1]->[0]; |
| 3039 | ($self->{document}->create_text_node ($token->{data}), | $prev_sibling = $foster_parent_element->last_child; |
| 3040 | $next_sibling); | # |
| 3041 | } | } |
| 3042 | last OE; | |
| 3043 | } | |
| 3044 | } # OE | |
| 3045 | $foster_parent_element = $self->{open_elements}->[0]->[0] and | |
| 3046 | $prev_sibling = $foster_parent_element->last_child | |
| 3047 | unless defined $foster_parent_element; | |
| 3048 | undef $prev_sibling unless $open_tables->[-1]->[2]; # ~node inserted | |
| 3049 | if (defined $prev_sibling and | |
| 3050 | $prev_sibling->node_type == 3) { | |
| 3051 | !!!cp ('t198'); | |
| 3052 | $prev_sibling->manakai_append_text ($token->{data}); | |
| 3053 | } else { | |
| 3054 | !!!cp ('t199'); | |
| 3055 | $foster_parent_element->insert_before | |
| 3056 | ($self->{document}->create_text_node ($token->{data}), | |
| 3057 | $next_sibling); | |
| 3058 | } | |
| 3059 | $open_tables->[-1]->[1] = 1; # tainted | $open_tables->[-1]->[1] = 1; # tainted |
| 3060 | $open_tables->[-1]->[2] = 1; # ~node inserted | |
| 3061 | } else { | } else { |
| 3062 | ## NOTE: Fragment case or in a foster parent'ed element | |
| 3063 | ## (e.g. |<table><span>a|). In fragment case, whether the | |
| 3064 | ## character is appended to existing node or a new node is | |
| 3065 | ## created is irrelevant, since the foster parent'ed nodes | |
| 3066 | ## are discarded and fragment parsing does not invoke any | |
| 3067 | ## script. | |
| 3068 | !!!cp ('t200'); | !!!cp ('t200'); |
| 3069 | $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data}); | $self->{open_elements}->[-1]->[0]->manakai_append_text |
| 3070 | ($token->{data}); | |
| 3071 | } | } |
| 3072 | ||
| 3073 | !!!next-token; | !!!next-token; |
| 3074 | redo B; | next B; |
| 3075 | } elsif ($token->{type} == START_TAG_TOKEN) { | } elsif ($token->{type} == START_TAG_TOKEN) { |
| 3076 | if ({ | if ({ |
| 3077 | tr => ($self->{insertion_mode} != IN_ROW_IM), | tr => (($self->{insertion_mode} & IM_MASK) != IN_ROW_IM), |
| 3078 | th => 1, td => 1, | th => 1, td => 1, |
| 3079 | }->{$token->{tag_name}}) { | }->{$token->{tag_name}}) { |
| 3080 | if ($self->{insertion_mode} == IN_TABLE_IM) { | if (($self->{insertion_mode} & IM_MASK) == IN_TABLE_IM) { |
| 3081 | ## Clear back to table context | ## Clear back to table context |
| 3082 | while ($self->{open_elements}->[-1]->[1] ne 'table' and | while (not ($self->{open_elements}->[-1]->[1] |
| 3083 | $self->{open_elements}->[-1]->[1] ne 'html') { | & TABLE_SCOPING_EL)) { |
| 3084 | !!!cp ('t201'); | !!!cp ('t201'); |
| 3085 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 3086 | } | } |
| 3087 | ||
| 3088 | !!!insert-element ('tbody'); | !!!insert-element ('tbody',, $token); |
| 3089 | $self->{insertion_mode} = IN_TABLE_BODY_IM; | $self->{insertion_mode} = IN_TABLE_BODY_IM; |
| 3090 | ## reprocess in the "in table body" insertion mode... | ## reprocess in the "in table body" insertion mode... |
| 3091 | } | } |
| 3092 | ||
| 3093 | if ($self->{insertion_mode} == IN_TABLE_BODY_IM) { | if (($self->{insertion_mode} & IM_MASK) == IN_TABLE_BODY_IM) { |
| 3094 | unless ($token->{tag_name} eq 'tr') { | unless ($token->{tag_name} eq 'tr') { |
| 3095 | !!!cp ('t202'); | !!!cp ('t202'); |
| 3096 | !!!parse-error (type => 'missing start tag:tr'); | !!!parse-error (type => 'missing start tag:tr', token => $token); |
| 3097 | } | } |
| 3098 | ||
| 3099 | ## Clear back to table body context | ## Clear back to table body context |
| 3100 | while (not { | while (not ($self->{open_elements}->[-1]->[1] |
| 3101 | tbody => 1, tfoot => 1, thead => 1, html => 1, | & TABLE_ROWS_SCOPING_EL)) { |
| 3102 | }->{$self->{open_elements}->[-1]->[1]}) { | !!!cp ('t203'); |
| 3103 | !!!cp ('t203'); | ## ISSUE: Can this case be reached? |
| 3104 | ## ISSUE: Can this case be reached? | pop @{$self->{open_elements}}; |
| 3105 | pop @{$self->{open_elements}}; | } |
| } | ||
| 3106 | ||
| 3107 | $self->{insertion_mode} = IN_ROW_IM; | $self->{insertion_mode} = IN_ROW_IM; |
| 3108 | if ($token->{tag_name} eq 'tr') { | if ($token->{tag_name} eq 'tr') { |
| 3109 | !!!cp ('t204'); | !!!cp ('t204'); |
| 3110 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); |
| 3111 | !!!next-token; | $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted |
| 3112 | redo B; | !!!nack ('t204'); |
| 3113 | } else { | !!!next-token; |
| 3114 | !!!cp ('t205'); | next B; |
| 3115 | !!!insert-element ('tr'); | } else { |
| 3116 | ## reprocess in the "in row" insertion mode | !!!cp ('t205'); |
| 3117 | } | !!!insert-element ('tr',, $token); |
| 3118 | } else { | ## reprocess in the "in row" insertion mode |
| 3119 | !!!cp ('t206'); | } |
| 3120 | } | } else { |
| 3121 | !!!cp ('t206'); | |
| 3122 | } | |
| 3123 | ||
| 3124 | ## Clear back to table row context | ## Clear back to table row context |
| 3125 | while (not { | while (not ($self->{open_elements}->[-1]->[1] |
| 3126 | tr => 1, html => 1, | & TABLE_ROW_SCOPING_EL)) { |
| }->{$self->{open_elements}->[-1]->[1]}) { | ||
| 3127 | !!!cp ('t207'); | !!!cp ('t207'); |
| 3128 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 3129 | } | } |
| 3130 | ||
| 3131 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); |
| 3132 | $self->{insertion_mode} = IN_CELL_IM; | $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted |
| 3133 | $self->{insertion_mode} = IN_CELL_IM; | |
| 3134 | ||
| 3135 | push @$active_formatting_elements, ['#marker', '']; | push @$active_formatting_elements, ['#marker', '']; |
| 3136 | ||
| 3137 | !!!nack ('t207.1'); | |
| 3138 | !!!next-token; | |
| 3139 | next B; | |
| 3140 | } elsif ({ | |
| 3141 | caption => 1, col => 1, colgroup => 1, | |
| 3142 | tbody => 1, tfoot => 1, thead => 1, | |
| 3143 | tr => 1, # $self->{insertion_mode} == IN_ROW_IM | |
| 3144 | }->{$token->{tag_name}}) { | |
| 3145 | if (($self->{insertion_mode} & IM_MASK) == IN_ROW_IM) { | |
| 3146 | ## As if </tr> | |
| 3147 | ## have an element in table scope | |
| 3148 | my $i; | |
| 3149 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | |
| 3150 | my $node = $self->{open_elements}->[$_]; | |
| 3151 | if ($node->[1] == TABLE_ROW_EL) { | |
| 3152 | !!!cp ('t208'); | |
| 3153 | $i = $_; | |
| 3154 | last INSCOPE; | |
| 3155 | } elsif ($node->[1] & TABLE_SCOPING_EL) { | |
| 3156 | !!!cp ('t209'); | |
| 3157 | last INSCOPE; | |
| 3158 | } | |
| 3159 | } # INSCOPE | |
| 3160 | unless (defined $i) { | |
| 3161 | !!!cp ('t210'); | |
| 3162 | ## TODO: This type is wrong. | |
| 3163 | !!!parse-error (type => 'unmacthed end tag', | |
| 3164 | text => $token->{tag_name}, token => $token); | |
| 3165 | ## Ignore the token | |
| 3166 | !!!nack ('t210.1'); | |
| 3167 | !!!next-token; | !!!next-token; |
| 3168 | redo B; | next B; |
| 3169 | } 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}); | ||
| ## Ignore the token | ||
| !!!next-token; | ||
| redo B; | ||
| } | ||
| 3170 | ||
| 3171 | ## Clear back to table row context | ## Clear back to table row context |
| 3172 | while (not { | while (not ($self->{open_elements}->[-1]->[1] |
| 3173 | tr => 1, html => 1, | & TABLE_ROW_SCOPING_EL)) { |
| }->{$self->{open_elements}->[-1]->[1]}) { | ||
| 3174 | !!!cp ('t211'); | !!!cp ('t211'); |
| 3175 | ## ISSUE: Can this case be reached? | ## ISSUE: Can this case be reached? |
| 3176 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| # | Line 4456 sub _tree_construction_main ($) { | Line 3181 sub _tree_construction_main ($) { |
| 3181 | if ($token->{tag_name} eq 'tr') { | if ($token->{tag_name} eq 'tr') { |
| 3182 | !!!cp ('t212'); | !!!cp ('t212'); |
| 3183 | ## reprocess | ## reprocess |
| 3184 | redo B; | !!!ack-later; |
| 3185 | next B; | |
| 3186 | } else { | } else { |
| 3187 | !!!cp ('t213'); | !!!cp ('t213'); |
| 3188 | ## reprocess in the "in table body" insertion mode... | ## reprocess in the "in table body" insertion mode... |
| 3189 | } | } |
| 3190 | } | } |
| 3191 | ||
| 3192 | if ($self->{insertion_mode} == IN_TABLE_BODY_IM) { | if (($self->{insertion_mode} & IM_MASK) == IN_TABLE_BODY_IM) { |
| 3193 | ## have an element in table scope | ## have an element in table scope |
| 3194 | my $i; | my $i; |
| 3195 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3196 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 3197 | if ({ | if ($node->[1] == TABLE_ROW_GROUP_EL) { |
| tbody => 1, thead => 1, tfoot => 1, | ||
| }->{$node->[1]}) { | ||
| 3198 | !!!cp ('t214'); | !!!cp ('t214'); |
| 3199 | $i = $_; | $i = $_; |
| 3200 | last INSCOPE; | last INSCOPE; |
| 3201 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 3202 | !!!cp ('t215'); | !!!cp ('t215'); |
| 3203 | last INSCOPE; | last INSCOPE; |
| 3204 | } | } |
| 3205 | } # INSCOPE | } # INSCOPE |
| 3206 | unless (defined $i) { | unless (defined $i) { |
| 3207 | !!!cp ('t216'); | !!!cp ('t216'); |
| 3208 | ## TODO: This erorr type ios wrong. | ## TODO: This erorr type is wrong. |
| 3209 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 3210 | text => $token->{tag_name}, token => $token); | |
| 3211 | ## Ignore the token | ## Ignore the token |
| 3212 | !!!nack ('t216.1'); | |
| 3213 | !!!next-token; | !!!next-token; |
| 3214 | redo B; | next B; |
| 3215 | } | } |
| 3216 | ||
| 3217 | ## Clear back to table body context | ## Clear back to table body context |
| 3218 | while (not { | while (not ($self->{open_elements}->[-1]->[1] |
| 3219 | tbody => 1, tfoot => 1, thead => 1, html => 1, | & TABLE_ROWS_SCOPING_EL)) { |
| }->{$self->{open_elements}->[-1]->[1]}) { | ||
| 3220 | !!!cp ('t217'); | !!!cp ('t217'); |
| 3221 | ## ISSUE: Can this state be reached? | ## ISSUE: Can this state be reached? |
| 3222 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| # | Line 4513 sub _tree_construction_main ($) { | Line 3236 sub _tree_construction_main ($) { |
| 3236 | !!!cp ('t218'); | !!!cp ('t218'); |
| 3237 | } | } |
| 3238 | ||
| 3239 | if ($token->{tag_name} eq 'col') { | if ($token->{tag_name} eq 'col') { |
| 3240 | ## Clear back to table context | ## Clear back to table context |
| 3241 | while ($self->{open_elements}->[-1]->[1] ne 'table' and | while (not ($self->{open_elements}->[-1]->[1] |
| 3242 | $self->{open_elements}->[-1]->[1] ne 'html') { | & TABLE_SCOPING_EL)) { |
| 3243 | !!!cp ('t219'); | !!!cp ('t219'); |
| 3244 | ## ISSUE: Can this state be reached? | ## ISSUE: Can this state be reached? |
| 3245 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 3246 | } | } |
| 3247 | ||
| 3248 | !!!insert-element ('colgroup'); | !!!insert-element ('colgroup',, $token); |
| 3249 | $self->{insertion_mode} = IN_COLUMN_GROUP_IM; | $self->{insertion_mode} = IN_COLUMN_GROUP_IM; |
| 3250 | ## reprocess | ## reprocess |
| 3251 | redo B; | $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted |
| 3252 | } elsif ({ | !!!ack-later; |
| 3253 | caption => 1, | next B; |
| 3254 | colgroup => 1, | } elsif ({ |
| 3255 | tbody => 1, tfoot => 1, thead => 1, | caption => 1, |
| 3256 | }->{$token->{tag_name}}) { | colgroup => 1, |
| 3257 | ## Clear back to table context | tbody => 1, tfoot => 1, thead => 1, |
| 3258 | while ($self->{open_elements}->[-1]->[1] ne 'table' and | }->{$token->{tag_name}}) { |
| 3259 | $self->{open_elements}->[-1]->[1] ne 'html') { | ## Clear back to table context |
| 3260 | while (not ($self->{open_elements}->[-1]->[1] | |
| 3261 | & TABLE_SCOPING_EL)) { | |
| 3262 | !!!cp ('t220'); | !!!cp ('t220'); |
| 3263 | ## ISSUE: Can this state be reached? | ## ISSUE: Can this state be reached? |
| 3264 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 3265 | } | } |
| 3266 | ||
| 3267 | push @$active_formatting_elements, ['#marker', ''] | push @$active_formatting_elements, ['#marker', ''] |
| 3268 | if $token->{tag_name} eq 'caption'; | if $token->{tag_name} eq 'caption'; |
| 3269 | ||
| 3270 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); |
| 3271 | $self->{insertion_mode} = { | $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted |
| 3272 | caption => IN_CAPTION_IM, | $self->{insertion_mode} = { |
| 3273 | colgroup => IN_COLUMN_GROUP_IM, | caption => IN_CAPTION_IM, |
| 3274 | tbody => IN_TABLE_BODY_IM, | colgroup => IN_COLUMN_GROUP_IM, |
| 3275 | tfoot => IN_TABLE_BODY_IM, | tbody => IN_TABLE_BODY_IM, |
| 3276 | thead => IN_TABLE_BODY_IM, | tfoot => IN_TABLE_BODY_IM, |
| 3277 | }->{$token->{tag_name}}; | thead => IN_TABLE_BODY_IM, |
| 3278 | !!!next-token; | }->{$token->{tag_name}}; |
| 3279 | redo B; | !!!next-token; |
| 3280 | } else { | !!!nack ('t220.1'); |
| 3281 | die "$0: in table: <>: $token->{tag_name}"; | next B; |
| 3282 | } | } else { |
| 3283 | die "$0: in table: <>: $token->{tag_name}"; | |
| 3284 | } | |
| 3285 | } elsif ($token->{tag_name} eq 'table') { | } elsif ($token->{tag_name} eq 'table') { |
| 3286 | !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]); | !!!parse-error (type => 'not closed', |
| 3287 | text => $self->{open_elements}->[-1]->[0] | |
| 3288 | ->manakai_local_name, | |
| 3289 | token => $token); | |
| 3290 | ||
| 3291 | ## As if </table> | ## As if </table> |
| 3292 | ## have a table element in table scope | ## have a table element in table scope |
| 3293 | my $i; | my $i; |
| 3294 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3295 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 3296 | if ($node->[1] eq 'table') { | if ($node->[1] == TABLE_EL) { |
| 3297 | !!!cp ('t221'); | !!!cp ('t221'); |
| 3298 | $i = $_; | $i = $_; |
| 3299 | last INSCOPE; | last INSCOPE; |
| 3300 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| #table => 1, | ||
| html => 1, | ||
| }->{$node->[1]}) { | ||
| 3301 | !!!cp ('t222'); | !!!cp ('t222'); |
| 3302 | last INSCOPE; | last INSCOPE; |
| 3303 | } | } |
| # | Line 4578 sub _tree_construction_main ($) { | Line 3305 sub _tree_construction_main ($) { |
| 3305 | unless (defined $i) { | unless (defined $i) { |
| 3306 | !!!cp ('t223'); | !!!cp ('t223'); |
| 3307 | ## TODO: The following is wrong, maybe. | ## TODO: The following is wrong, maybe. |
| 3308 | !!!parse-error (type => 'unmatched end tag:table'); | !!!parse-error (type => 'unmatched end tag', text => 'table', |
| 3309 | token => $token); | |
| 3310 | ## Ignore tokens </table><table> | ## Ignore tokens </table><table> |
| 3311 | !!!nack ('t223.1'); | |
| 3312 | !!!next-token; | !!!next-token; |
| 3313 | redo B; | next B; |
| 3314 | } | } |
| 3315 | ||
| 3316 | ## TODO: Followings are removed from the latest spec. | ## TODO: Followings are removed from the latest spec. |
| 3317 | ## generate implied end tags | ## generate implied end tags |
| 3318 | while ({ | while ($self->{open_elements}->[-1]->[1] & END_TAG_OPTIONAL_EL) { |
| dd => 1, dt => 1, li => 1, p => 1, | ||
| }->{$self->{open_elements}->[-1]->[1]}) { | ||
| 3319 | !!!cp ('t224'); | !!!cp ('t224'); |
| 3320 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 3321 | } | } |
| 3322 | ||
| 3323 | if ($self->{open_elements}->[-1]->[1] ne 'table') { | unless ($self->{open_elements}->[-1]->[1] == TABLE_EL) { |
| 3324 | !!!cp ('t225'); | !!!cp ('t225'); |
| 3325 | ## ISSUE: Can this case be reached? | ## NOTE: |<table><tr><table>| |
| 3326 | !!!parse-error (type => 'not closed:'.$self->{open_elements}->[-1]->[1]); | !!!parse-error (type => 'not closed', |
| 3327 | text => $self->{open_elements}->[-1]->[0] | |
| 3328 | ->manakai_local_name, | |
| 3329 | token => $token); | |
| 3330 | } else { | } else { |
| 3331 | !!!cp ('t226'); | !!!cp ('t226'); |
| 3332 | } | } |
| # | Line 4606 sub _tree_construction_main ($) { | Line 3336 sub _tree_construction_main ($) { |
| 3336 | ||
| 3337 | $self->_reset_insertion_mode; | $self->_reset_insertion_mode; |
| 3338 | ||
| 3339 | ## reprocess | ## reprocess |
| 3340 | redo B; | !!!ack-later; |
| 3341 | next B; | |
| 3342 | } elsif ($token->{tag_name} eq 'style') { | } elsif ($token->{tag_name} eq 'style') { |
| 3343 | if (not $open_tables->[-1]->[1]) { # tainted | if (not $open_tables->[-1]->[1]) { # tainted |
| 3344 | !!!cp ('t227.8'); | !!!cp ('t227.8'); |
| 3345 | ## NOTE: This is a "as if in head" code clone. | ## NOTE: This is a "as if in head" code clone. |
| 3346 | $parse_rcdata->(CDATA_CONTENT_MODEL); | $parse_rcdata->(CDATA_CONTENT_MODEL); |
| 3347 | redo B; | $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted |
| 3348 | next B; | |
| 3349 | } else { | } else { |
| 3350 | !!!cp ('t227.7'); | !!!cp ('t227.7'); |
| 3351 | # | # |
| # | Line 4623 sub _tree_construction_main ($) { | Line 3355 sub _tree_construction_main ($) { |
| 3355 | !!!cp ('t227.6'); | !!!cp ('t227.6'); |
| 3356 | ## NOTE: This is a "as if in head" code clone. | ## NOTE: This is a "as if in head" code clone. |
| 3357 | $script_start_tag->(); | $script_start_tag->(); |
| 3358 | redo B; | $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted |
| 3359 | next B; | |
| 3360 | } else { | } else { |
| 3361 | !!!cp ('t227.5'); | !!!cp ('t227.5'); |
| 3362 | # | # |
| # | Line 4634 sub _tree_construction_main ($) { | Line 3367 sub _tree_construction_main ($) { |
| 3367 | my $type = lc $token->{attributes}->{type}->{value}; | my $type = lc $token->{attributes}->{type}->{value}; |
| 3368 | if ($type eq 'hidden') { | if ($type eq 'hidden') { |
| 3369 | !!!cp ('t227.3'); | !!!cp ('t227.3'); |
| 3370 | !!!parse-error (type => 'in table:'.$token->{tag_name}); | !!!parse-error (type => 'in table', |
| 3371 | text => $token->{tag_name}, token => $token); | |
| 3372 | ||
| 3373 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); |
| 3374 | $open_tables->[-1]->[2] = 0 if @$open_tables; # ~node inserted | |
| 3375 | ||
| 3376 | ## TODO: form element pointer | ## TODO: form element pointer |
| 3377 | ||
| 3378 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 3379 | ||
| 3380 | !!!next-token; | !!!next-token; |
| 3381 | redo B; | !!!ack ('t227.2.1'); |
| 3382 | next B; | |
| 3383 | } else { | } else { |
| 3384 | !!!cp ('t227.2'); | !!!cp ('t227.2'); |
| 3385 | # | # |
| # | Line 4661 sub _tree_construction_main ($) { | Line 3397 sub _tree_construction_main ($) { |
| 3397 | # | # |
| 3398 | } | } |
| 3399 | ||
| 3400 | !!!parse-error (type => 'in table:'.$token->{tag_name}); | !!!parse-error (type => 'in table', text => $token->{tag_name}, |
| 3401 | token => $token); | |
| 3402 | ||
| 3403 | $insert = $insert_to_foster; | $insert = $insert_to_foster; |
| 3404 | # | # |
| 3405 | } elsif ($token->{type} == END_TAG_TOKEN) { | } elsif ($token->{type} == END_TAG_TOKEN) { |
| 3406 | if ($token->{tag_name} eq 'tr' and | if ($token->{tag_name} eq 'tr' and |
| 3407 | $self->{insertion_mode} == IN_ROW_IM) { | ($self->{insertion_mode} & IM_MASK) == IN_ROW_IM) { |
| 3408 | ## have an element in table scope | ## have an element in table scope |
| 3409 | my $i; | my $i; |
| 3410 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3411 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 3412 | if ($node->[1] eq $token->{tag_name}) { | if ($node->[1] == TABLE_ROW_EL) { |
| 3413 | !!!cp ('t228'); | !!!cp ('t228'); |
| 3414 | $i = $_; | $i = $_; |
| 3415 | last INSCOPE; | last INSCOPE; |
| 3416 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 3417 | !!!cp ('t229'); | !!!cp ('t229'); |
| 3418 | last INSCOPE; | last INSCOPE; |
| 3419 | } | } |
| 3420 | } # INSCOPE | } # INSCOPE |
| 3421 | unless (defined $i) { | unless (defined $i) { |
| 3422 | !!!cp ('t230'); | !!!cp ('t230'); |
| 3423 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 3424 | text => $token->{tag_name}, token => $token); | |
| 3425 | ## Ignore the token | ## Ignore the token |
| 3426 | !!!nack ('t230.1'); | |
| 3427 | !!!next-token; | !!!next-token; |
| 3428 | redo B; | next B; |
| 3429 | } else { | } else { |
| 3430 | !!!cp ('t232'); | !!!cp ('t232'); |
| 3431 | } | } |
| 3432 | ||
| 3433 | ## Clear back to table row context | ## Clear back to table row context |
| 3434 | while (not { | while (not ($self->{open_elements}->[-1]->[1] |
| 3435 | tr => 1, html => 1, | & TABLE_ROW_SCOPING_EL)) { |
| }->{$self->{open_elements}->[-1]->[1]}) { | ||
| 3436 | !!!cp ('t231'); | !!!cp ('t231'); |
| 3437 | ## ISSUE: Can this state be reached? | ## ISSUE: Can this state be reached? |
| 3438 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| # | Line 4705 sub _tree_construction_main ($) { | Line 3441 sub _tree_construction_main ($) { |
| 3441 | pop @{$self->{open_elements}}; # tr | pop @{$self->{open_elements}}; # tr |
| 3442 | $self->{insertion_mode} = IN_TABLE_BODY_IM; | $self->{insertion_mode} = IN_TABLE_BODY_IM; |
| 3443 | !!!next-token; | !!!next-token; |
| 3444 | redo B; | !!!nack ('t231.1'); |
| 3445 | next B; | |
| 3446 | } elsif ($token->{tag_name} eq 'table') { | } elsif ($token->{tag_name} eq 'table') { |
| 3447 | if ($self->{insertion_mode} == IN_ROW_IM) { | if (($self->{insertion_mode} & IM_MASK) == IN_ROW_IM) { |
| 3448 | ## As if </tr> | ## As if </tr> |
| 3449 | ## have an element in table scope | ## have an element in table scope |
| 3450 | my $i; | my $i; |
| 3451 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3452 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 3453 | if ($node->[1] eq 'tr') { | if ($node->[1] == TABLE_ROW_EL) { |
| 3454 | !!!cp ('t233'); | !!!cp ('t233'); |
| 3455 | $i = $_; | $i = $_; |
| 3456 | last INSCOPE; | last INSCOPE; |
| 3457 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 3458 | !!!cp ('t234'); | !!!cp ('t234'); |
| 3459 | last INSCOPE; | last INSCOPE; |
| 3460 | } | } |
| # | Line 4727 sub _tree_construction_main ($) { | Line 3462 sub _tree_construction_main ($) { |
| 3462 | unless (defined $i) { | unless (defined $i) { |
| 3463 | !!!cp ('t235'); | !!!cp ('t235'); |
| 3464 | ## TODO: The following is wrong. | ## TODO: The following is wrong. |
| 3465 | !!!parse-error (type => 'unmatched end tag:'.$token->{type}); | !!!parse-error (type => 'unmatched end tag', |
| 3466 | text => $token->{type}, token => $token); | |
| 3467 | ## Ignore the token | ## Ignore the token |
| 3468 | !!!nack ('t236.1'); | |
| 3469 | !!!next-token; | !!!next-token; |
| 3470 | redo B; | next B; |
| 3471 | } | } |
| 3472 | ||
| 3473 | ## Clear back to table row context | ## Clear back to table row context |
| 3474 | while (not { | while (not ($self->{open_elements}->[-1]->[1] |
| 3475 | tr => 1, html => 1, | & TABLE_ROW_SCOPING_EL)) { |
| }->{$self->{open_elements}->[-1]->[1]}) { | ||
| 3476 | !!!cp ('t236'); | !!!cp ('t236'); |
| 3477 | ## ISSUE: Can this state be reached? | ## ISSUE: Can this state be reached? |
| 3478 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| # | Line 4747 sub _tree_construction_main ($) { | Line 3483 sub _tree_construction_main ($) { |
| 3483 | ## reprocess in the "in table body" insertion mode... | ## reprocess in the "in table body" insertion mode... |
| 3484 | } | } |
| 3485 | ||
| 3486 | if ($self->{insertion_mode} == IN_TABLE_BODY_IM) { | if (($self->{insertion_mode} & IM_MASK) == IN_TABLE_BODY_IM) { |
| 3487 | ## have an element in table scope | ## have an element in table scope |
| 3488 | my $i; | my $i; |
| 3489 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3490 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 3491 | if ({ | if ($node->[1] == TABLE_ROW_GROUP_EL) { |
| tbody => 1, thead => 1, tfoot => 1, | ||
| }->{$node->[1]}) { | ||
| 3492 | !!!cp ('t237'); | !!!cp ('t237'); |
| 3493 | $i = $_; | $i = $_; |
| 3494 | last INSCOPE; | last INSCOPE; |
| 3495 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 3496 | !!!cp ('t238'); | !!!cp ('t238'); |
| 3497 | last INSCOPE; | last INSCOPE; |
| 3498 | } | } |
| 3499 | } # INSCOPE | } # INSCOPE |
| 3500 | unless (defined $i) { | unless (defined $i) { |
| 3501 | !!!cp ('t239'); | !!!cp ('t239'); |
| 3502 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 3503 | text => $token->{tag_name}, token => $token); | |
| 3504 | ## Ignore the token | ## Ignore the token |
| 3505 | !!!nack ('t239.1'); | |
| 3506 | !!!next-token; | !!!next-token; |
| 3507 | redo B; | next B; |
| 3508 | } | } |
| 3509 | ||
| 3510 | ## Clear back to table body context | ## Clear back to table body context |
| 3511 | while (not { | while (not ($self->{open_elements}->[-1]->[1] |
| 3512 | tbody => 1, tfoot => 1, thead => 1, html => 1, | & TABLE_ROWS_SCOPING_EL)) { |
| }->{$self->{open_elements}->[-1]->[1]}) { | ||
| 3513 | !!!cp ('t240'); | !!!cp ('t240'); |
| 3514 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 3515 | } | } |
| # | Line 4802 sub _tree_construction_main ($) { | Line 3535 sub _tree_construction_main ($) { |
| 3535 | my $i; | my $i; |
| 3536 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3537 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 3538 | if ($node->[1] eq $token->{tag_name}) { | if ($node->[1] == TABLE_EL) { |
| 3539 | !!!cp ('t241'); | !!!cp ('t241'); |
| 3540 | $i = $_; | $i = $_; |
| 3541 | last INSCOPE; | last INSCOPE; |
| 3542 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 3543 | !!!cp ('t242'); | !!!cp ('t242'); |
| 3544 | last INSCOPE; | last INSCOPE; |
| 3545 | } | } |
| 3546 | } # INSCOPE | } # INSCOPE |
| 3547 | unless (defined $i) { | unless (defined $i) { |
| 3548 | !!!cp ('t243'); | !!!cp ('t243'); |
| 3549 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 3550 | text => $token->{tag_name}, token => $token); | |
| 3551 | ## Ignore the token | ## Ignore the token |
| 3552 | !!!nack ('t243.1'); | |
| 3553 | !!!next-token; | !!!next-token; |
| 3554 | redo B; | next B; |
| 3555 | } | } |
| 3556 | ||
| 3557 | splice @{$self->{open_elements}}, $i; | splice @{$self->{open_elements}}, $i; |
| # | Line 4827 sub _tree_construction_main ($) { | Line 3560 sub _tree_construction_main ($) { |
| 3560 | $self->_reset_insertion_mode; | $self->_reset_insertion_mode; |
| 3561 | ||
| 3562 | !!!next-token; | !!!next-token; |
| 3563 | redo B; | next B; |
| 3564 | } elsif ({ | } elsif ({ |
| 3565 | tbody => 1, tfoot => 1, thead => 1, | tbody => 1, tfoot => 1, thead => 1, |
| 3566 | }->{$token->{tag_name}} and | }->{$token->{tag_name}} and |
| 3567 | $self->{insertion_mode} & ROW_IMS) { | $self->{insertion_mode} & ROW_IMS) { |
| 3568 | if ($self->{insertion_mode} == IN_ROW_IM) { | if (($self->{insertion_mode} & IM_MASK) == IN_ROW_IM) { |
| 3569 | ## have an element in table scope | ## have an element in table scope |
| 3570 | my $i; | my $i; |
| 3571 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3572 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 3573 | if ($node->[1] eq $token->{tag_name}) { | if ($node->[0]->manakai_local_name eq $token->{tag_name}) { |
| 3574 | !!!cp ('t247'); | !!!cp ('t247'); |
| 3575 | $i = $_; | $i = $_; |
| 3576 | last INSCOPE; | last INSCOPE; |
| 3577 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 3578 | !!!cp ('t248'); | !!!cp ('t248'); |
| 3579 | last INSCOPE; | last INSCOPE; |
| 3580 | } | } |
| 3581 | } # INSCOPE | } # INSCOPE |
| 3582 | unless (defined $i) { | unless (defined $i) { |
| 3583 | !!!cp ('t249'); | !!!cp ('t249'); |
| 3584 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 3585 | text => $token->{tag_name}, token => $token); | |
| 3586 | ## Ignore the token | ## Ignore the token |
| 3587 | !!!nack ('t249.1'); | |
| 3588 | !!!next-token; | !!!next-token; |
| 3589 | redo B; | next B; |
| 3590 | } | } |
| 3591 | ||
| 3592 | ## As if </tr> | ## As if </tr> |
| # | Line 4861 sub _tree_construction_main ($) { | Line 3594 sub _tree_construction_main ($) { |
| 3594 | my $i; | my $i; |
| 3595 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3596 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 3597 | if ($node->[1] eq 'tr') { | if ($node->[1] == TABLE_ROW_EL) { |
| 3598 | !!!cp ('t250'); | !!!cp ('t250'); |
| 3599 | $i = $_; | $i = $_; |
| 3600 | last INSCOPE; | last INSCOPE; |
| 3601 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 3602 | !!!cp ('t251'); | !!!cp ('t251'); |
| 3603 | last INSCOPE; | last INSCOPE; |
| 3604 | } | } |
| 3605 | } # INSCOPE | } # INSCOPE |
| 3606 | unless (defined $i) { | unless (defined $i) { |
| 3607 | !!!cp ('t252'); | !!!cp ('t252'); |
| 3608 | !!!parse-error (type => 'unmatched end tag:tr'); | !!!parse-error (type => 'unmatched end tag', |
| 3609 | text => 'tr', token => $token); | |
| 3610 | ## Ignore the token | ## Ignore the token |
| 3611 | !!!nack ('t252.1'); | |
| 3612 | !!!next-token; | !!!next-token; |
| 3613 | redo B; | next B; |
| 3614 | } | } |
| 3615 | ||
| 3616 | ## Clear back to table row context | ## Clear back to table row context |
| 3617 | while (not { | while (not ($self->{open_elements}->[-1]->[1] |
| 3618 | tr => 1, html => 1, | & TABLE_ROW_SCOPING_EL)) { |
| }->{$self->{open_elements}->[-1]->[1]}) { | ||
| 3619 | !!!cp ('t253'); | !!!cp ('t253'); |
| 3620 | ## ISSUE: Can this case be reached? | ## ISSUE: Can this case be reached? |
| 3621 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| # | Line 4898 sub _tree_construction_main ($) { | Line 3630 sub _tree_construction_main ($) { |
| 3630 | my $i; | my $i; |
| 3631 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3632 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 3633 | if ($node->[1] eq $token->{tag_name}) { | if ($node->[0]->manakai_local_name eq $token->{tag_name}) { |
| 3634 | !!!cp ('t254'); | !!!cp ('t254'); |
| 3635 | $i = $_; | $i = $_; |
| 3636 | last INSCOPE; | last INSCOPE; |
| 3637 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 3638 | !!!cp ('t255'); | !!!cp ('t255'); |
| 3639 | last INSCOPE; | last INSCOPE; |
| 3640 | } | } |
| 3641 | } # INSCOPE | } # INSCOPE |
| 3642 | unless (defined $i) { | unless (defined $i) { |
| 3643 | !!!cp ('t256'); | !!!cp ('t256'); |
| 3644 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 3645 | text => $token->{tag_name}, token => $token); | |
| 3646 | ## Ignore the token | ## Ignore the token |
| 3647 | !!!nack ('t256.1'); | |
| 3648 | !!!next-token; | !!!next-token; |
| 3649 | redo B; | next B; |
| 3650 | } | } |
| 3651 | ||
| 3652 | ## Clear back to table body context | ## Clear back to table body context |
| 3653 | while (not { | while (not ($self->{open_elements}->[-1]->[1] |
| 3654 | tbody => 1, tfoot => 1, thead => 1, html => 1, | & TABLE_ROWS_SCOPING_EL)) { |
| }->{$self->{open_elements}->[-1]->[1]}) { | ||
| 3655 | !!!cp ('t257'); | !!!cp ('t257'); |
| 3656 | ## ISSUE: Can this case be reached? | ## ISSUE: Can this case be reached? |
| 3657 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| # | Line 4928 sub _tree_construction_main ($) { | Line 3659 sub _tree_construction_main ($) { |
| 3659 | ||
| 3660 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 3661 | $self->{insertion_mode} = IN_TABLE_IM; | $self->{insertion_mode} = IN_TABLE_IM; |
| 3662 | !!!nack ('t257.1'); | |
| 3663 | !!!next-token; | !!!next-token; |
| 3664 | redo B; | next B; |
| 3665 | } elsif ({ | } elsif ({ |
| 3666 | body => 1, caption => 1, col => 1, colgroup => 1, | body => 1, caption => 1, col => 1, colgroup => 1, |
| 3667 | html => 1, td => 1, th => 1, | html => 1, td => 1, th => 1, |
| 3668 | tr => 1, # $self->{insertion_mode} == IN_ROW_IM | tr => 1, # $self->{insertion_mode} == IN_ROW_IM |
| 3669 | tbody => 1, tfoot => 1, thead => 1, # $self->{insertion_mode} == IN_TABLE_IM | tbody => 1, tfoot => 1, thead => 1, # $self->{insertion_mode} == IN_TABLE_IM |
| 3670 | }->{$token->{tag_name}}) { | }->{$token->{tag_name}}) { |
| 3671 | !!!cp ('t258'); | !!!cp ('t258'); |
| 3672 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 3673 | ## Ignore the token | text => $token->{tag_name}, token => $token); |
| 3674 | !!!next-token; | ## Ignore the token |
| 3675 | redo B; | !!!nack ('t258.1'); |
| 3676 | !!!next-token; | |
| 3677 | next B; | |
| 3678 | } else { | } else { |
| 3679 | !!!cp ('t259'); | !!!cp ('t259'); |
| 3680 | !!!parse-error (type => 'in table:/'.$token->{tag_name}); | !!!parse-error (type => 'in table:/', |
| 3681 | text => $token->{tag_name}, token => $token); | |
| 3682 | ||
| 3683 | $insert = $insert_to_foster; | $insert = $insert_to_foster; |
| 3684 | # | # |
| 3685 | } | } |
| 3686 | } elsif ($token->{type} == END_OF_FILE_TOKEN) { | } elsif ($token->{type} == END_OF_FILE_TOKEN) { |
| 3687 | unless ($self->{open_elements}->[-1]->[1] eq 'html' and | unless ($self->{open_elements}->[-1]->[1] == HTML_EL and |
| 3688 | @{$self->{open_elements}} == 1) { # redundant, maybe | @{$self->{open_elements}} == 1) { # redundant, maybe |
| 3689 | !!!parse-error (type => 'in body:#eof'); | !!!parse-error (type => 'in body:#eof', token => $token); |
| 3690 | !!!cp ('t259.1'); | !!!cp ('t259.1'); |
| 3691 | # | # |
| 3692 | } else { | } else { |
| # | Line 4964 sub _tree_construction_main ($) { | Line 3699 sub _tree_construction_main ($) { |
| 3699 | } else { | } else { |
| 3700 | die "$0: $token->{type}: Unknown token type"; | die "$0: $token->{type}: Unknown token type"; |
| 3701 | } | } |
| 3702 | } elsif ($self->{insertion_mode} == IN_COLUMN_GROUP_IM) { | } elsif (($self->{insertion_mode} & IM_MASK) == IN_COLUMN_GROUP_IM) { |
| 3703 | if ($token->{type} == CHARACTER_TOKEN) { | if ($token->{type} == CHARACTER_TOKEN) { |
| 3704 | if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { | if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) { |
| 3705 | $self->{open_elements}->[-1]->[0]->manakai_append_text ($1); | $self->{open_elements}->[-1]->[0]->manakai_append_text ($1); |
| 3706 | unless (length $token->{data}) { | unless (length $token->{data}) { |
| 3707 | !!!cp ('t260'); | !!!cp ('t260'); |
| 3708 | !!!next-token; | !!!next-token; |
| 3709 | redo B; | next B; |
| 3710 | } | } |
| 3711 | } | } |
| 3712 | ||
| # | Line 4980 sub _tree_construction_main ($) { | Line 3715 sub _tree_construction_main ($) { |
| 3715 | } elsif ($token->{type} == START_TAG_TOKEN) { | } elsif ($token->{type} == START_TAG_TOKEN) { |
| 3716 | if ($token->{tag_name} eq 'col') { | if ($token->{tag_name} eq 'col') { |
| 3717 | !!!cp ('t262'); | !!!cp ('t262'); |
| 3718 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); |
| 3719 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 3720 | !!!ack ('t262.1'); | |
| 3721 | !!!next-token; | !!!next-token; |
| 3722 | redo B; | next B; |
| 3723 | } else { | } else { |
| 3724 | !!!cp ('t263'); | !!!cp ('t263'); |
| 3725 | # | # |
| 3726 | } | } |
| 3727 | } elsif ($token->{type} == END_TAG_TOKEN) { | } elsif ($token->{type} == END_TAG_TOKEN) { |
| 3728 | if ($token->{tag_name} eq 'colgroup') { | if ($token->{tag_name} eq 'colgroup') { |
| 3729 | if ($self->{open_elements}->[-1]->[1] eq 'html') { | if ($self->{open_elements}->[-1]->[1] == HTML_EL) { |
| 3730 | !!!cp ('t264'); | !!!cp ('t264'); |
| 3731 | !!!parse-error (type => 'unmatched end tag:colgroup'); | !!!parse-error (type => 'unmatched end tag', |
| 3732 | text => 'colgroup', token => $token); | |
| 3733 | ## Ignore the token | ## Ignore the token |
| 3734 | !!!next-token; | !!!next-token; |
| 3735 | redo B; | next B; |
| 3736 | } else { | } else { |
| 3737 | !!!cp ('t265'); | !!!cp ('t265'); |
| 3738 | pop @{$self->{open_elements}}; # colgroup | pop @{$self->{open_elements}}; # colgroup |
| 3739 | $self->{insertion_mode} = IN_TABLE_IM; | $self->{insertion_mode} = IN_TABLE_IM; |
| 3740 | !!!next-token; | !!!next-token; |
| 3741 | redo B; | next B; |
| 3742 | } | } |
| 3743 | } elsif ($token->{tag_name} eq 'col') { | } elsif ($token->{tag_name} eq 'col') { |
| 3744 | !!!cp ('t266'); | !!!cp ('t266'); |
| 3745 | !!!parse-error (type => 'unmatched end tag:col'); | !!!parse-error (type => 'unmatched end tag', |
| 3746 | text => 'col', token => $token); | |
| 3747 | ## Ignore the token | ## Ignore the token |
| 3748 | !!!next-token; | !!!next-token; |
| 3749 | redo B; | next B; |
| 3750 | } else { | } else { |
| 3751 | !!!cp ('t267'); | !!!cp ('t267'); |
| 3752 | # | # |
| 3753 | } | } |
| 3754 | } elsif ($token->{type} == END_OF_FILE_TOKEN) { | } elsif ($token->{type} == END_OF_FILE_TOKEN) { |
| 3755 | if ($self->{open_elements}->[-1]->[1] eq 'html' or | if ($self->{open_elements}->[-1]->[1] == HTML_EL and |
| 3756 | @{$self->{open_elements}} == 1) { # redundant, maybe | @{$self->{open_elements}} == 1) { # redundant, maybe |
| 3757 | !!!cp ('t270.2'); | !!!cp ('t270.2'); |
| 3758 | ## Stop parsing. | ## Stop parsing. |
| # | Line 5025 sub _tree_construction_main ($) { | Line 3763 sub _tree_construction_main ($) { |
| 3763 | pop @{$self->{open_elements}}; # colgroup | pop @{$self->{open_elements}}; # colgroup |
| 3764 | $self->{insertion_mode} = IN_TABLE_IM; | $self->{insertion_mode} = IN_TABLE_IM; |
| 3765 | ## Reprocess. | ## Reprocess. |
| 3766 | redo B; | next B; |
| 3767 | } | } |
| 3768 | } else { | } else { |
| 3769 | die "$0: $token->{type}: Unknown token type"; | die "$0: $token->{type}: Unknown token type"; |
| 3770 | } | } |
| 3771 | ||
| 3772 | ## As if </colgroup> | ## As if </colgroup> |
| 3773 | if ($self->{open_elements}->[-1]->[1] eq 'html') { | if ($self->{open_elements}->[-1]->[1] == HTML_EL) { |
| 3774 | !!!cp ('t269'); | !!!cp ('t269'); |
| 3775 | ## TODO: Wrong error type? | ## TODO: Wrong error type? |
| 3776 | !!!parse-error (type => 'unmatched end tag:colgroup'); | !!!parse-error (type => 'unmatched end tag', |
| 3777 | text => 'colgroup', token => $token); | |
| 3778 | ## Ignore the token | ## Ignore the token |
| 3779 | !!!nack ('t269.1'); | |
| 3780 | !!!next-token; | !!!next-token; |
| 3781 | redo B; | next B; |
| 3782 | } else { | } else { |
| 3783 | !!!cp ('t270'); | !!!cp ('t270'); |
| 3784 | pop @{$self->{open_elements}}; # colgroup | pop @{$self->{open_elements}}; # colgroup |
| 3785 | $self->{insertion_mode} = IN_TABLE_IM; | $self->{insertion_mode} = IN_TABLE_IM; |
| 3786 | !!!ack-later; | |
| 3787 | ## reprocess | ## reprocess |
| 3788 | redo B; | next B; |
| 3789 | } | } |
| 3790 | } elsif ($self->{insertion_mode} & SELECT_IMS) { | } elsif ($self->{insertion_mode} & SELECT_IMS) { |
| 3791 | if ($token->{type} == CHARACTER_TOKEN) { | if ($token->{type} == CHARACTER_TOKEN) { |
| 3792 | !!!cp ('t271'); | !!!cp ('t271'); |
| 3793 | $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data}); | $self->{open_elements}->[-1]->[0]->manakai_append_text ($token->{data}); |
| 3794 | !!!next-token; | !!!next-token; |
| 3795 | redo B; | next B; |
| 3796 | } elsif ($token->{type} == START_TAG_TOKEN) { | } elsif ($token->{type} == START_TAG_TOKEN) { |
| 3797 | if ($token->{tag_name} eq 'option') { | if ($token->{tag_name} eq 'option') { |
| 3798 | if ($self->{open_elements}->[-1]->[1] eq 'option') { | if ($self->{open_elements}->[-1]->[1] == OPTION_EL) { |
| 3799 | !!!cp ('t272'); | !!!cp ('t272'); |
| 3800 | ## As if </option> | ## As if </option> |
| 3801 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 3802 | } else { | } else { |
| 3803 | !!!cp ('t273'); | !!!cp ('t273'); |
| 3804 | } | } |
| 3805 | ||
| 3806 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); |
| 3807 | !!!next-token; | !!!nack ('t273.1'); |
| 3808 | redo B; | !!!next-token; |
| 3809 | } elsif ($token->{tag_name} eq 'optgroup') { | next B; |
| 3810 | if ($self->{open_elements}->[-1]->[1] eq 'option') { | } elsif ($token->{tag_name} eq 'optgroup') { |
| 3811 | !!!cp ('t274'); | if ($self->{open_elements}->[-1]->[1] == OPTION_EL) { |
| 3812 | ## As if </option> | !!!cp ('t274'); |
| 3813 | pop @{$self->{open_elements}}; | ## As if </option> |
| 3814 | } else { | pop @{$self->{open_elements}}; |
| 3815 | !!!cp ('t275'); | } else { |
| 3816 | } | !!!cp ('t275'); |
| 3817 | } | |
| 3818 | ||
| 3819 | if ($self->{open_elements}->[-1]->[1] eq 'optgroup') { | if ($self->{open_elements}->[-1]->[1] == OPTGROUP_EL) { |
| 3820 | !!!cp ('t276'); | !!!cp ('t276'); |
| 3821 | ## As if </optgroup> | ## As if </optgroup> |
| 3822 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 3823 | } else { | } else { |
| 3824 | !!!cp ('t277'); | !!!cp ('t277'); |
| 3825 | } | } |
| 3826 | ||
| 3827 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); |
| 3828 | !!!next-token; | !!!nack ('t277.1'); |
| 3829 | redo B; | !!!next-token; |
| 3830 | } elsif ($token->{tag_name} eq 'select' or | next B; |
| 3831 | $token->{tag_name} eq 'input' or | } elsif ({ |
| 3832 | ($self->{insertion_mode} == IN_SELECT_IN_TABLE_IM and | select => 1, input => 1, textarea => 1, |
| 3833 | }->{$token->{tag_name}} or | |
| 3834 | (($self->{insertion_mode} & IM_MASK) | |
| 3835 | == IN_SELECT_IN_TABLE_IM and | |
| 3836 | { | { |
| 3837 | caption => 1, table => 1, | caption => 1, table => 1, |
| 3838 | tbody => 1, tfoot => 1, thead => 1, | tbody => 1, tfoot => 1, thead => 1, |
| 3839 | tr => 1, td => 1, th => 1, | tr => 1, td => 1, th => 1, |
| 3840 | }->{$token->{tag_name}})) { | }->{$token->{tag_name}})) { |
| 3841 | ## TODO: The type below is not good - <select> is replaced by </select> | ## TODO: The type below is not good - <select> is replaced by </select> |
| 3842 | !!!parse-error (type => 'not closed:select'); | !!!parse-error (type => 'not closed', text => 'select', |
| 3843 | token => $token); | |
| 3844 | ## NOTE: As if the token were </select> (<select> case) or | ## NOTE: As if the token were </select> (<select> case) or |
| 3845 | ## as if there were </select> (otherwise). | ## as if there were </select> (otherwise). |
| 3846 | ## have an element in table scope | ## have an element in table scope |
| 3847 | my $i; | my $i; |
| 3848 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3849 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 3850 | if ($node->[1] eq 'select') { | if ($node->[1] == SELECT_EL) { |
| 3851 | !!!cp ('t278'); | !!!cp ('t278'); |
| 3852 | $i = $_; | $i = $_; |
| 3853 | last INSCOPE; | last INSCOPE; |
| 3854 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| 3855 | table => 1, html => 1, | !!!cp ('t279'); |
| 3856 | }->{$node->[1]}) { | last INSCOPE; |
| 3857 | !!!cp ('t279'); | } |
| 3858 | last INSCOPE; | } # INSCOPE |
| 3859 | } | unless (defined $i) { |
| 3860 | } # INSCOPE | !!!cp ('t280'); |
| 3861 | unless (defined $i) { | !!!parse-error (type => 'unmatched end tag', |
| 3862 | !!!cp ('t280'); | text => 'select', token => $token); |
| 3863 | !!!parse-error (type => 'unmatched end tag:select'); | ## Ignore the token |
| 3864 | ## Ignore the token | !!!nack ('t280.1'); |
| 3865 | !!!next-token; | !!!next-token; |
| 3866 | redo B; | next B; |
| 3867 | } | } |
| 3868 | ||
| 3869 | !!!cp ('t281'); | !!!cp ('t281'); |
| 3870 | splice @{$self->{open_elements}}, $i; | splice @{$self->{open_elements}}, $i; |
| 3871 | ||
| 3872 | $self->_reset_insertion_mode; | $self->_reset_insertion_mode; |
| 3873 | ||
| 3874 | if ($token->{tag_name} eq 'select') { | if ($token->{tag_name} eq 'select') { |
| 3875 | !!!cp ('t281.2'); | !!!nack ('t281.2'); |
| 3876 | !!!next-token; | !!!next-token; |
| 3877 | redo B; | next B; |
| 3878 | } else { | } else { |
| 3879 | !!!cp ('t281.1'); | !!!cp ('t281.1'); |
| 3880 | !!!ack-later; | |
| 3881 | ## Reprocess the token. | ## Reprocess the token. |
| 3882 | redo B; | next B; |
| 3883 | } | } |
| 3884 | } else { | } else { |
| 3885 | !!!cp ('t282'); | !!!cp ('t282'); |
| 3886 | !!!parse-error (type => 'in select:'.$token->{tag_name}); | !!!parse-error (type => 'in select', |
| 3887 | text => $token->{tag_name}, token => $token); | |
| 3888 | ## Ignore the token | ## Ignore the token |
| 3889 | !!!nack ('t282.1'); | |
| 3890 | !!!next-token; | !!!next-token; |
| 3891 | redo B; | next B; |
| 3892 | } | } |
| 3893 | } elsif ($token->{type} == END_TAG_TOKEN) { | } elsif ($token->{type} == END_TAG_TOKEN) { |
| 3894 | if ($token->{tag_name} eq 'optgroup') { | if ($token->{tag_name} eq 'optgroup') { |
| 3895 | if ($self->{open_elements}->[-1]->[1] eq 'option' and | if ($self->{open_elements}->[-1]->[1] == OPTION_EL and |
| 3896 | $self->{open_elements}->[-2]->[1] eq 'optgroup') { | $self->{open_elements}->[-2]->[1] == OPTGROUP_EL) { |
| 3897 | !!!cp ('t283'); | !!!cp ('t283'); |
| 3898 | ## As if </option> | ## As if </option> |
| 3899 | splice @{$self->{open_elements}}, -2; | splice @{$self->{open_elements}}, -2; |
| 3900 | } elsif ($self->{open_elements}->[-1]->[1] eq 'optgroup') { | } elsif ($self->{open_elements}->[-1]->[1] == OPTGROUP_EL) { |
| 3901 | !!!cp ('t284'); | !!!cp ('t284'); |
| 3902 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 3903 | } else { | } else { |
| 3904 | !!!cp ('t285'); | !!!cp ('t285'); |
| 3905 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 3906 | ## Ignore the token | text => $token->{tag_name}, token => $token); |
| 3907 | } | ## Ignore the token |
| 3908 | !!!next-token; | } |
| 3909 | redo B; | !!!nack ('t285.1'); |
| 3910 | } elsif ($token->{tag_name} eq 'option') { | !!!next-token; |
| 3911 | if ($self->{open_elements}->[-1]->[1] eq 'option') { | next B; |
| 3912 | !!!cp ('t286'); | } elsif ($token->{tag_name} eq 'option') { |
| 3913 | pop @{$self->{open_elements}}; | if ($self->{open_elements}->[-1]->[1] == OPTION_EL) { |
| 3914 | } else { | !!!cp ('t286'); |
| 3915 | !!!cp ('t287'); | pop @{$self->{open_elements}}; |
| 3916 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | } else { |
| 3917 | ## Ignore the token | !!!cp ('t287'); |
| 3918 | } | !!!parse-error (type => 'unmatched end tag', |
| 3919 | !!!next-token; | text => $token->{tag_name}, token => $token); |
| 3920 | redo B; | ## Ignore the token |
| 3921 | } elsif ($token->{tag_name} eq 'select') { | } |
| 3922 | ## have an element in table scope | !!!nack ('t287.1'); |
| 3923 | my $i; | !!!next-token; |
| 3924 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | next B; |
| 3925 | my $node = $self->{open_elements}->[$_]; | } elsif ($token->{tag_name} eq 'select') { |
| 3926 | if ($node->[1] eq $token->{tag_name}) { | ## have an element in table scope |
| 3927 | !!!cp ('t288'); | my $i; |
| 3928 | $i = $_; | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3929 | last INSCOPE; | my $node = $self->{open_elements}->[$_]; |
| 3930 | } elsif ({ | if ($node->[1] == SELECT_EL) { |
| 3931 | table => 1, html => 1, | !!!cp ('t288'); |
| 3932 | }->{$node->[1]}) { | $i = $_; |
| 3933 | !!!cp ('t289'); | last INSCOPE; |
| 3934 | last INSCOPE; | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| 3935 | } | !!!cp ('t289'); |
| 3936 | } # INSCOPE | last INSCOPE; |
| 3937 | unless (defined $i) { | } |
| 3938 | !!!cp ('t290'); | } # INSCOPE |
| 3939 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | unless (defined $i) { |
| 3940 | ## Ignore the token | !!!cp ('t290'); |
| 3941 | !!!next-token; | !!!parse-error (type => 'unmatched end tag', |
| 3942 | redo B; | text => $token->{tag_name}, token => $token); |
| 3943 | } | ## Ignore the token |
| 3944 | !!!nack ('t290.1'); | |
| 3945 | !!!next-token; | |
| 3946 | next B; | |
| 3947 | } | |
| 3948 | ||
| 3949 | !!!cp ('t291'); | !!!cp ('t291'); |
| 3950 | splice @{$self->{open_elements}}, $i; | splice @{$self->{open_elements}}, $i; |
| 3951 | ||
| 3952 | $self->_reset_insertion_mode; | $self->_reset_insertion_mode; |
| 3953 | ||
| 3954 | !!!next-token; | !!!nack ('t291.1'); |
| 3955 | redo B; | !!!next-token; |
| 3956 | } elsif ($self->{insertion_mode} == IN_SELECT_IN_TABLE_IM and | next B; |
| 3957 | } elsif (($self->{insertion_mode} & IM_MASK) | |
| 3958 | == IN_SELECT_IN_TABLE_IM and | |
| 3959 | { | { |
| 3960 | caption => 1, table => 1, tbody => 1, | caption => 1, table => 1, tbody => 1, |
| 3961 | tfoot => 1, thead => 1, tr => 1, td => 1, th => 1, | tfoot => 1, thead => 1, tr => 1, td => 1, th => 1, |
| 3962 | }->{$token->{tag_name}}) { | }->{$token->{tag_name}}) { |
| 3963 | ## TODO: The following is wrong? | ## TODO: The following is wrong? |
| 3964 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 3965 | text => $token->{tag_name}, token => $token); | |
| 3966 | ||
| 3967 | ## have an element in table scope | ## have an element in table scope |
| 3968 | my $i; | my $i; |
| 3969 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3970 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 3971 | if ($node->[1] eq $token->{tag_name}) { | if ($node->[0]->manakai_local_name eq $token->{tag_name}) { |
| 3972 | !!!cp ('t292'); | !!!cp ('t292'); |
| 3973 | $i = $_; | $i = $_; |
| 3974 | last INSCOPE; | last INSCOPE; |
| 3975 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| 3976 | table => 1, html => 1, | !!!cp ('t293'); |
| 3977 | }->{$node->[1]}) { | last INSCOPE; |
| 3978 | !!!cp ('t293'); | } |
| 3979 | last INSCOPE; | } # INSCOPE |
| 3980 | } | unless (defined $i) { |
| 3981 | } # INSCOPE | !!!cp ('t294'); |
| 3982 | unless (defined $i) { | ## Ignore the token |
| 3983 | !!!cp ('t294'); | !!!nack ('t294.1'); |
| 3984 | ## Ignore the token | !!!next-token; |
| 3985 | !!!next-token; | next B; |
| 3986 | redo B; | } |
| } | ||
| 3987 | ||
| 3988 | ## As if </select> | ## As if </select> |
| 3989 | ## have an element in table scope | ## have an element in table scope |
| 3990 | undef $i; | undef $i; |
| 3991 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 3992 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 3993 | if ($node->[1] eq 'select') { | if ($node->[1] == SELECT_EL) { |
| 3994 | !!!cp ('t295'); | !!!cp ('t295'); |
| 3995 | $i = $_; | $i = $_; |
| 3996 | last INSCOPE; | last INSCOPE; |
| 3997 | } elsif ({ | } elsif ($node->[1] & TABLE_SCOPING_EL) { |
| table => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 3998 | ## ISSUE: Can this state be reached? | ## ISSUE: Can this state be reached? |
| 3999 | !!!cp ('t296'); | !!!cp ('t296'); |
| 4000 | last INSCOPE; | last INSCOPE; |
| 4001 | } | } |
| 4002 | } # INSCOPE | } # INSCOPE |
| 4003 | unless (defined $i) { | unless (defined $i) { |
| 4004 | !!!cp ('t297'); | !!!cp ('t297'); |
| 4005 | ## TODO: The following error type is correct? | ## TODO: The following error type is correct? |
| 4006 | !!!parse-error (type => 'unmatched end tag:select'); | !!!parse-error (type => 'unmatched end tag', |
| 4007 | ## Ignore the </select> token | text => 'select', token => $token); |
| 4008 | !!!next-token; ## TODO: ok? | ## Ignore the </select> token |
| 4009 | redo B; | !!!nack ('t297.1'); |
| 4010 | } | !!!next-token; ## TODO: ok? |
| 4011 | next B; | |
| 4012 | } | |
| 4013 | ||
| 4014 | !!!cp ('t298'); | !!!cp ('t298'); |
| 4015 | splice @{$self->{open_elements}}, $i; | splice @{$self->{open_elements}}, $i; |
| 4016 | ||
| 4017 | $self->_reset_insertion_mode; | $self->_reset_insertion_mode; |
| 4018 | ||
| 4019 | ## reprocess | !!!ack-later; |
| 4020 | redo B; | ## reprocess |
| 4021 | next B; | |
| 4022 | } else { | } else { |
| 4023 | !!!cp ('t299'); | !!!cp ('t299'); |
| 4024 | !!!parse-error (type => 'in select:/'.$token->{tag_name}); | !!!parse-error (type => 'in select:/', |
| 4025 | text => $token->{tag_name}, token => $token); | |
| 4026 | ## Ignore the token | ## Ignore the token |
| 4027 | !!!nack ('t299.3'); | |
| 4028 | !!!next-token; | !!!next-token; |
| 4029 | redo B; | next B; |
| 4030 | } | } |
| 4031 | } elsif ($token->{type} == END_OF_FILE_TOKEN) { | } elsif ($token->{type} == END_OF_FILE_TOKEN) { |
| 4032 | unless ($self->{open_elements}->[-1]->[1] eq 'html' and | unless ($self->{open_elements}->[-1]->[1] == HTML_EL and |
| 4033 | @{$self->{open_elements}} == 1) { # redundant, maybe | @{$self->{open_elements}} == 1) { # redundant, maybe |
| 4034 | !!!cp ('t299.1'); | !!!cp ('t299.1'); |
| 4035 | !!!parse-error (type => 'in body:#eof'); | !!!parse-error (type => 'in body:#eof', token => $token); |
| 4036 | } else { | } else { |
| 4037 | !!!cp ('t299.2'); | !!!cp ('t299.2'); |
| 4038 | } | } |
| # | Line 5286 sub _tree_construction_main ($) { | Line 4044 sub _tree_construction_main ($) { |
| 4044 | } | } |
| 4045 | } elsif ($self->{insertion_mode} & BODY_AFTER_IMS) { | } elsif ($self->{insertion_mode} & BODY_AFTER_IMS) { |
| 4046 | if ($token->{type} == CHARACTER_TOKEN) { | if ($token->{type} == CHARACTER_TOKEN) { |
| 4047 | if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { | if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) { |
| 4048 | my $data = $1; | my $data = $1; |
| 4049 | ## As if in body | ## As if in body |
| 4050 | $reconstruct_active_formatting_elements->($insert_to_current); | $reconstruct_active_formatting_elements->($insert_to_current); |
| # | Line 5296 sub _tree_construction_main ($) { | Line 4054 sub _tree_construction_main ($) { |
| 4054 | unless (length $token->{data}) { | unless (length $token->{data}) { |
| 4055 | !!!cp ('t300'); | !!!cp ('t300'); |
| 4056 | !!!next-token; | !!!next-token; |
| 4057 | redo B; | next B; |
| 4058 | } | } |
| 4059 | } | } |
| 4060 | ||
| 4061 | if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) { | if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) { |
| 4062 | !!!cp ('t301'); | !!!cp ('t301'); |
| 4063 | !!!parse-error (type => 'after html:#character'); | !!!parse-error (type => 'after html:#text', token => $token); |
| 4064 | # | |
| ## Reprocess in the "after body" insertion mode. | ||
| 4065 | } else { | } else { |
| 4066 | !!!cp ('t302'); | !!!cp ('t302'); |
| 4067 | ## "after body" insertion mode | |
| 4068 | !!!parse-error (type => 'after body:#text', token => $token); | |
| 4069 | # | |
| 4070 | } | } |
| ## "after body" insertion mode | ||
| !!!parse-error (type => 'after body:#character'); | ||
| 4071 | ||
| 4072 | $self->{insertion_mode} = IN_BODY_IM; | $self->{insertion_mode} = IN_BODY_IM; |
| 4073 | ## reprocess | ## reprocess |
| 4074 | redo B; | next B; |
| 4075 | } elsif ($token->{type} == START_TAG_TOKEN) { | } elsif ($token->{type} == START_TAG_TOKEN) { |
| 4076 | if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) { | if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) { |
| 4077 | !!!cp ('t303'); | !!!cp ('t303'); |
| 4078 | !!!parse-error (type => 'after html:'.$token->{tag_name}); | !!!parse-error (type => 'after html', |
| 4079 | text => $token->{tag_name}, token => $token); | |
| 4080 | ## Reprocess in the "after body" insertion mode. | # |
| 4081 | } else { | } else { |
| 4082 | !!!cp ('t304'); | !!!cp ('t304'); |
| 4083 | ## "after body" insertion mode | |
| 4084 | !!!parse-error (type => 'after body', | |
| 4085 | text => $token->{tag_name}, token => $token); | |
| 4086 | # | |
| 4087 | } | } |
| 4088 | ||
| ## "after body" insertion mode | ||
| !!!parse-error (type => 'after body:'.$token->{tag_name}); | ||
| 4089 | $self->{insertion_mode} = IN_BODY_IM; | $self->{insertion_mode} = IN_BODY_IM; |
| 4090 | !!!ack-later; | |
| 4091 | ## reprocess | ## reprocess |
| 4092 | redo B; | next B; |
| 4093 | } elsif ($token->{type} == END_TAG_TOKEN) { | } elsif ($token->{type} == END_TAG_TOKEN) { |
| 4094 | if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) { | if ($self->{insertion_mode} == AFTER_HTML_BODY_IM) { |
| 4095 | !!!cp ('t305'); | !!!cp ('t305'); |
| 4096 | !!!parse-error (type => 'after html:/'.$token->{tag_name}); | !!!parse-error (type => 'after html:/', |
| 4097 | text => $token->{tag_name}, token => $token); | |
| 4098 | ||
| 4099 | $self->{insertion_mode} = AFTER_BODY_IM; | $self->{insertion_mode} = IN_BODY_IM; |
| 4100 | ## Reprocess in the "after body" insertion mode. | ## Reprocess. |
| 4101 | next B; | |
| 4102 | } else { | } else { |
| 4103 | !!!cp ('t306'); | !!!cp ('t306'); |
| 4104 | } | } |
| # | Line 5346 sub _tree_construction_main ($) { | Line 4107 sub _tree_construction_main ($) { |
| 4107 | if ($token->{tag_name} eq 'html') { | if ($token->{tag_name} eq 'html') { |
| 4108 | if (defined $self->{inner_html_node}) { | if (defined $self->{inner_html_node}) { |
| 4109 | !!!cp ('t307'); | !!!cp ('t307'); |
| 4110 | !!!parse-error (type => 'unmatched end tag:html'); | !!!parse-error (type => 'unmatched end tag', |
| 4111 | text => 'html', token => $token); | |
| 4112 | ## Ignore the token | ## Ignore the token |
| 4113 | !!!next-token; | !!!next-token; |
| 4114 | redo B; | next B; |
| 4115 | } else { | } else { |
| 4116 | !!!cp ('t308'); | !!!cp ('t308'); |
| 4117 | $self->{insertion_mode} = AFTER_HTML_BODY_IM; | $self->{insertion_mode} = AFTER_HTML_BODY_IM; |
| 4118 | !!!next-token; | !!!next-token; |
| 4119 | redo B; | next B; |
| 4120 | } | } |
| 4121 | } else { | } else { |
| 4122 | !!!cp ('t309'); | !!!cp ('t309'); |
| 4123 | !!!parse-error (type => 'after body:/'.$token->{tag_name}); | !!!parse-error (type => 'after body:/', |
| 4124 | text => $token->{tag_name}, token => $token); | |
| 4125 | ||
| 4126 | $self->{insertion_mode} = IN_BODY_IM; | $self->{insertion_mode} = IN_BODY_IM; |
| 4127 | ## reprocess | ## reprocess |
| 4128 | redo B; | next B; |
| 4129 | } | } |
| 4130 | } elsif ($token->{type} == END_OF_FILE_TOKEN) { | } elsif ($token->{type} == END_OF_FILE_TOKEN) { |
| 4131 | !!!cp ('t309.2'); | !!!cp ('t309.2'); |
| # | Line 5373 sub _tree_construction_main ($) { | Line 4136 sub _tree_construction_main ($) { |
| 4136 | } | } |
| 4137 | } elsif ($self->{insertion_mode} & FRAME_IMS) { | } elsif ($self->{insertion_mode} & FRAME_IMS) { |
| 4138 | if ($token->{type} == CHARACTER_TOKEN) { | if ($token->{type} == CHARACTER_TOKEN) { |
| 4139 | if ($token->{data} =~ s/^([\x09\x0A\x0B\x0C\x20]+)//) { | if ($token->{data} =~ s/^([\x09\x0A\x0C\x20]+)//) { |
| 4140 | $self->{open_elements}->[-1]->[0]->manakai_append_text ($1); | $self->{open_elements}->[-1]->[0]->manakai_append_text ($1); |
| 4141 | ||
| 4142 | unless (length $token->{data}) { | unless (length $token->{data}) { |
| 4143 | !!!cp ('t310'); | !!!cp ('t310'); |
| 4144 | !!!next-token; | !!!next-token; |
| 4145 | redo B; | next B; |
| 4146 | } | } |
| 4147 | } | } |
| 4148 | ||
| 4149 | if ($token->{data} =~ s/^[^\x09\x0A\x0B\x0C\x20]+//) { | if ($token->{data} =~ s/^[^\x09\x0A\x0C\x20]+//) { |
| 4150 | if ($self->{insertion_mode} == IN_FRAMESET_IM) { | if ($self->{insertion_mode} == IN_FRAMESET_IM) { |
| 4151 | !!!cp ('t311'); | !!!cp ('t311'); |
| 4152 | !!!parse-error (type => 'in frameset:#character'); | !!!parse-error (type => 'in frameset:#text', token => $token); |
| 4153 | } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) { | } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) { |
| 4154 | !!!cp ('t312'); | !!!cp ('t312'); |
| 4155 | !!!parse-error (type => 'after frameset:#character'); | !!!parse-error (type => 'after frameset:#text', token => $token); |
| 4156 | } else { # "after html frameset" | } else { # "after after frameset" |
| 4157 | !!!cp ('t313'); | !!!cp ('t313'); |
| 4158 | !!!parse-error (type => 'after html:#character'); | !!!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'); | ||
| 4159 | } | } |
| 4160 | ||
| 4161 | ## Ignore the token. | ## Ignore the token. |
| # | Line 5407 sub _tree_construction_main ($) { | Line 4166 sub _tree_construction_main ($) { |
| 4166 | !!!cp ('t315'); | !!!cp ('t315'); |
| 4167 | !!!next-token; | !!!next-token; |
| 4168 | } | } |
| 4169 | redo B; | next B; |
| 4170 | } | } |
| 4171 | ||
| 4172 | die qq[$0: Character "$token->{data}"]; | die qq[$0: Character "$token->{data}"]; |
| 4173 | } 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}); | ||
| $self->{insertion_mode} = AFTER_FRAMESET_IM; | ||
| ## Process in the "after frameset" insertion mode. | ||
| } else { | ||
| !!!cp ('t317'); | ||
| } | ||
| 4174 | if ($token->{tag_name} eq 'frameset' and | if ($token->{tag_name} eq 'frameset' and |
| 4175 | $self->{insertion_mode} == IN_FRAMESET_IM) { | $self->{insertion_mode} == IN_FRAMESET_IM) { |
| 4176 | !!!cp ('t318'); | !!!cp ('t318'); |
| 4177 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); |
| 4178 | !!!nack ('t318.1'); | |
| 4179 | !!!next-token; | !!!next-token; |
| 4180 | redo B; | next B; |
| 4181 | } elsif ($token->{tag_name} eq 'frame' and | } elsif ($token->{tag_name} eq 'frame' and |
| 4182 | $self->{insertion_mode} == IN_FRAMESET_IM) { | $self->{insertion_mode} == IN_FRAMESET_IM) { |
| 4183 | !!!cp ('t319'); | !!!cp ('t319'); |
| 4184 | !!!insert-element ($token->{tag_name}, $token->{attributes}); | !!!insert-element ($token->{tag_name}, $token->{attributes}, $token); |
| 4185 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 4186 | !!!ack ('t319.1'); | |
| 4187 | !!!next-token; | !!!next-token; |
| 4188 | redo B; | next B; |
| 4189 | } elsif ($token->{tag_name} eq 'noframes') { | } elsif ($token->{tag_name} eq 'noframes') { |
| 4190 | !!!cp ('t320'); | !!!cp ('t320'); |
| 4191 | ## NOTE: As if in body. | ## NOTE: As if in head. |
| 4192 | $parse_rcdata->(CDATA_CONTENT_MODEL); | $parse_rcdata->(CDATA_CONTENT_MODEL); |
| 4193 | redo B; | next B; |
| 4194 | ||
| 4195 | ## NOTE: |<!DOCTYPE HTML><frameset></frameset></html><noframes></noframes>| | |
| 4196 | ## has no parse error. | |
| 4197 | } else { | } else { |
| 4198 | if ($self->{insertion_mode} == IN_FRAMESET_IM) { | if ($self->{insertion_mode} == IN_FRAMESET_IM) { |
| 4199 | !!!cp ('t321'); | !!!cp ('t321'); |
| 4200 | !!!parse-error (type => 'in frameset:'.$token->{tag_name}); | !!!parse-error (type => 'in frameset', |
| 4201 | } else { | text => $token->{tag_name}, token => $token); |
| 4202 | } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) { | |
| 4203 | !!!cp ('t322'); | !!!cp ('t322'); |
| 4204 | !!!parse-error (type => 'after frameset:'.$token->{tag_name}); | !!!parse-error (type => 'after frameset', |
| 4205 | text => $token->{tag_name}, token => $token); | |
| 4206 | } else { # "after after frameset" | |
| 4207 | !!!cp ('t322.2'); | |
| 4208 | !!!parse-error (type => 'after after frameset', | |
| 4209 | text => $token->{tag_name}, token => $token); | |
| 4210 | } | } |
| 4211 | ## Ignore the token | ## Ignore the token |
| 4212 | !!!nack ('t322.1'); | |
| 4213 | !!!next-token; | !!!next-token; |
| 4214 | redo B; | next B; |
| 4215 | } | } |
| 4216 | } 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}); | ||
| $self->{insertion_mode} = AFTER_FRAMESET_IM; | ||
| ## Process in the "after frameset" insertion mode. | ||
| } else { | ||
| !!!cp ('t324'); | ||
| } | ||
| 4217 | if ($token->{tag_name} eq 'frameset' and | if ($token->{tag_name} eq 'frameset' and |
| 4218 | $self->{insertion_mode} == IN_FRAMESET_IM) { | $self->{insertion_mode} == IN_FRAMESET_IM) { |
| 4219 | if ($self->{open_elements}->[-1]->[1] eq 'html' and | if ($self->{open_elements}->[-1]->[1] == HTML_EL and |
| 4220 | @{$self->{open_elements}} == 1) { | @{$self->{open_elements}} == 1) { |
| 4221 | !!!cp ('t325'); | !!!cp ('t325'); |
| 4222 | !!!parse-error (type => 'unmatched end tag:'.$token->{tag_name}); | !!!parse-error (type => 'unmatched end tag', |
| 4223 | text => $token->{tag_name}, token => $token); | |
| 4224 | ## Ignore the token | ## Ignore the token |
| 4225 | !!!next-token; | !!!next-token; |
| 4226 | } else { | } else { |
| # | Line 5478 sub _tree_construction_main ($) { | Line 4230 sub _tree_construction_main ($) { |
| 4230 | } | } |
| 4231 | ||
| 4232 | if (not defined $self->{inner_html_node} and | if (not defined $self->{inner_html_node} and |
| 4233 | $self->{open_elements}->[-1]->[1] ne 'frameset') { | not ($self->{open_elements}->[-1]->[1] == FRAMESET_EL)) { |
| 4234 | !!!cp ('t327'); | !!!cp ('t327'); |
| 4235 | $self->{insertion_mode} = AFTER_FRAMESET_IM; | $self->{insertion_mode} = AFTER_FRAMESET_IM; |
| 4236 | } else { | } else { |
| 4237 | !!!cp ('t328'); | !!!cp ('t328'); |
| 4238 | } | } |
| 4239 | redo B; | next B; |
| 4240 | } elsif ($token->{tag_name} eq 'html' and | } elsif ($token->{tag_name} eq 'html' and |
| 4241 | $self->{insertion_mode} == AFTER_FRAMESET_IM) { | $self->{insertion_mode} == AFTER_FRAMESET_IM) { |
| 4242 | !!!cp ('t329'); | !!!cp ('t329'); |
| 4243 | $self->{insertion_mode} = AFTER_HTML_FRAMESET_IM; | $self->{insertion_mode} = AFTER_HTML_FRAMESET_IM; |
| 4244 | !!!next-token; | !!!next-token; |
| 4245 | redo B; | next B; |
| 4246 | } else { | } else { |
| 4247 | if ($self->{insertion_mode} == IN_FRAMESET_IM) { | if ($self->{insertion_mode} == IN_FRAMESET_IM) { |
| 4248 | !!!cp ('t330'); | !!!cp ('t330'); |
| 4249 | !!!parse-error (type => 'in frameset:/'.$token->{tag_name}); | !!!parse-error (type => 'in frameset:/', |
| 4250 | } else { | text => $token->{tag_name}, token => $token); |
| 4251 | } elsif ($self->{insertion_mode} == AFTER_FRAMESET_IM) { | |
| 4252 | !!!cp ('t330.1'); | |
| 4253 | !!!parse-error (type => 'after frameset:/', | |
| 4254 | text => $token->{tag_name}, token => $token); | |
| 4255 | } else { # "after after html" | |
| 4256 | !!!cp ('t331'); | !!!cp ('t331'); |
| 4257 | !!!parse-error (type => 'after frameset:/'.$token->{tag_name}); | !!!parse-error (type => 'after after frameset:/', |
| 4258 | text => $token->{tag_name}, token => $token); | |
| 4259 | } | } |
| 4260 | ## Ignore the token | ## Ignore the token |
| 4261 | !!!next-token; | !!!next-token; |
| 4262 | redo B; | next B; |
| 4263 | } | } |
| 4264 | } elsif ($token->{type} == END_OF_FILE_TOKEN) { | } elsif ($token->{type} == END_OF_FILE_TOKEN) { |
| 4265 | unless ($self->{open_elements}->[-1]->[1] eq 'html' and | unless ($self->{open_elements}->[-1]->[1] == HTML_EL and |
| 4266 | @{$self->{open_elements}} == 1) { # redundant, maybe | @{$self->{open_elements}} == 1) { # redundant, maybe |
| 4267 | !!!cp ('t331.1'); | !!!cp ('t331.1'); |
| 4268 | !!!parse-error (type => 'in body:#eof'); | !!!parse-error (type => 'in body:#eof', token => $token); |
| 4269 | } else { | } else { |
| 4270 | !!!cp ('t331.2'); | !!!cp ('t331.2'); |
| 4271 | } | } |
| # | Line 5517 sub _tree_construction_main ($) { | Line 4275 sub _tree_construction_main ($) { |
| 4275 | } else { | } else { |
| 4276 | die "$0: $token->{type}: Unknown token type"; | die "$0: $token->{type}: Unknown token type"; |
| 4277 | } | } |
| ## ISSUE: An issue in spec here | ||
| 4278 | } else { | } else { |
| 4279 | die "$0: $self->{insertion_mode}: Unknown insertion mode"; | die "$0: $self->{insertion_mode}: Unknown insertion mode"; |
| 4280 | } | } |
| # | Line 5529 sub _tree_construction_main ($) { | Line 4285 sub _tree_construction_main ($) { |
| 4285 | !!!cp ('t332'); | !!!cp ('t332'); |
| 4286 | ## NOTE: This is an "as if in head" code clone | ## NOTE: This is an "as if in head" code clone |
| 4287 | $script_start_tag->(); | $script_start_tag->(); |
| 4288 | redo B; | next B; |
| 4289 | } elsif ($token->{tag_name} eq 'style') { | } elsif ($token->{tag_name} eq 'style') { |
| 4290 | !!!cp ('t333'); | !!!cp ('t333'); |
| 4291 | ## NOTE: This is an "as if in head" code clone | ## NOTE: This is an "as if in head" code clone |
| 4292 | $parse_rcdata->(CDATA_CONTENT_MODEL); | $parse_rcdata->(CDATA_CONTENT_MODEL); |
| 4293 | redo B; | next B; |
| 4294 | } elsif ({ | } elsif ({ |
| 4295 | base => 1, link => 1, | base => 1, command => 1, eventsource => 1, link => 1, |
| 4296 | }->{$token->{tag_name}}) { | }->{$token->{tag_name}}) { |
| 4297 | !!!cp ('t334'); | !!!cp ('t334'); |
| 4298 | ## 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 |
| 4299 | !!!insert-element-t ($token->{tag_name}, $token->{attributes}); | !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token); |
| 4300 | pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec. | pop @{$self->{open_elements}}; |
| 4301 | !!!ack ('t334.1'); | |
| 4302 | !!!next-token; | !!!next-token; |
| 4303 | redo B; | next B; |
| 4304 | } elsif ($token->{tag_name} eq 'meta') { | } elsif ($token->{tag_name} eq 'meta') { |
| 4305 | ## 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 |
| 4306 | !!!insert-element-t ($token->{tag_name}, $token->{attributes}); | !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token); |
| 4307 | my $meta_el = pop @{$self->{open_elements}}; ## ISSUE: This step is missing in the spec. | my $meta_el = pop @{$self->{open_elements}}; |
| 4308 | ||
| 4309 | unless ($self->{confident}) { | unless ($self->{confident}) { |
| 4310 | if ($token->{attributes}->{charset}) { ## TODO: And if supported | if ($token->{attributes}->{charset}) { |
| 4311 | !!!cp ('t335'); | !!!cp ('t335'); |
| 4312 | ## NOTE: Whether the encoding is supported or not is handled | |
| 4313 | ## in the {change_encoding} callback. | |
| 4314 | $self->{change_encoding} | $self->{change_encoding} |
| 4315 | ->($self, $token->{attributes}->{charset}->{value}); | ->($self, $token->{attributes}->{charset}->{value}, $token); |
| 4316 | ||
| 4317 | $meta_el->[0]->get_attribute_node_ns (undef, 'charset') | $meta_el->[0]->get_attribute_node_ns (undef, 'charset') |
| 4318 | ->set_user_data (manakai_has_reference => | ->set_user_data (manakai_has_reference => |
| 4319 | $token->{attributes}->{charset} | $token->{attributes}->{charset} |
| 4320 | ->{has_reference}); | ->{has_reference}); |
| 4321 | } elsif ($token->{attributes}->{content}) { | } elsif ($token->{attributes}->{content}) { |
| ## ISSUE: Algorithm name in the spec was incorrect so that not linked to the definition. | ||
| 4322 | if ($token->{attributes}->{content}->{value} | if ($token->{attributes}->{content}->{value} |
| 4323 | =~ /\A[^;]*;[\x09-\x0D\x20]*[Cc][Hh][Aa][Rr][Ss][Ee][Tt] | =~ /[Cc][Hh][Aa][Rr][Ss][Ee][Tt] |
| 4324 | [\x09-\x0D\x20]*= | [\x09\x0A\x0C\x0D\x20]*= |
| 4325 | [\x09-\x0D\x20]*(?>"([^"]*)"|'([^']*)'| | [\x09\x0A\x0C\x0D\x20]*(?>"([^"]*)"|'([^']*)'| |
| 4326 | ([^"'\x09-\x0D\x20][^\x09-\x0D\x20]*))/x) { | ([^"'\x09\x0A\x0C\x0D\x20][^\x09\x0A\x0C\x0D\x20\x3B]*)) |
| 4327 | /x) { | |
| 4328 | !!!cp ('t336'); | !!!cp ('t336'); |
| 4329 | ## NOTE: Whether the encoding is supported or not is handled | |
| 4330 | ## in the {change_encoding} callback. | |
| 4331 | $self->{change_encoding} | $self->{change_encoding} |
| 4332 | ->($self, defined $1 ? $1 : defined $2 ? $2 : $3); | ->($self, defined $1 ? $1 : defined $2 ? $2 : $3, $token); |
| 4333 | $meta_el->[0]->get_attribute_node_ns (undef, 'content') | $meta_el->[0]->get_attribute_node_ns (undef, 'content') |
| 4334 | ->set_user_data (manakai_has_reference => | ->set_user_data (manakai_has_reference => |
| 4335 | $token->{attributes}->{content} | $token->{attributes}->{content} |
| # | Line 5592 sub _tree_construction_main ($) { | Line 4353 sub _tree_construction_main ($) { |
| 4353 | } | } |
| 4354 | } | } |
| 4355 | ||
| 4356 | !!!ack ('t338.1'); | |
| 4357 | !!!next-token; | !!!next-token; |
| 4358 | redo B; | next B; |
| 4359 | } elsif ($token->{tag_name} eq 'title') { | } elsif ($token->{tag_name} eq 'title') { |
| 4360 | !!!cp ('t341'); | !!!cp ('t341'); |
| 4361 | ## NOTE: This is an "as if in head" code clone | ## NOTE: This is an "as if in head" code clone |
| 4362 | $parse_rcdata->(RCDATA_CONTENT_MODEL); | $parse_rcdata->(RCDATA_CONTENT_MODEL); |
| 4363 | redo B; | next B; |
| 4364 | } elsif ($token->{tag_name} eq 'body') { | } elsif ($token->{tag_name} eq 'body') { |
| 4365 | !!!parse-error (type => 'in body:body'); | !!!parse-error (type => 'in body', text => 'body', token => $token); |
| 4366 | ||
| 4367 | if (@{$self->{open_elements}} == 1 or | if (@{$self->{open_elements}} == 1 or |
| 4368 | $self->{open_elements}->[1]->[1] ne 'body') { | not ($self->{open_elements}->[1]->[1] == BODY_EL)) { |
| 4369 | !!!cp ('t342'); | !!!cp ('t342'); |
| 4370 | ## Ignore the token | ## Ignore the token |
| 4371 | } else { | } else { |
| # | Line 5617 sub _tree_construction_main ($) { | Line 4379 sub _tree_construction_main ($) { |
| 4379 | } | } |
| 4380 | } | } |
| 4381 | } | } |
| 4382 | !!!nack ('t343.1'); | |
| 4383 | !!!next-token; | !!!next-token; |
| 4384 | redo B; | next B; |
| 4385 | } elsif ({ | } elsif ({ |
| 4386 | address => 1, blockquote => 1, center => 1, dir => 1, | ## NOTE: Start tags for non-phrasing flow content elements |
| 4387 | div => 1, dl => 1, fieldset => 1, | |
| 4388 | h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, h6 => 1, | ## NOTE: The normal one |
| 4389 | menu => 1, ol => 1, p => 1, ul => 1, | address => 1, article => 1, aside => 1, blockquote => 1, |
| 4390 | center => 1, datagrid => 1, details => 1, dialog => 1, | |
| 4391 | dir => 1, div => 1, dl => 1, fieldset => 1, figure => 1, | |
| 4392 | footer => 1, h1 => 1, h2 => 1, h3 => 1, h4 => 1, h5 => 1, | |
| 4393 | h6 => 1, header => 1, menu => 1, nav => 1, ol => 1, p => 1, | |
| 4394 | section => 1, ul => 1, | |
| 4395 | ## NOTE: As normal, but drops leading newline | |
| 4396 | pre => 1, listing => 1, | pre => 1, listing => 1, |
| 4397 | ## NOTE: As normal, but interacts with the form element pointer | |
| 4398 | form => 1, | form => 1, |
| 4399 | ||
| 4400 | table => 1, | table => 1, |
| 4401 | hr => 1, | hr => 1, |
| 4402 | }->{$token->{tag_name}}) { | }->{$token->{tag_name}}) { |
| 4403 | if ($token->{tag_name} eq 'form' and defined $self->{form_element}) { | if ($token->{tag_name} eq 'form' and defined $self->{form_element}) { |
| 4404 | !!!cp ('t350'); | !!!cp ('t350'); |
| 4405 | !!!parse-error (type => 'in form:form'); | !!!parse-error (type => 'in form:form', token => $token); |
| 4406 | ## Ignore the token | ## Ignore the token |
| 4407 | !!!nack ('t350.1'); | |
| 4408 | !!!next-token; | !!!next-token; |
| 4409 | redo B; | next B; |
| 4410 | } | } |
| 4411 | ||
| 4412 | ## has a p element in scope | ## has a p element in scope |
| 4413 | INSCOPE: for (reverse @{$self->{open_elements}}) { | INSCOPE: for (reverse @{$self->{open_elements}}) { |
| 4414 | if ($_->[1] eq 'p') { | if ($_->[1] == P_EL) { |
| 4415 | !!!cp ('t344'); | !!!cp ('t344'); |
| 4416 | !!!back-token; | !!!back-token; # <form> |
| 4417 | $token = {type => END_TAG_TOKEN, tag_name => 'p'}; | $token = {type => END_TAG_TOKEN, tag_name => 'p', |
| 4418 | redo B; | line => $token->{line}, column => $token->{column}}; |
| 4419 | } elsif ({ | next B; |
| 4420 | applet => 1, table => 1, caption => 1, td => 1, th => 1, | } elsif ($_->[1] & SCOPING_EL) { |
| button => 1, marquee => 1, object => 1, html => 1, | ||
| }->{$_->[1]}) { | ||
| 4421 | !!!cp ('t345'); | !!!cp ('t345'); |
| 4422 | last INSCOPE; | last INSCOPE; |
| 4423 | } | } |
| 4424 | } # INSCOPE | } # INSCOPE |
| 4425 | ||
| 4426 | !!!insert-element-t ($token->{tag_name}, $token->{attributes}); | !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token); |
| 4427 | if ($token->{tag_name} eq 'pre' or $token->{tag_name} eq 'listing') { | if ($token->{tag_name} eq 'pre' or $token->{tag_name} eq 'listing') { |
| 4428 | !!!nack ('t346.1'); | |
| 4429 | !!!next-token; | !!!next-token; |
| 4430 | if ($token->{type} == CHARACTER_TOKEN) { | if ($token->{type} == CHARACTER_TOKEN) { |
| 4431 | $token->{data} =~ s/^\x0A//; | $token->{data} =~ s/^\x0A//; |
| # | Line 5671 sub _tree_construction_main ($) { | Line 4442 sub _tree_construction_main ($) { |
| 4442 | !!!cp ('t347.1'); | !!!cp ('t347.1'); |
| 4443 | $self->{form_element} = $self->{open_elements}->[-1]->[0]; | $self->{form_element} = $self->{open_elements}->[-1]->[0]; |
| 4444 | ||
| 4445 | !!!nack ('t347.2'); | |
| 4446 | !!!next-token; | !!!next-token; |
| 4447 | } elsif ($token->{tag_name} eq 'table') { | } elsif ($token->{tag_name} eq 'table') { |
| 4448 | !!!cp ('t382'); | !!!cp ('t382'); |
| # | Line 5678 sub _tree_construction_main ($) { | Line 4450 sub _tree_construction_main ($) { |
| 4450 | ||
| 4451 | $self->{insertion_mode} = IN_TABLE_IM; | $self->{insertion_mode} = IN_TABLE_IM; |
| 4452 | ||
| 4453 | !!!nack ('t382.1'); | |
| 4454 | !!!next-token; | !!!next-token; |
| 4455 | } elsif ($token->{tag_name} eq 'hr') { | } elsif ($token->{tag_name} eq 'hr') { |
| 4456 | !!!cp ('t386'); | !!!cp ('t386'); |
| 4457 | pop @{$self->{open_elements}}; | pop @{$self->{open_elements}}; |
| 4458 | ||
| 4459 | !!!nack ('t386.1'); | |
| 4460 | !!!next-token; | !!!next-token; |
| 4461 | } else { | } else { |
| 4462 | !!!cp ('t347'); | !!!nack ('t347.1'); |
| 4463 | !!!next-token; | !!!next-token; |
| 4464 | } | } |
| 4465 | redo B; | next B; |
| 4466 | } elsif ({li => 1, dt => 1, dd => 1}->{$token->{tag_name}}) { | } elsif ($token->{tag_name} eq 'li') { |
| 4467 | ## has a p element in scope | ## NOTE: As normal, but imply </li> when there's another <li> ... |
| 4468 | ||
| 4469 | ## NOTE: Special, Scope (<li><foo><li> == <li><foo><li/></foo></li>) | |
| 4470 | ## Interpreted as <li><foo/></li><li/> (non-conforming) | |
| 4471 | ## blockquote (O9.27), center (O), dd (Fx3, O, S3.1.2, IE7), | |
| 4472 | ## dt (Fx, O, S, IE), dl (O), fieldset (O, S, IE), form (Fx, O, S), | |
| 4473 | ## hn (O), pre (O), applet (O, S), button (O, S), marquee (Fx, O, S), | |
| 4474 | ## object (Fx) | |
| 4475 | ## Generate non-tree (non-conforming) | |
| 4476 | ## basefont (IE7 (where basefont is non-void)), center (IE), | |
| 4477 | ## form (IE), hn (IE) | |
| 4478 | ## address, div, p (<li><foo><li> == <li><foo/></li><li/>) | |
| 4479 | ## Interpreted as <li><foo><li/></foo></li> (non-conforming) | |
| 4480 | ## div (Fx, S) | |
| 4481 | ||
| 4482 | my $non_optional; | |
| 4483 | my $i = -1; | |
| 4484 | ||
| 4485 | ## 1. | |
| 4486 | for my $node (reverse @{$self->{open_elements}}) { | |
| 4487 | if ($node->[1] == LI_EL) { | |
| 4488 | ## 2. (a) As if </li> | |
| 4489 | { | |
| 4490 | ## If no </li> - not applied | |
| 4491 | # | |
| 4492 | ||
| 4493 | ## Otherwise | |
| 4494 | ||
| 4495 | ## 1. generate implied end tags, except for </li> | |
| 4496 | # | |
| 4497 | ||
| 4498 | ## 2. If current node != "li", parse error | |
| 4499 | if ($non_optional) { | |
| 4500 | !!!parse-error (type => 'not closed', | |
| 4501 | text => $non_optional->[0]->manakai_local_name, | |
| 4502 | token => $token); | |
| 4503 | !!!cp ('t355'); | |
| 4504 | } else { | |
| 4505 | !!!cp ('t356'); | |
| 4506 | } | |
| 4507 | ||
| 4508 | ## 3. Pop | |
| 4509 | splice @{$self->{open_elements}}, $i; | |
| 4510 | } | |
| 4511 | ||
| 4512 | last; ## 2. (b) goto 5. | |
| 4513 | } elsif ( | |
| 4514 | ## NOTE: not "formatting" and not "phrasing" | |
| 4515 | ($node->[1] & SPECIAL_EL or | |
| 4516 | $node->[1] & SCOPING_EL) and | |
| 4517 | ## NOTE: "li", "dt", and "dd" are in |SPECIAL_EL|. | |
| 4518 | (not $node->[1] & ADDRESS_DIV_P_EL) | |
| 4519 | ) { | |
| 4520 | ## 3. | |
| 4521 | !!!cp ('t357'); | |
| 4522 | last; ## goto 5. | |
| 4523 | } elsif ($node->[1] & END_TAG_OPTIONAL_EL) { | |
| 4524 | !!!cp ('t358'); | |
| 4525 | # | |
| 4526 | } else { | |
| 4527 | !!!cp ('t359'); | |
| 4528 | $non_optional ||= $node; | |
| 4529 | # | |
| 4530 | } | |
| 4531 | ## 4. | |
| 4532 | ## goto 2. | |
| 4533 | $i--; | |
| 4534 | } | |
| 4535 | ||
| 4536 | ## 5. (a) has a |p| element in scope | |
| 4537 | INSCOPE: for (reverse @{$self->{open_elements}}) { | INSCOPE: for (reverse @{$self->{open_elements}}) { |
| 4538 | if ($_->[1] eq 'p') { | if ($_->[1] == P_EL) { |
| 4539 | !!!cp ('t353'); | !!!cp ('t353'); |
| 4540 | !!!back-token; | |
| 4541 | $token = {type => END_TAG_TOKEN, tag_name => 'p'}; | ## NOTE: |<p><li>|, for example. |
| 4542 | redo B; | |
| 4543 | } elsif ({ | !!!back-token; # <x> |
| 4544 | applet => 1, table => 1, caption => 1, td => 1, th => 1, | $token = {type => END_TAG_TOKEN, tag_name => 'p', |
| 4545 | button => 1, marquee => 1, object => 1, html => 1, | line => $token->{line}, column => $token->{column}}; |
| 4546 | }->{$_->[1]}) { | next B; |
| 4547 | } elsif ($_->[1] & SCOPING_EL) { | |
| 4548 | !!!cp ('t354'); | !!!cp ('t354'); |
| 4549 | last INSCOPE; | last INSCOPE; |
| 4550 | } | } |
| 4551 | } # INSCOPE | } # INSCOPE |
| 4552 | ||
| 4553 | ## Step 1 | ## 5. (b) insert |
| 4554 | !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token); | |
| 4555 | !!!nack ('t359.1'); | |
| 4556 | !!!next-token; | |
| 4557 | next B; | |
| 4558 | } elsif ($token->{tag_name} eq 'dt' or | |
| 4559 | $token->{tag_name} eq 'dd') { | |
| 4560 | ## NOTE: As normal, but imply </dt> or </dd> when ... | |
| 4561 | ||
| 4562 | my $non_optional; | |
| 4563 | my $i = -1; | my $i = -1; |
| 4564 | my $node = $self->{open_elements}->[$i]; | |
| 4565 | my $li_or_dtdd = {li => {li => 1}, | ## 1. |
| 4566 | dt => {dt => 1, dd => 1}, | for my $node (reverse @{$self->{open_elements}}) { |
| 4567 | dd => {dt => 1, dd => 1}}->{$token->{tag_name}}; | if ($node->[1] == DTDD_EL) { |
| 4568 | LI: { | ## 2. (a) As if </li> |
| 4569 | ## Step 2 | { |
| 4570 | if ($li_or_dtdd->{$node->[1]}) { | ## If no </li> - not applied |
| 4571 | if ($i != -1) { | # |
| 4572 | !!!cp ('t355'); | |
| 4573 | !!!parse-error (type => 'end tag missing:'. | ## Otherwise |
| 4574 | $self->{open_elements}->[-1]->[1]); | |
| 4575 | } else { | ## 1. generate implied end tags, except for </dt> or </dd> |
| 4576 | !!!cp ('t356'); | # |
| 4577 | ||
| 4578 | ## 2. If current node != "dt"|"dd", parse error | |
| 4579 | if ($non_optional) { | |
| 4580 | !!!parse-error (type => 'not closed', | |
| 4581 | text => $non_optional->[0]->manakai_local_name, | |
| 4582 | token => $token); | |
| 4583 | !!!cp ('t355.1'); | |
| 4584 | } else { | |
| 4585 | !!!cp ('t356.1'); | |
| 4586 | } | |
| 4587 | ||
| 4588 | ## 3. Pop | |
| 4589 | splice @{$self->{open_elements}}, $i; | |
| 4590 | } | } |
| 4591 | splice @{$self->{open_elements}}, $i; | |
| 4592 | last LI; | last; ## 2. (b) goto 5. |
| 4593 | } elsif ( | |
| 4594 | ## NOTE: not "formatting" and not "phrasing" | |
| 4595 | ($node->[1] & SPECIAL_EL or | |
| 4596 | $node->[1] & SCOPING_EL) and | |
| 4597 | ## NOTE: "li", "dt", and "dd" are in |SPECIAL_EL|. | |
| 4598 | ||
| 4599 | (not $node->[1] & ADDRESS_DIV_P_EL) | |
| 4600 | ) { | |
| 4601 | ## 3. | |
| 4602 | !!!cp ('t357.1'); | |
| 4603 | last; ## goto 5. | |
| 4604 | } elsif ($node->[1] & END_TAG_OPTIONAL_EL) { | |
| 4605 | !!!cp ('t358.1'); | |
| 4606 | # | |
| 4607 | } else { | } else { |
| 4608 | !!!cp ('t357'); | !!!cp ('t359.1'); |
| 4609 | } | $non_optional ||= $node; |
| 4610 | # | |
| ## 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; | ||
| 4611 | } | } |
| 4612 | ## 4. | |
| 4613 | !!!cp ('t359'); | ## goto 2. |
| ## Step 4 | ||
| 4614 | $i--; | $i--; |
| 4615 | $node = $self->{open_elements}->[$i]; | } |
| 4616 | redo LI; | |
| 4617 | } # LI | ## 5. (a) has a |p| element in scope |
| 4618 | INSCOPE: for (reverse @{$self->{open_elements}}) { | |
| 4619 | !!!insert-element-t ($token->{tag_name}, $token->{attributes}); | if ($_->[1] == P_EL) { |
| 4620 | !!!cp ('t353.1'); | |
| 4621 | !!!back-token; # <x> | |
| 4622 | $token = {type => END_TAG_TOKEN, tag_name => 'p', | |
| 4623 | line => $token->{line}, column => $token->{column}}; | |
| 4624 | next B; | |
| 4625 | } elsif ($_->[1] & SCOPING_EL) { | |
| 4626 | !!!cp ('t354.1'); | |
| 4627 | last INSCOPE; | |
| 4628 | } | |
| 4629 | } # INSCOPE | |
| 4630 | ||
| 4631 | ## 5. (b) insert | |
| 4632 | !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token); | |
| 4633 | !!!nack ('t359.2'); | |
| 4634 | !!!next-token; | !!!next-token; |
| 4635 | redo B; | next B; |
| 4636 | } elsif ($token->{tag_name} eq 'plaintext') { | } elsif ($token->{tag_name} eq 'plaintext') { |
| 4637 | ## NOTE: As normal, but effectively ends parsing | |
| 4638 | ||
| 4639 | ## has a p element in scope | ## has a p element in scope |
| 4640 | INSCOPE: for (reverse @{$self->{open_elements}}) { | INSCOPE: for (reverse @{$self->{open_elements}}) { |
| 4641 | if ($_->[1] eq 'p') { | if ($_->[1] == P_EL) { |
| 4642 | !!!cp ('t367'); | !!!cp ('t367'); |
| 4643 | !!!back-token; | !!!back-token; # <plaintext> |
| 4644 | $token = {type => END_TAG_TOKEN, tag_name => 'p'}; | $token = {type => END_TAG_TOKEN, tag_name => 'p', |
| 4645 | redo B; | line => $token->{line}, column => $token->{column}}; |
| 4646 | } elsif ({ | next B; |
| 4647 | applet => 1, table => 1, caption => 1, td => 1, th => 1, | } elsif ($_->[1] & SCOPING_EL) { |
| button => 1, marquee => 1, object => 1, html => 1, | ||
| }->{$_->[1]}) { | ||
| 4648 | !!!cp ('t368'); | !!!cp ('t368'); |
| 4649 | last INSCOPE; | last INSCOPE; |
| 4650 | } | } |
| 4651 | } # INSCOPE | } # INSCOPE |
| 4652 | ||
| 4653 | !!!insert-element-t ($token->{tag_name}, $token->{attributes}); | !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token); |
| 4654 | ||
| 4655 | $self->{content_model} = PLAINTEXT_CONTENT_MODEL; | $self->{content_model} = PLAINTEXT_CONTENT_MODEL; |
| 4656 | ||
| 4657 | !!!nack ('t368.1'); | |
| 4658 | !!!next-token; | !!!next-token; |
| 4659 | redo B; | next B; |
| 4660 | } elsif ($token->{tag_name} eq 'a') { | } elsif ($token->{tag_name} eq 'a') { |
| 4661 | AFE: for my $i (reverse 0..$#$active_formatting_elements) { | AFE: for my $i (reverse 0..$#$active_formatting_elements) { |
| 4662 | my $node = $active_formatting_elements->[$i]; | my $node = $active_formatting_elements->[$i]; |
| 4663 | if ($node->[1] eq 'a') { | if ($node->[1] == A_EL) { |
| 4664 | !!!cp ('t371'); | !!!cp ('t371'); |
| 4665 | !!!parse-error (type => 'in a:a'); | !!!parse-error (type => 'in a:a', token => $token); |
| 4666 | ||
| 4667 | !!!back-token; | !!!back-token; # <a> |
| 4668 | $token = {type => END_TAG_TOKEN, tag_name => 'a'}; | $token = {type => END_TAG_TOKEN, tag_name => 'a', |
| 4669 | $formatting_end_tag->($token->{tag_name}); | line => $token->{line}, column => $token->{column}}; |
| 4670 | $formatting_end_tag->($token); | |
| 4671 | ||
| 4672 | AFE2: for (reverse 0..$#$active_formatting_elements) { | AFE2: for (reverse 0..$#$active_formatting_elements) { |
| 4673 | if ($active_formatting_elements->[$_]->[0] eq $node->[0]) { | if ($active_formatting_elements->[$_]->[0] eq $node->[0]) { |
| # | Line 5805 sub _tree_construction_main ($) { | Line 4692 sub _tree_construction_main ($) { |
| 4692 | ||
| 4693 | $reconstruct_active_formatting_elements->($insert_to_current); | $reconstruct_active_formatting_elements->($insert_to_current); |
| 4694 | ||
| 4695 | !!!insert-element-t ($token->{tag_name}, $token->{attributes}); | !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token); |
| 4696 | push @$active_formatting_elements, $self->{open_elements}->[-1]; | push @$active_formatting_elements, $self->{open_elements}->[-1]; |
| 4697 | ||
| 4698 | !!!nack ('t374.1'); | |
| 4699 | !!!next-token; | !!!next-token; |
| 4700 | redo B; | next B; |
| 4701 | } elsif ($token->{tag_name} eq 'nobr') { | } elsif ($token->{tag_name} eq 'nobr') { |
| 4702 | $reconstruct_active_formatting_elements->($insert_to_current); | $reconstruct_active_formatting_elements->($insert_to_current); |
| 4703 | ||
| 4704 | ## has a |nobr| element in scope | ## has a |nobr| element in scope |
| 4705 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 4706 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 4707 | if ($node->[1] eq 'nobr') { | if ($node->[1] == NOBR_EL) { |
| 4708 | !!!cp ('t376'); | !!!cp ('t376'); |
| 4709 | !!!parse-error (type => 'in nobr:nobr'); | !!!parse-error (type => 'in nobr:nobr', token => $token); |
| 4710 | !!!back-token; | !!!back-token; # <nobr> |
| 4711 | $token = {type => END_TAG_TOKEN, tag_name => 'nobr'}; | $token = {type => END_TAG_TOKEN, tag_name => 'nobr', |
| 4712 | redo B; | line => $token->{line}, column => $token->{column}}; |
| 4713 | } elsif ({ | next B; |
| 4714 | applet => 1, table => 1, caption => 1, td => 1, th => 1, | } elsif ($node->[1] & SCOPING_EL) { |
| button => 1, marquee => 1, object => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 4715 | !!!cp ('t377'); | !!!cp ('t377'); |
| 4716 | last INSCOPE; | last INSCOPE; |
| 4717 | } | } |
| 4718 | } # INSCOPE | } # INSCOPE |
| 4719 | ||
| 4720 | !!!insert-element-t ($token->{tag_name}, $token->{attributes}); | !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token); |
| 4721 | push @$active_formatting_elements, $self->{open_elements}->[-1]; | push @$active_formatting_elements, $self->{open_elements}->[-1]; |
| 4722 | ||
| 4723 | !!!nack ('t377.1'); | |
| 4724 | !!!next-token; | !!!next-token; |
| 4725 | redo B; | next B; |
| 4726 | } elsif ($token->{tag_name} eq 'button') { | } elsif ($token->{tag_name} eq 'button') { |
| 4727 | ## has a button element in scope | ## has a button element in scope |
| 4728 | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { | INSCOPE: for (reverse 0..$#{$self->{open_elements}}) { |
| 4729 | my $node = $self->{open_elements}->[$_]; | my $node = $self->{open_elements}->[$_]; |
| 4730 | if ($node->[1] eq 'button') { | if ($node->[1] == BUTTON_EL) { |
| 4731 | !!!cp ('t378'); | !!!cp ('t378'); |
| 4732 | !!!parse-error (type => 'in button:button'); | !!!parse-error (type => 'in button:button', token => $token); |
| 4733 | !!!back-token; | !!!back-token; # <button> |
| 4734 | $token = {type => END_TAG_TOKEN, tag_name => 'button'}; | $token = {type => END_TAG_TOKEN, tag_name => 'button', |
| 4735 | redo B; | line => $token->{line}, column => $token->{column}}; |
| 4736 | } elsif ({ | next B; |
| 4737 | applet => 1, table => 1, caption => 1, td => 1, th => 1, | } elsif ($node->[1] & SCOPING_EL) { |
| button => 1, marquee => 1, object => 1, html => 1, | ||
| }->{$node->[1]}) { | ||
| 4738 | !!!cp ('t379'); | !!!cp ('t379'); |
| 4739 | last INSCOPE; | last INSCOPE; |
| 4740 | } | } |
| # | Line 5857 sub _tree_construction_main ($) { | Line 4742 sub _tree_construction_main ($) { |
| 4742 | ||
| 4743 | $reconstruct_active_formatting_elements->($insert_to_current); | $reconstruct_active_formatting_elements->($insert_to_current); |
| 4744 | ||
| 4745 | !!!insert-element-t ($token->{tag_name}, $token->{attributes}); | !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token); |
| 4746 | ||
| 4747 | ## TODO: associate with $self->{form_element} if defined | ## TODO: associate with $self->{form_element} if defined |
| 4748 | ||
| 4749 | push @$active_formatting_elements, ['#marker', '']; | push @$active_formatting_elements, ['#marker', '']; |
| 4750 | ||
| 4751 | !!!nack ('t379.1'); | |
| 4752 | !!!next-token; | !!!next-token; |
| 4753 | redo B; | next B; |
| 4754 | } elsif ({ | } elsif ({ |
| 4755 | xmp => 1, | xmp => 1, |
| 4756 | iframe => 1, | iframe => 1, |
| 4757 | noembed => 1, | noembed => 1, |
| 4758 | noframes => 1, | noframes => 1, ## NOTE: This is an "as if in head" code clone. |
| 4759 | noscript => 0, ## TODO: 1 if scripting is enabled | noscript => 0, ## TODO: 1 if scripting is enabled |
| 4760 | }->{$token->{tag_name}}) { | }->{$token->{tag_name}}) { |
| 4761 | if ($token->{tag_name} eq 'xmp') { | if ($token->{tag_name} eq 'xmp') { |
| # | Line 5880 sub _tree_construction_main ($) { | Line 4766 sub _tree_construction_main ($) { |
| 4766 | } | } |
| 4767 | ## NOTE: There is an "as if in body" code clone. | ## NOTE: There is an "as if in body" code clone. |
| 4768 | $parse_rcdata->(CDATA_CONTENT_MODEL); | $parse_rcdata->(CDATA_CONTENT_MODEL); |
| 4769 | redo B; | next B; |
| 4770 | } elsif ($token->{tag_name} eq 'isindex') { | } elsif ($token->{tag_name} eq 'isindex') { |
| 4771 | !!!parse-error (type => 'isindex'); | !!!parse-error (type => 'isindex', token => $token); |
| 4772 | ||
| 4773 | if (defined $self->{form_element}) { | if (defined $self->{form_element}) { |
| 4774 | !!!cp ('t389'); | !!!cp ('t389'); |
| 4775 | ## Ignore the token | ## Ignore the token |
| 4776 | !!!nack ('t389'); ## NOTE: Not acknowledged. | |
| 4777 | !!!next-token; | !!!next-token; |
| 4778 | redo B; | next B; |
| 4779 | } else { | } else { |
| 4780 | !!!ack ('t391.1'); | |
| 4781 | ||
| 4782 | my $at = $token->{attributes}; | my $at = $token->{attributes}; |
| 4783 | my $form_attrs; | my $form_attrs; |
| 4784 | $form_attrs->{action} = $at->{action} if $at->{action}; | $form_attrs->{action} = $at->{action} if $at->{action}; |
| # | Line 5899 sub _tree_construction_main ($) { | Line 4788 sub _tree_construction_main ($) { |
| 4788 | delete $at->{prompt}; | delete $at->{prompt}; |
| 4789 | my @tokens = ( | my @tokens = ( |
| 4790 | {type => START_TAG_TOKEN, tag_name => 'form', | {type => START_TAG_TOKEN, tag_name => 'form', |
| 4791 | attributes => $form_attrs}, | attributes => $form_attrs, |
| 4792 | {type => START_TAG_TOKEN, tag_name => 'hr'}, | line => $token->{line}, column => $token->{column}}, |
| 4793 | {type => START_TAG_TOKEN, tag_name => 'p'}, | {type => START_TAG_TOKEN, tag_name => 'hr', |
| 4794 | {type => START_TAG_TOKEN, tag_name => 'label'}, | line => $token->{line}, column => $token->{column}}, |
| 4795 | {type => START_TAG_TOKEN, tag_name => 'p', | |
| 4796 | line => $token->{line}, column => $token->{column}}, | |
| 4797 | {type => START_TAG_TOKEN, tag_name => 'label', | |
| 4798 | line => $token->{line}, column => $token->{column}}, | |
| 4799 | ); | ); |
| 4800 | if ($prompt_attr) { | if ($prompt_attr) { |
| 4801 | !!!cp ('t390'); | !!!cp ('t390'); |
| 4802 | push @tokens, {type => CHARACTER_TOKEN, data => $prompt_attr->{value}}; | push @tokens, {type => CHARACTER_TOKEN, data => $prompt_attr->{value}, |
| 4803 | #line => $token->{line}, column => $token->{column}, | |
| 4804 | }; | |
| 4805 | } else { | } else { |
| 4806 | !!!cp ('t391'); | !!!cp ('t391'); |
| 4807 | push @tokens, {type => CHARACTER_TOKEN, | push @tokens, {type => CHARACTER_TOKEN, |
| 4808 | data => 'This is a searchable index. Insert your search keywords here: '}; # SHOULD | data => 'This is a searchable index. Insert your search keywords here: ', |
| 4809 | #line => $token->{line}, column => $token->{column}, | |
| 4810 | }; # SHOULD | |
| 4811 | ## TODO: make this configurable | ## TODO: make this configurable |
| 4812 | } | } |
| 4813 | push @tokens, | push @tokens, |
| 4814 | {type => START_TAG_TOKEN, tag_name => 'input', attributes => $at}, | {type => START_TAG_TOKEN, tag_name => 'input', attributes => $at, |
| 4815 | line => $token->{line}, column => $token->{column}}, | |
| 4816 | #{type => CHARACTER_TOKEN, data => ''}, # SHOULD | #{type => CHARACTER_TOKEN, data => ''}, # SHOULD |
| 4817 | {type => END_TAG_TOKEN, tag_name => 'label'}, | {type => END_TAG_TOKEN, tag_name => 'label', |
| 4818 | {type => END_TAG_TOKEN, tag_name => 'p'}, | line => $token->{line}, column => $token->{column}}, |
| 4819 | {type => START_TAG_TOKEN, tag_name => 'hr'}, | {type => END_TAG_TOKEN, tag_name => 'p', |
| 4820 | {type => END_TAG_TOKEN, tag_name => 'form'}; | line => $token->{line}, column => $token->{column}}, |
| 4821 | $token = shift @tokens; | {type => START_TAG_TOKEN, tag_name => 'hr', |
| 4822 | line => $token->{line}, column => $token->{column}}, | |
| 4823 | {type => END_TAG_TOKEN, tag_name => 'form', | |
| 4824 | line => $token->{line}, column => $token->{column}}; | |
| 4825 | !!!back-token (@tokens); | !!!back-token (@tokens); |
| 4826 | redo B; | !!!next-token; |
| 4827 | next B; | |
| 4828 | } | } |
| 4829 | } elsif ($token->{tag_name} eq 'textarea') { | } elsif ($token->{tag_name} eq 'textarea') { |
| 4830 | my $tag_name = $token->{tag_name}; | ## Step 1 |
| 4831 | my $el; | !!!insert-element-t ($token->{tag_name}, $token->{attributes}, $token); |
| !!!create-element ($el, $token->{tag_name}, $token->{attributes}); | ||
| 4832 | ||
| 4833 | ## Step 2 | |
| 4834 | ## TODO: $self->{form_element} if defined | ## TODO: $self->{form_element} if defined |
| 4835 | ||
| 4836 | ## Step 3 | |
| 4837 | $self->{ignore_newline} = 1; | |
| 4838 | ||
| 4839 | ## Step 4 | |
| 4840 | ## ISSUE: This step is wrong. (r2302 enbugged) | |
| 4841 | ||
| 4842 | ## Step 5 | |
| 4843 | $self->{content_model} = RCDATA_CONTENT_MODEL; | $self->{content_model} = RCDATA_CONTENT_MODEL; |
| 4844 | delete $self->{escape}; # MUST | delete $self->{escape}; # MUST |
| 484 |