1 /* 2 * Copyright (C) 2008 Apple Inc. All Rights Reserved. 3 * Copyright (C) 2009 Torch Mobile, Inc. http://www.torchmobile.com/ 4 * Copyright (C) 2010 Google, Inc. All Rights Reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY 16 * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 17 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 18 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR 19 * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 20 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, 21 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 22 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY 23 * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 25 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include "config.h" 29 #include "core/html/parser/HTMLTokenizer.h" 30 31 #include "core/HTMLNames.h" 32 #include "core/HTMLTokenizerNames.h" 33 #include "core/html/parser/HTMLEntityParser.h" 34 #include "core/html/parser/HTMLParserIdioms.h" 35 #include "core/html/parser/HTMLTreeBuilder.h" 36 #include "platform/NotImplemented.h" 37 #include "core/xml/parser/MarkupTokenizerInlines.h" 38 #include "wtf/ASCIICType.h" 39 #include "wtf/text/AtomicString.h" 40 #include "wtf/unicode/Unicode.h" 41 42 // Please don't use DEFINE_STATIC_LOCAL in this file. The HTMLTokenizer is used 43 // from multiple threads and DEFINE_STATIC_LOCAL isn't threadsafe. 44 #undef DEFINE_STATIC_LOCAL 45 46 namespace blink { 47 48 using namespace HTMLNames; 49 50 // This has to go in a .cpp file, as the linker doesn't like it being included more than once. 51 // We don't have an HTMLToken.cpp though, so this is the next best place. 52 QualifiedName AtomicHTMLToken::nameForAttribute(const HTMLToken::Attribute& attribute) const 53 { 54 return QualifiedName(nullAtom, AtomicString(attribute.name), nullAtom); 55 } 56 57 bool AtomicHTMLToken::usesName() const 58 { 59 return m_type == HTMLToken::StartTag || m_type == HTMLToken::EndTag || m_type == HTMLToken::DOCTYPE; 60 } 61 62 bool AtomicHTMLToken::usesAttributes() const 63 { 64 return m_type == HTMLToken::StartTag || m_type == HTMLToken::EndTag; 65 } 66 67 static inline UChar toLowerCase(UChar cc) 68 { 69 ASSERT(isASCIIUpper(cc)); 70 const int lowerCaseOffset = 0x20; 71 return cc + lowerCaseOffset; 72 } 73 74 static inline bool vectorEqualsString(const Vector<LChar, 32>& vector, const String& string) 75 { 76 if (vector.size() != string.length()) 77 return false; 78 79 if (!string.length()) 80 return true; 81 82 return equal(string.impl(), vector.data(), vector.size()); 83 } 84 85 static inline bool isEndTagBufferingState(HTMLTokenizer::State state) 86 { 87 switch (state) { 88 case HTMLTokenizer::RCDATAEndTagOpenState: 89 case HTMLTokenizer::RCDATAEndTagNameState: 90 case HTMLTokenizer::RAWTEXTEndTagOpenState: 91 case HTMLTokenizer::RAWTEXTEndTagNameState: 92 case HTMLTokenizer::ScriptDataEndTagOpenState: 93 case HTMLTokenizer::ScriptDataEndTagNameState: 94 case HTMLTokenizer::ScriptDataEscapedEndTagOpenState: 95 case HTMLTokenizer::ScriptDataEscapedEndTagNameState: 96 return true; 97 default: 98 return false; 99 } 100 } 101 102 #define HTML_BEGIN_STATE(stateName) BEGIN_STATE(HTMLTokenizer, stateName) 103 #define HTML_RECONSUME_IN(stateName) RECONSUME_IN(HTMLTokenizer, stateName) 104 #define HTML_ADVANCE_TO(stateName) ADVANCE_TO(HTMLTokenizer, stateName) 105 #define HTML_SWITCH_TO(stateName) SWITCH_TO(HTMLTokenizer, stateName) 106 107 HTMLTokenizer::HTMLTokenizer(const HTMLParserOptions& options) 108 : m_inputStreamPreprocessor(this) 109 , m_options(options) 110 { 111 reset(); 112 } 113 114 HTMLTokenizer::~HTMLTokenizer() 115 { 116 } 117 118 void HTMLTokenizer::reset() 119 { 120 m_state = HTMLTokenizer::DataState; 121 m_token = 0; 122 m_forceNullCharacterReplacement = false; 123 m_shouldAllowCDATA = false; 124 m_additionalAllowedCharacter = '\0'; 125 } 126 127 bool HTMLTokenizer::canCreateCheckpoint() const 128 { 129 if (!m_appropriateEndTagName.isEmpty()) 130 return false; 131 if (!m_temporaryBuffer.isEmpty()) 132 return false; 133 if (!m_bufferedEndTagName.isEmpty()) 134 return false; 135 return true; 136 } 137 138 void HTMLTokenizer::createCheckpoint(Checkpoint& result) const 139 { 140 ASSERT(canCreateCheckpoint()); 141 result.options = m_options; 142 result.state = m_state; 143 result.additionalAllowedCharacter = m_additionalAllowedCharacter; 144 result.skipNextNewLine = m_inputStreamPreprocessor.skipNextNewLine(); 145 result.shouldAllowCDATA = m_shouldAllowCDATA; 146 } 147 148 void HTMLTokenizer::restoreFromCheckpoint(const Checkpoint& checkpoint) 149 { 150 m_token = 0; 151 m_options = checkpoint.options; 152 m_state = checkpoint.state; 153 m_additionalAllowedCharacter = checkpoint.additionalAllowedCharacter; 154 m_inputStreamPreprocessor.reset(checkpoint.skipNextNewLine); 155 m_shouldAllowCDATA = checkpoint.shouldAllowCDATA; 156 } 157 158 inline bool HTMLTokenizer::processEntity(SegmentedString& source) 159 { 160 bool notEnoughCharacters = false; 161 DecodedHTMLEntity decodedEntity; 162 bool success = consumeHTMLEntity(source, decodedEntity, notEnoughCharacters); 163 if (notEnoughCharacters) 164 return false; 165 if (!success) { 166 ASSERT(decodedEntity.isEmpty()); 167 bufferCharacter('&'); 168 } else { 169 for (unsigned i = 0; i < decodedEntity.length; ++i) 170 bufferCharacter(decodedEntity.data[i]); 171 } 172 return true; 173 } 174 175 bool HTMLTokenizer::flushBufferedEndTag(SegmentedString& source) 176 { 177 ASSERT(m_token->type() == HTMLToken::Character || m_token->type() == HTMLToken::Uninitialized); 178 source.advanceAndUpdateLineNumber(); 179 if (m_token->type() == HTMLToken::Character) 180 return true; 181 m_token->beginEndTag(m_bufferedEndTagName); 182 m_bufferedEndTagName.clear(); 183 m_appropriateEndTagName.clear(); 184 m_temporaryBuffer.clear(); 185 return false; 186 } 187 188 #define FLUSH_AND_ADVANCE_TO(stateName) \ 189 do { \ 190 m_state = HTMLTokenizer::stateName; \ 191 if (flushBufferedEndTag(source)) \ 192 return true; \ 193 if (source.isEmpty() \ 194 || !m_inputStreamPreprocessor.peek(source)) \ 195 return haveBufferedCharacterToken(); \ 196 cc = m_inputStreamPreprocessor.nextInputCharacter(); \ 197 goto stateName; \ 198 } while (false) 199 200 bool HTMLTokenizer::flushEmitAndResumeIn(SegmentedString& source, HTMLTokenizer::State state) 201 { 202 m_state = state; 203 flushBufferedEndTag(source); 204 return true; 205 } 206 207 bool HTMLTokenizer::nextToken(SegmentedString& source, HTMLToken& token) 208 { 209 // If we have a token in progress, then we're supposed to be called back 210 // with the same token so we can finish it. 211 ASSERT(!m_token || m_token == &token || token.type() == HTMLToken::Uninitialized); 212 m_token = &token; 213 214 if (!m_bufferedEndTagName.isEmpty() && !isEndTagBufferingState(m_state)) { 215 // FIXME: This should call flushBufferedEndTag(). 216 // We started an end tag during our last iteration. 217 m_token->beginEndTag(m_bufferedEndTagName); 218 m_bufferedEndTagName.clear(); 219 m_appropriateEndTagName.clear(); 220 m_temporaryBuffer.clear(); 221 if (m_state == HTMLTokenizer::DataState) { 222 // We're back in the data state, so we must be done with the tag. 223 return true; 224 } 225 } 226 227 if (source.isEmpty() || !m_inputStreamPreprocessor.peek(source)) 228 return haveBufferedCharacterToken(); 229 UChar cc = m_inputStreamPreprocessor.nextInputCharacter(); 230 231 // Source: http://www.whatwg.org/specs/web-apps/current-work/#tokenisation0 232 switch (m_state) { 233 HTML_BEGIN_STATE(DataState) { 234 if (cc == '&') 235 HTML_ADVANCE_TO(CharacterReferenceInDataState); 236 else if (cc == '<') { 237 if (m_token->type() == HTMLToken::Character) { 238 // We have a bunch of character tokens queued up that we 239 // are emitting lazily here. 240 return true; 241 } 242 HTML_ADVANCE_TO(TagOpenState); 243 } else if (cc == kEndOfFileMarker) 244 return emitEndOfFile(source); 245 else { 246 bufferCharacter(cc); 247 HTML_ADVANCE_TO(DataState); 248 } 249 } 250 END_STATE() 251 252 HTML_BEGIN_STATE(CharacterReferenceInDataState) { 253 if (!processEntity(source)) 254 return haveBufferedCharacterToken(); 255 HTML_SWITCH_TO(DataState); 256 } 257 END_STATE() 258 259 HTML_BEGIN_STATE(RCDATAState) { 260 if (cc == '&') 261 HTML_ADVANCE_TO(CharacterReferenceInRCDATAState); 262 else if (cc == '<') 263 HTML_ADVANCE_TO(RCDATALessThanSignState); 264 else if (cc == kEndOfFileMarker) 265 return emitEndOfFile(source); 266 else { 267 bufferCharacter(cc); 268 HTML_ADVANCE_TO(RCDATAState); 269 } 270 } 271 END_STATE() 272 273 HTML_BEGIN_STATE(CharacterReferenceInRCDATAState) { 274 if (!processEntity(source)) 275 return haveBufferedCharacterToken(); 276 HTML_SWITCH_TO(RCDATAState); 277 } 278 END_STATE() 279 280 HTML_BEGIN_STATE(RAWTEXTState) { 281 if (cc == '<') 282 HTML_ADVANCE_TO(RAWTEXTLessThanSignState); 283 else if (cc == kEndOfFileMarker) 284 return emitEndOfFile(source); 285 else { 286 bufferCharacter(cc); 287 HTML_ADVANCE_TO(RAWTEXTState); 288 } 289 } 290 END_STATE() 291 292 HTML_BEGIN_STATE(ScriptDataState) { 293 if (cc == '<') 294 HTML_ADVANCE_TO(ScriptDataLessThanSignState); 295 else if (cc == kEndOfFileMarker) 296 return emitEndOfFile(source); 297 else { 298 bufferCharacter(cc); 299 HTML_ADVANCE_TO(ScriptDataState); 300 } 301 } 302 END_STATE() 303 304 HTML_BEGIN_STATE(PLAINTEXTState) { 305 if (cc == kEndOfFileMarker) 306 return emitEndOfFile(source); 307 bufferCharacter(cc); 308 HTML_ADVANCE_TO(PLAINTEXTState); 309 } 310 END_STATE() 311 312 HTML_BEGIN_STATE(TagOpenState) { 313 if (cc == '!') 314 HTML_ADVANCE_TO(MarkupDeclarationOpenState); 315 else if (cc == '/') 316 HTML_ADVANCE_TO(EndTagOpenState); 317 else if (isASCIIUpper(cc)) { 318 m_token->beginStartTag(toLowerCase(cc)); 319 HTML_ADVANCE_TO(TagNameState); 320 } else if (isASCIILower(cc)) { 321 m_token->beginStartTag(cc); 322 HTML_ADVANCE_TO(TagNameState); 323 } else if (cc == '?') { 324 parseError(); 325 // The spec consumes the current character before switching 326 // to the bogus comment state, but it's easier to implement 327 // if we reconsume the current character. 328 HTML_RECONSUME_IN(BogusCommentState); 329 } else { 330 parseError(); 331 bufferCharacter('<'); 332 HTML_RECONSUME_IN(DataState); 333 } 334 } 335 END_STATE() 336 337 HTML_BEGIN_STATE(EndTagOpenState) { 338 if (isASCIIUpper(cc)) { 339 m_token->beginEndTag(static_cast<LChar>(toLowerCase(cc))); 340 m_appropriateEndTagName.clear(); 341 HTML_ADVANCE_TO(TagNameState); 342 } else if (isASCIILower(cc)) { 343 m_token->beginEndTag(static_cast<LChar>(cc)); 344 m_appropriateEndTagName.clear(); 345 HTML_ADVANCE_TO(TagNameState); 346 } else if (cc == '>') { 347 parseError(); 348 HTML_ADVANCE_TO(DataState); 349 } else if (cc == kEndOfFileMarker) { 350 parseError(); 351 bufferCharacter('<'); 352 bufferCharacter('/'); 353 HTML_RECONSUME_IN(DataState); 354 } else { 355 parseError(); 356 HTML_RECONSUME_IN(BogusCommentState); 357 } 358 } 359 END_STATE() 360 361 HTML_BEGIN_STATE(TagNameState) { 362 if (isTokenizerWhitespace(cc)) 363 HTML_ADVANCE_TO(BeforeAttributeNameState); 364 else if (cc == '/') 365 HTML_ADVANCE_TO(SelfClosingStartTagState); 366 else if (cc == '>') 367 return emitAndResumeIn(source, HTMLTokenizer::DataState); 368 else if (isASCIIUpper(cc)) { 369 m_token->appendToName(toLowerCase(cc)); 370 HTML_ADVANCE_TO(TagNameState); 371 } else if (cc == kEndOfFileMarker) { 372 parseError(); 373 HTML_RECONSUME_IN(DataState); 374 } else { 375 m_token->appendToName(cc); 376 HTML_ADVANCE_TO(TagNameState); 377 } 378 } 379 END_STATE() 380 381 HTML_BEGIN_STATE(RCDATALessThanSignState) { 382 if (cc == '/') { 383 m_temporaryBuffer.clear(); 384 ASSERT(m_bufferedEndTagName.isEmpty()); 385 HTML_ADVANCE_TO(RCDATAEndTagOpenState); 386 } else { 387 bufferCharacter('<'); 388 HTML_RECONSUME_IN(RCDATAState); 389 } 390 } 391 END_STATE() 392 393 HTML_BEGIN_STATE(RCDATAEndTagOpenState) { 394 if (isASCIIUpper(cc)) { 395 m_temporaryBuffer.append(static_cast<LChar>(cc)); 396 addToPossibleEndTag(static_cast<LChar>(toLowerCase(cc))); 397 HTML_ADVANCE_TO(RCDATAEndTagNameState); 398 } else if (isASCIILower(cc)) { 399 m_temporaryBuffer.append(static_cast<LChar>(cc)); 400 addToPossibleEndTag(static_cast<LChar>(cc)); 401 HTML_ADVANCE_TO(RCDATAEndTagNameState); 402 } else { 403 bufferCharacter('<'); 404 bufferCharacter('/'); 405 HTML_RECONSUME_IN(RCDATAState); 406 } 407 } 408 END_STATE() 409 410 HTML_BEGIN_STATE(RCDATAEndTagNameState) { 411 if (isASCIIUpper(cc)) { 412 m_temporaryBuffer.append(static_cast<LChar>(cc)); 413 addToPossibleEndTag(static_cast<LChar>(toLowerCase(cc))); 414 HTML_ADVANCE_TO(RCDATAEndTagNameState); 415 } else if (isASCIILower(cc)) { 416 m_temporaryBuffer.append(static_cast<LChar>(cc)); 417 addToPossibleEndTag(static_cast<LChar>(cc)); 418 HTML_ADVANCE_TO(RCDATAEndTagNameState); 419 } else { 420 if (isTokenizerWhitespace(cc)) { 421 if (isAppropriateEndTag()) { 422 m_temporaryBuffer.append(static_cast<LChar>(cc)); 423 FLUSH_AND_ADVANCE_TO(BeforeAttributeNameState); 424 } 425 } else if (cc == '/') { 426 if (isAppropriateEndTag()) { 427 m_temporaryBuffer.append(static_cast<LChar>(cc)); 428 FLUSH_AND_ADVANCE_TO(SelfClosingStartTagState); 429 } 430 } else if (cc == '>') { 431 if (isAppropriateEndTag()) { 432 m_temporaryBuffer.append(static_cast<LChar>(cc)); 433 return flushEmitAndResumeIn(source, HTMLTokenizer::DataState); 434 } 435 } 436 bufferCharacter('<'); 437 bufferCharacter('/'); 438 m_token->appendToCharacter(m_temporaryBuffer); 439 m_bufferedEndTagName.clear(); 440 m_temporaryBuffer.clear(); 441 HTML_RECONSUME_IN(RCDATAState); 442 } 443 } 444 END_STATE() 445 446 HTML_BEGIN_STATE(RAWTEXTLessThanSignState) { 447 if (cc == '/') { 448 m_temporaryBuffer.clear(); 449 ASSERT(m_bufferedEndTagName.isEmpty()); 450 HTML_ADVANCE_TO(RAWTEXTEndTagOpenState); 451 } else { 452 bufferCharacter('<'); 453 HTML_RECONSUME_IN(RAWTEXTState); 454 } 455 } 456 END_STATE() 457 458 HTML_BEGIN_STATE(RAWTEXTEndTagOpenState) { 459 if (isASCIIUpper(cc)) { 460 m_temporaryBuffer.append(static_cast<LChar>(cc)); 461 addToPossibleEndTag(static_cast<LChar>(toLowerCase(cc))); 462 HTML_ADVANCE_TO(RAWTEXTEndTagNameState); 463 } else if (isASCIILower(cc)) { 464 m_temporaryBuffer.append(static_cast<LChar>(cc)); 465 addToPossibleEndTag(static_cast<LChar>(cc)); 466 HTML_ADVANCE_TO(RAWTEXTEndTagNameState); 467 } else { 468 bufferCharacter('<'); 469 bufferCharacter('/'); 470 HTML_RECONSUME_IN(RAWTEXTState); 471 } 472 } 473 END_STATE() 474 475 HTML_BEGIN_STATE(RAWTEXTEndTagNameState) { 476 if (isASCIIUpper(cc)) { 477 m_temporaryBuffer.append(static_cast<LChar>(cc)); 478 addToPossibleEndTag(static_cast<LChar>(toLowerCase(cc))); 479 HTML_ADVANCE_TO(RAWTEXTEndTagNameState); 480 } else if (isASCIILower(cc)) { 481 m_temporaryBuffer.append(static_cast<LChar>(cc)); 482 addToPossibleEndTag(static_cast<LChar>(cc)); 483 HTML_ADVANCE_TO(RAWTEXTEndTagNameState); 484 } else { 485 if (isTokenizerWhitespace(cc)) { 486 if (isAppropriateEndTag()) { 487 m_temporaryBuffer.append(static_cast<LChar>(cc)); 488 FLUSH_AND_ADVANCE_TO(BeforeAttributeNameState); 489 } 490 } else if (cc == '/') { 491 if (isAppropriateEndTag()) { 492 m_temporaryBuffer.append(static_cast<LChar>(cc)); 493 FLUSH_AND_ADVANCE_TO(SelfClosingStartTagState); 494 } 495 } else if (cc == '>') { 496 if (isAppropriateEndTag()) { 497 m_temporaryBuffer.append(static_cast<LChar>(cc)); 498 return flushEmitAndResumeIn(source, HTMLTokenizer::DataState); 499 } 500 } 501 bufferCharacter('<'); 502 bufferCharacter('/'); 503 m_token->appendToCharacter(m_temporaryBuffer); 504 m_bufferedEndTagName.clear(); 505 m_temporaryBuffer.clear(); 506 HTML_RECONSUME_IN(RAWTEXTState); 507 } 508 } 509 END_STATE() 510 511 HTML_BEGIN_STATE(ScriptDataLessThanSignState) { 512 if (cc == '/') { 513 m_temporaryBuffer.clear(); 514 ASSERT(m_bufferedEndTagName.isEmpty()); 515 HTML_ADVANCE_TO(ScriptDataEndTagOpenState); 516 } else if (cc == '!') { 517 bufferCharacter('<'); 518 bufferCharacter('!'); 519 HTML_ADVANCE_TO(ScriptDataEscapeStartState); 520 } else { 521 bufferCharacter('<'); 522 HTML_RECONSUME_IN(ScriptDataState); 523 } 524 } 525 END_STATE() 526 527 HTML_BEGIN_STATE(ScriptDataEndTagOpenState) { 528 if (isASCIIUpper(cc)) { 529 m_temporaryBuffer.append(static_cast<LChar>(cc)); 530 addToPossibleEndTag(static_cast<LChar>(toLowerCase(cc))); 531 HTML_ADVANCE_TO(ScriptDataEndTagNameState); 532 } else if (isASCIILower(cc)) { 533 m_temporaryBuffer.append(static_cast<LChar>(cc)); 534 addToPossibleEndTag(static_cast<LChar>(cc)); 535 HTML_ADVANCE_TO(ScriptDataEndTagNameState); 536 } else { 537 bufferCharacter('<'); 538 bufferCharacter('/'); 539 HTML_RECONSUME_IN(ScriptDataState); 540 } 541 } 542 END_STATE() 543 544 HTML_BEGIN_STATE(ScriptDataEndTagNameState) { 545 if (isASCIIUpper(cc)) { 546 m_temporaryBuffer.append(static_cast<LChar>(cc)); 547 addToPossibleEndTag(static_cast<LChar>(toLowerCase(cc))); 548 HTML_ADVANCE_TO(ScriptDataEndTagNameState); 549 } else if (isASCIILower(cc)) { 550 m_temporaryBuffer.append(static_cast<LChar>(cc)); 551 addToPossibleEndTag(static_cast<LChar>(cc)); 552 HTML_ADVANCE_TO(ScriptDataEndTagNameState); 553 } else { 554 if (isTokenizerWhitespace(cc)) { 555 if (isAppropriateEndTag()) { 556 m_temporaryBuffer.append(static_cast<LChar>(cc)); 557 FLUSH_AND_ADVANCE_TO(BeforeAttributeNameState); 558 } 559 } else if (cc == '/') { 560 if (isAppropriateEndTag()) { 561 m_temporaryBuffer.append(static_cast<LChar>(cc)); 562 FLUSH_AND_ADVANCE_TO(SelfClosingStartTagState); 563 } 564 } else if (cc == '>') { 565 if (isAppropriateEndTag()) { 566 m_temporaryBuffer.append(static_cast<LChar>(cc)); 567 return flushEmitAndResumeIn(source, HTMLTokenizer::DataState); 568 } 569 } 570 bufferCharacter('<'); 571 bufferCharacter('/'); 572 m_token->appendToCharacter(m_temporaryBuffer); 573 m_bufferedEndTagName.clear(); 574 m_temporaryBuffer.clear(); 575 HTML_RECONSUME_IN(ScriptDataState); 576 } 577 } 578 END_STATE() 579 580 HTML_BEGIN_STATE(ScriptDataEscapeStartState) { 581 if (cc == '-') { 582 bufferCharacter(cc); 583 HTML_ADVANCE_TO(ScriptDataEscapeStartDashState); 584 } else 585 HTML_RECONSUME_IN(ScriptDataState); 586 } 587 END_STATE() 588 589 HTML_BEGIN_STATE(ScriptDataEscapeStartDashState) { 590 if (cc == '-') { 591 bufferCharacter(cc); 592 HTML_ADVANCE_TO(ScriptDataEscapedDashDashState); 593 } else 594 HTML_RECONSUME_IN(ScriptDataState); 595 } 596 END_STATE() 597 598 HTML_BEGIN_STATE(ScriptDataEscapedState) { 599 if (cc == '-') { 600 bufferCharacter(cc); 601 HTML_ADVANCE_TO(ScriptDataEscapedDashState); 602 } else if (cc == '<') 603 HTML_ADVANCE_TO(ScriptDataEscapedLessThanSignState); 604 else if (cc == kEndOfFileMarker) { 605 parseError(); 606 HTML_RECONSUME_IN(DataState); 607 } else { 608 bufferCharacter(cc); 609 HTML_ADVANCE_TO(ScriptDataEscapedState); 610 } 611 } 612 END_STATE() 613 614 HTML_BEGIN_STATE(ScriptDataEscapedDashState) { 615 if (cc == '-') { 616 bufferCharacter(cc); 617 HTML_ADVANCE_TO(ScriptDataEscapedDashDashState); 618 } else if (cc == '<') 619 HTML_ADVANCE_TO(ScriptDataEscapedLessThanSignState); 620 else if (cc == kEndOfFileMarker) { 621 parseError(); 622 HTML_RECONSUME_IN(DataState); 623 } else { 624 bufferCharacter(cc); 625 HTML_ADVANCE_TO(ScriptDataEscapedState); 626 } 627 } 628 END_STATE() 629 630 HTML_BEGIN_STATE(ScriptDataEscapedDashDashState) { 631 if (cc == '-') { 632 bufferCharacter(cc); 633 HTML_ADVANCE_TO(ScriptDataEscapedDashDashState); 634 } else if (cc == '<') 635 HTML_ADVANCE_TO(ScriptDataEscapedLessThanSignState); 636 else if (cc == '>') { 637 bufferCharacter(cc); 638 HTML_ADVANCE_TO(ScriptDataState); 639 } else if (cc == kEndOfFileMarker) { 640 parseError(); 641 HTML_RECONSUME_IN(DataState); 642 } else { 643 bufferCharacter(cc); 644 HTML_ADVANCE_TO(ScriptDataEscapedState); 645 } 646 } 647 END_STATE() 648 649 HTML_BEGIN_STATE(ScriptDataEscapedLessThanSignState) { 650 if (cc == '/') { 651 m_temporaryBuffer.clear(); 652 ASSERT(m_bufferedEndTagName.isEmpty()); 653 HTML_ADVANCE_TO(ScriptDataEscapedEndTagOpenState); 654 } else if (isASCIIUpper(cc)) { 655 bufferCharacter('<'); 656 bufferCharacter(cc); 657 m_temporaryBuffer.clear(); 658 m_temporaryBuffer.append(toLowerCase(cc)); 659 HTML_ADVANCE_TO(ScriptDataDoubleEscapeStartState); 660 } else if (isASCIILower(cc)) { 661 bufferCharacter('<'); 662 bufferCharacter(cc); 663 m_temporaryBuffer.clear(); 664 m_temporaryBuffer.append(static_cast<LChar>(cc)); 665 HTML_ADVANCE_TO(ScriptDataDoubleEscapeStartState); 666 } else { 667 bufferCharacter('<'); 668 HTML_RECONSUME_IN(ScriptDataEscapedState); 669 } 670 } 671 END_STATE() 672 673 HTML_BEGIN_STATE(ScriptDataEscapedEndTagOpenState) { 674 if (isASCIIUpper(cc)) { 675 m_temporaryBuffer.append(static_cast<LChar>(cc)); 676 addToPossibleEndTag(static_cast<LChar>(toLowerCase(cc))); 677 HTML_ADVANCE_TO(ScriptDataEscapedEndTagNameState); 678 } else if (isASCIILower(cc)) { 679 m_temporaryBuffer.append(static_cast<LChar>(cc)); 680 addToPossibleEndTag(static_cast<LChar>(cc)); 681 HTML_ADVANCE_TO(ScriptDataEscapedEndTagNameState); 682 } else { 683 bufferCharacter('<'); 684 bufferCharacter('/'); 685 HTML_RECONSUME_IN(ScriptDataEscapedState); 686 } 687 } 688 END_STATE() 689 690 HTML_BEGIN_STATE(ScriptDataEscapedEndTagNameState) { 691 if (isASCIIUpper(cc)) { 692 m_temporaryBuffer.append(static_cast<LChar>(cc)); 693 addToPossibleEndTag(static_cast<LChar>(toLowerCase(cc))); 694 HTML_ADVANCE_TO(ScriptDataEscapedEndTagNameState); 695 } else if (isASCIILower(cc)) { 696 m_temporaryBuffer.append(static_cast<LChar>(cc)); 697 addToPossibleEndTag(static_cast<LChar>(cc)); 698 HTML_ADVANCE_TO(ScriptDataEscapedEndTagNameState); 699 } else { 700 if (isTokenizerWhitespace(cc)) { 701 if (isAppropriateEndTag()) { 702 m_temporaryBuffer.append(static_cast<LChar>(cc)); 703 FLUSH_AND_ADVANCE_TO(BeforeAttributeNameState); 704 } 705 } else if (cc == '/') { 706 if (isAppropriateEndTag()) { 707 m_temporaryBuffer.append(static_cast<LChar>(cc)); 708 FLUSH_AND_ADVANCE_TO(SelfClosingStartTagState); 709 } 710 } else if (cc == '>') { 711 if (isAppropriateEndTag()) { 712 m_temporaryBuffer.append(static_cast<LChar>(cc)); 713 return flushEmitAndResumeIn(source, HTMLTokenizer::DataState); 714 } 715 } 716 bufferCharacter('<'); 717 bufferCharacter('/'); 718 m_token->appendToCharacter(m_temporaryBuffer); 719 m_bufferedEndTagName.clear(); 720 m_temporaryBuffer.clear(); 721 HTML_RECONSUME_IN(ScriptDataEscapedState); 722 } 723 } 724 END_STATE() 725 726 HTML_BEGIN_STATE(ScriptDataDoubleEscapeStartState) { 727 if (isTokenizerWhitespace(cc) || cc == '/' || cc == '>') { 728 bufferCharacter(cc); 729 if (temporaryBufferIs(scriptTag.localName())) 730 HTML_ADVANCE_TO(ScriptDataDoubleEscapedState); 731 else 732 HTML_ADVANCE_TO(ScriptDataEscapedState); 733 } else if (isASCIIUpper(cc)) { 734 bufferCharacter(cc); 735 m_temporaryBuffer.append(toLowerCase(cc)); 736 HTML_ADVANCE_TO(ScriptDataDoubleEscapeStartState); 737 } else if (isASCIILower(cc)) { 738 bufferCharacter(cc); 739 m_temporaryBuffer.append(static_cast<LChar>(cc)); 740 HTML_ADVANCE_TO(ScriptDataDoubleEscapeStartState); 741 } else 742 HTML_RECONSUME_IN(ScriptDataEscapedState); 743 } 744 END_STATE() 745 746 HTML_BEGIN_STATE(ScriptDataDoubleEscapedState) { 747 if (cc == '-') { 748 bufferCharacter(cc); 749 HTML_ADVANCE_TO(ScriptDataDoubleEscapedDashState); 750 } else if (cc == '<') { 751 bufferCharacter(cc); 752 HTML_ADVANCE_TO(ScriptDataDoubleEscapedLessThanSignState); 753 } else if (cc == kEndOfFileMarker) { 754 parseError(); 755 HTML_RECONSUME_IN(DataState); 756 } else { 757 bufferCharacter(cc); 758 HTML_ADVANCE_TO(ScriptDataDoubleEscapedState); 759 } 760 } 761 END_STATE() 762 763 HTML_BEGIN_STATE(ScriptDataDoubleEscapedDashState) { 764 if (cc == '-') { 765 bufferCharacter(cc); 766 HTML_ADVANCE_TO(ScriptDataDoubleEscapedDashDashState); 767 } else if (cc == '<') { 768 bufferCharacter(cc); 769 HTML_ADVANCE_TO(ScriptDataDoubleEscapedLessThanSignState); 770 } else if (cc == kEndOfFileMarker) { 771 parseError(); 772 HTML_RECONSUME_IN(DataState); 773 } else { 774 bufferCharacter(cc); 775 HTML_ADVANCE_TO(ScriptDataDoubleEscapedState); 776 } 777 } 778 END_STATE() 779 780 HTML_BEGIN_STATE(ScriptDataDoubleEscapedDashDashState) { 781 if (cc == '-') { 782 bufferCharacter(cc); 783 HTML_ADVANCE_TO(ScriptDataDoubleEscapedDashDashState); 784 } else if (cc == '<') { 785 bufferCharacter(cc); 786 HTML_ADVANCE_TO(ScriptDataDoubleEscapedLessThanSignState); 787 } else if (cc == '>') { 788 bufferCharacter(cc); 789 HTML_ADVANCE_TO(ScriptDataState); 790 } else if (cc == kEndOfFileMarker) { 791 parseError(); 792 HTML_RECONSUME_IN(DataState); 793 } else { 794 bufferCharacter(cc); 795 HTML_ADVANCE_TO(ScriptDataDoubleEscapedState); 796 } 797 } 798 END_STATE() 799 800 HTML_BEGIN_STATE(ScriptDataDoubleEscapedLessThanSignState) { 801 if (cc == '/') { 802 bufferCharacter(cc); 803 m_temporaryBuffer.clear(); 804 HTML_ADVANCE_TO(ScriptDataDoubleEscapeEndState); 805 } else 806 HTML_RECONSUME_IN(ScriptDataDoubleEscapedState); 807 } 808 END_STATE() 809 810 HTML_BEGIN_STATE(ScriptDataDoubleEscapeEndState) { 811 if (isTokenizerWhitespace(cc) || cc == '/' || cc == '>') { 812 bufferCharacter(cc); 813 if (temporaryBufferIs(scriptTag.localName())) 814 HTML_ADVANCE_TO(ScriptDataEscapedState); 815 else 816 HTML_ADVANCE_TO(ScriptDataDoubleEscapedState); 817 } else if (isASCIIUpper(cc)) { 818 bufferCharacter(cc); 819 m_temporaryBuffer.append(toLowerCase(cc)); 820 HTML_ADVANCE_TO(ScriptDataDoubleEscapeEndState); 821 } else if (isASCIILower(cc)) { 822 bufferCharacter(cc); 823 m_temporaryBuffer.append(static_cast<LChar>(cc)); 824 HTML_ADVANCE_TO(ScriptDataDoubleEscapeEndState); 825 } else 826 HTML_RECONSUME_IN(ScriptDataDoubleEscapedState); 827 } 828 END_STATE() 829 830 HTML_BEGIN_STATE(BeforeAttributeNameState) { 831 if (isTokenizerWhitespace(cc)) 832 HTML_ADVANCE_TO(BeforeAttributeNameState); 833 else if (cc == '/') 834 HTML_ADVANCE_TO(SelfClosingStartTagState); 835 else if (cc == '>') 836 return emitAndResumeIn(source, HTMLTokenizer::DataState); 837 else if (isASCIIUpper(cc)) { 838 m_token->addNewAttribute(); 839 m_token->beginAttributeName(source.numberOfCharactersConsumed()); 840 m_token->appendToAttributeName(toLowerCase(cc)); 841 HTML_ADVANCE_TO(AttributeNameState); 842 } else if (cc == kEndOfFileMarker) { 843 parseError(); 844 HTML_RECONSUME_IN(DataState); 845 } else { 846 if (cc == '"' || cc == '\'' || cc == '<' || cc == '=') 847 parseError(); 848 m_token->addNewAttribute(); 849 m_token->beginAttributeName(source.numberOfCharactersConsumed()); 850 m_token->appendToAttributeName(cc); 851 HTML_ADVANCE_TO(AttributeNameState); 852 } 853 } 854 END_STATE() 855 856 HTML_BEGIN_STATE(AttributeNameState) { 857 if (isTokenizerWhitespace(cc)) { 858 m_token->endAttributeName(source.numberOfCharactersConsumed()); 859 HTML_ADVANCE_TO(AfterAttributeNameState); 860 } else if (cc == '/') { 861 m_token->endAttributeName(source.numberOfCharactersConsumed()); 862 HTML_ADVANCE_TO(SelfClosingStartTagState); 863 } else if (cc == '=') { 864 m_token->endAttributeName(source.numberOfCharactersConsumed()); 865 HTML_ADVANCE_TO(BeforeAttributeValueState); 866 } else if (cc == '>') { 867 m_token->endAttributeName(source.numberOfCharactersConsumed()); 868 return emitAndResumeIn(source, HTMLTokenizer::DataState); 869 } else if (isASCIIUpper(cc)) { 870 m_token->appendToAttributeName(toLowerCase(cc)); 871 HTML_ADVANCE_TO(AttributeNameState); 872 } else if (cc == kEndOfFileMarker) { 873 parseError(); 874 m_token->endAttributeName(source.numberOfCharactersConsumed()); 875 HTML_RECONSUME_IN(DataState); 876 } else { 877 if (cc == '"' || cc == '\'' || cc == '<' || cc == '=') 878 parseError(); 879 m_token->appendToAttributeName(cc); 880 HTML_ADVANCE_TO(AttributeNameState); 881 } 882 } 883 END_STATE() 884 885 HTML_BEGIN_STATE(AfterAttributeNameState) { 886 if (isTokenizerWhitespace(cc)) 887 HTML_ADVANCE_TO(AfterAttributeNameState); 888 else if (cc == '/') 889 HTML_ADVANCE_TO(SelfClosingStartTagState); 890 else if (cc == '=') 891 HTML_ADVANCE_TO(BeforeAttributeValueState); 892 else if (cc == '>') 893 return emitAndResumeIn(source, HTMLTokenizer::DataState); 894 else if (isASCIIUpper(cc)) { 895 m_token->addNewAttribute(); 896 m_token->beginAttributeName(source.numberOfCharactersConsumed()); 897 m_token->appendToAttributeName(toLowerCase(cc)); 898 HTML_ADVANCE_TO(AttributeNameState); 899 } else if (cc == kEndOfFileMarker) { 900 parseError(); 901 HTML_RECONSUME_IN(DataState); 902 } else { 903 if (cc == '"' || cc == '\'' || cc == '<') 904 parseError(); 905 m_token->addNewAttribute(); 906 m_token->beginAttributeName(source.numberOfCharactersConsumed()); 907 m_token->appendToAttributeName(cc); 908 HTML_ADVANCE_TO(AttributeNameState); 909 } 910 } 911 END_STATE() 912 913 HTML_BEGIN_STATE(BeforeAttributeValueState) { 914 if (isTokenizerWhitespace(cc)) 915 HTML_ADVANCE_TO(BeforeAttributeValueState); 916 else if (cc == '"') { 917 m_token->beginAttributeValue(source.numberOfCharactersConsumed() + 1); 918 HTML_ADVANCE_TO(AttributeValueDoubleQuotedState); 919 } else if (cc == '&') { 920 m_token->beginAttributeValue(source.numberOfCharactersConsumed()); 921 HTML_RECONSUME_IN(AttributeValueUnquotedState); 922 } else if (cc == '\'') { 923 m_token->beginAttributeValue(source.numberOfCharactersConsumed() + 1); 924 HTML_ADVANCE_TO(AttributeValueSingleQuotedState); 925 } else if (cc == '>') { 926 parseError(); 927 return emitAndResumeIn(source, HTMLTokenizer::DataState); 928 } else if (cc == kEndOfFileMarker) { 929 parseError(); 930 HTML_RECONSUME_IN(DataState); 931 } else { 932 if (cc == '<' || cc == '=' || cc == '`') 933 parseError(); 934 m_token->beginAttributeValue(source.numberOfCharactersConsumed()); 935 m_token->appendToAttributeValue(cc); 936 HTML_ADVANCE_TO(AttributeValueUnquotedState); 937 } 938 } 939 END_STATE() 940 941 HTML_BEGIN_STATE(AttributeValueDoubleQuotedState) { 942 if (cc == '"') { 943 m_token->endAttributeValue(source.numberOfCharactersConsumed()); 944 HTML_ADVANCE_TO(AfterAttributeValueQuotedState); 945 } else if (cc == '&') { 946 m_additionalAllowedCharacter = '"'; 947 HTML_ADVANCE_TO(CharacterReferenceInAttributeValueState); 948 } else if (cc == kEndOfFileMarker) { 949 parseError(); 950 m_token->endAttributeValue(source.numberOfCharactersConsumed()); 951 HTML_RECONSUME_IN(DataState); 952 } else { 953 m_token->appendToAttributeValue(cc); 954 HTML_ADVANCE_TO(AttributeValueDoubleQuotedState); 955 } 956 } 957 END_STATE() 958 959 HTML_BEGIN_STATE(AttributeValueSingleQuotedState) { 960 if (cc == '\'') { 961 m_token->endAttributeValue(source.numberOfCharactersConsumed()); 962 HTML_ADVANCE_TO(AfterAttributeValueQuotedState); 963 } else if (cc == '&') { 964 m_additionalAllowedCharacter = '\''; 965 HTML_ADVANCE_TO(CharacterReferenceInAttributeValueState); 966 } else if (cc == kEndOfFileMarker) { 967 parseError(); 968 m_token->endAttributeValue(source.numberOfCharactersConsumed()); 969 HTML_RECONSUME_IN(DataState); 970 } else { 971 m_token->appendToAttributeValue(cc); 972 HTML_ADVANCE_TO(AttributeValueSingleQuotedState); 973 } 974 } 975 END_STATE() 976 977 HTML_BEGIN_STATE(AttributeValueUnquotedState) { 978 if (isTokenizerWhitespace(cc)) { 979 m_token->endAttributeValue(source.numberOfCharactersConsumed()); 980 HTML_ADVANCE_TO(BeforeAttributeNameState); 981 } else if (cc == '&') { 982 m_additionalAllowedCharacter = '>'; 983 HTML_ADVANCE_TO(CharacterReferenceInAttributeValueState); 984 } else if (cc == '>') { 985 m_token->endAttributeValue(source.numberOfCharactersConsumed()); 986 return emitAndResumeIn(source, HTMLTokenizer::DataState); 987 } else if (cc == kEndOfFileMarker) { 988 parseError(); 989 m_token->endAttributeValue(source.numberOfCharactersConsumed()); 990 HTML_RECONSUME_IN(DataState); 991 } else { 992 if (cc == '"' || cc == '\'' || cc == '<' || cc == '=' || cc == '`') 993 parseError(); 994 m_token->appendToAttributeValue(cc); 995 HTML_ADVANCE_TO(AttributeValueUnquotedState); 996 } 997 } 998 END_STATE() 999 1000 HTML_BEGIN_STATE(CharacterReferenceInAttributeValueState) { 1001 bool notEnoughCharacters = false; 1002 DecodedHTMLEntity decodedEntity; 1003 bool success = consumeHTMLEntity(source, decodedEntity, notEnoughCharacters, m_additionalAllowedCharacter); 1004 if (notEnoughCharacters) 1005 return haveBufferedCharacterToken(); 1006 if (!success) { 1007 ASSERT(decodedEntity.isEmpty()); 1008 m_token->appendToAttributeValue('&'); 1009 } else { 1010 for (unsigned i = 0; i < decodedEntity.length; ++i) 1011 m_token->appendToAttributeValue(decodedEntity.data[i]); 1012 } 1013 // We're supposed to switch back to the attribute value state that 1014 // we were in when we were switched into this state. Rather than 1015 // keeping track of this explictly, we observe that the previous 1016 // state can be determined by m_additionalAllowedCharacter. 1017 if (m_additionalAllowedCharacter == '"') 1018 HTML_SWITCH_TO(AttributeValueDoubleQuotedState); 1019 else if (m_additionalAllowedCharacter == '\'') 1020 HTML_SWITCH_TO(AttributeValueSingleQuotedState); 1021 else if (m_additionalAllowedCharacter == '>') 1022 HTML_SWITCH_TO(AttributeValueUnquotedState); 1023 else 1024 ASSERT_NOT_REACHED(); 1025 } 1026 END_STATE() 1027 1028 HTML_BEGIN_STATE(AfterAttributeValueQuotedState) { 1029 if (isTokenizerWhitespace(cc)) 1030 HTML_ADVANCE_TO(BeforeAttributeNameState); 1031 else if (cc == '/') 1032 HTML_ADVANCE_TO(SelfClosingStartTagState); 1033 else if (cc == '>') 1034 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1035 else if (cc == kEndOfFileMarker) { 1036 parseError(); 1037 HTML_RECONSUME_IN(DataState); 1038 } else { 1039 parseError(); 1040 HTML_RECONSUME_IN(BeforeAttributeNameState); 1041 } 1042 } 1043 END_STATE() 1044 1045 HTML_BEGIN_STATE(SelfClosingStartTagState) { 1046 if (cc == '>') { 1047 m_token->setSelfClosing(); 1048 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1049 } else if (cc == kEndOfFileMarker) { 1050 parseError(); 1051 HTML_RECONSUME_IN(DataState); 1052 } else { 1053 parseError(); 1054 HTML_RECONSUME_IN(BeforeAttributeNameState); 1055 } 1056 } 1057 END_STATE() 1058 1059 HTML_BEGIN_STATE(BogusCommentState) { 1060 m_token->beginComment(); 1061 HTML_RECONSUME_IN(ContinueBogusCommentState); 1062 } 1063 END_STATE() 1064 1065 HTML_BEGIN_STATE(ContinueBogusCommentState) { 1066 if (cc == '>') 1067 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1068 else if (cc == kEndOfFileMarker) 1069 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1070 else { 1071 m_token->appendToComment(cc); 1072 HTML_ADVANCE_TO(ContinueBogusCommentState); 1073 } 1074 } 1075 END_STATE() 1076 1077 HTML_BEGIN_STATE(MarkupDeclarationOpenState) { 1078 if (cc == '-') { 1079 SegmentedString::LookAheadResult result = source.lookAhead(HTMLTokenizerNames::dashDash); 1080 if (result == SegmentedString::DidMatch) { 1081 source.advanceAndASSERT('-'); 1082 source.advanceAndASSERT('-'); 1083 m_token->beginComment(); 1084 HTML_SWITCH_TO(CommentStartState); 1085 } else if (result == SegmentedString::NotEnoughCharacters) 1086 return haveBufferedCharacterToken(); 1087 } else if (cc == 'D' || cc == 'd') { 1088 SegmentedString::LookAheadResult result = source.lookAheadIgnoringCase(HTMLTokenizerNames::doctype); 1089 if (result == SegmentedString::DidMatch) { 1090 advanceStringAndASSERTIgnoringCase(source, "doctype"); 1091 HTML_SWITCH_TO(DOCTYPEState); 1092 } else if (result == SegmentedString::NotEnoughCharacters) 1093 return haveBufferedCharacterToken(); 1094 } else if (cc == '[' && shouldAllowCDATA()) { 1095 SegmentedString::LookAheadResult result = source.lookAhead(HTMLTokenizerNames::cdata); 1096 if (result == SegmentedString::DidMatch) { 1097 advanceStringAndASSERT(source, "[CDATA["); 1098 HTML_SWITCH_TO(CDATASectionState); 1099 } else if (result == SegmentedString::NotEnoughCharacters) 1100 return haveBufferedCharacterToken(); 1101 } 1102 parseError(); 1103 HTML_RECONSUME_IN(BogusCommentState); 1104 } 1105 END_STATE() 1106 1107 HTML_BEGIN_STATE(CommentStartState) { 1108 if (cc == '-') 1109 HTML_ADVANCE_TO(CommentStartDashState); 1110 else if (cc == '>') { 1111 parseError(); 1112 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1113 } else if (cc == kEndOfFileMarker) { 1114 parseError(); 1115 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1116 } else { 1117 m_token->appendToComment(cc); 1118 HTML_ADVANCE_TO(CommentState); 1119 } 1120 } 1121 END_STATE() 1122 1123 HTML_BEGIN_STATE(CommentStartDashState) { 1124 if (cc == '-') 1125 HTML_ADVANCE_TO(CommentEndState); 1126 else if (cc == '>') { 1127 parseError(); 1128 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1129 } else if (cc == kEndOfFileMarker) { 1130 parseError(); 1131 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1132 } else { 1133 m_token->appendToComment('-'); 1134 m_token->appendToComment(cc); 1135 HTML_ADVANCE_TO(CommentState); 1136 } 1137 } 1138 END_STATE() 1139 1140 HTML_BEGIN_STATE(CommentState) { 1141 if (cc == '-') 1142 HTML_ADVANCE_TO(CommentEndDashState); 1143 else if (cc == kEndOfFileMarker) { 1144 parseError(); 1145 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1146 } else { 1147 m_token->appendToComment(cc); 1148 HTML_ADVANCE_TO(CommentState); 1149 } 1150 } 1151 END_STATE() 1152 1153 HTML_BEGIN_STATE(CommentEndDashState) { 1154 if (cc == '-') 1155 HTML_ADVANCE_TO(CommentEndState); 1156 else if (cc == kEndOfFileMarker) { 1157 parseError(); 1158 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1159 } else { 1160 m_token->appendToComment('-'); 1161 m_token->appendToComment(cc); 1162 HTML_ADVANCE_TO(CommentState); 1163 } 1164 } 1165 END_STATE() 1166 1167 HTML_BEGIN_STATE(CommentEndState) { 1168 if (cc == '>') 1169 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1170 else if (cc == '!') { 1171 parseError(); 1172 HTML_ADVANCE_TO(CommentEndBangState); 1173 } else if (cc == '-') { 1174 parseError(); 1175 m_token->appendToComment('-'); 1176 HTML_ADVANCE_TO(CommentEndState); 1177 } else if (cc == kEndOfFileMarker) { 1178 parseError(); 1179 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1180 } else { 1181 parseError(); 1182 m_token->appendToComment('-'); 1183 m_token->appendToComment('-'); 1184 m_token->appendToComment(cc); 1185 HTML_ADVANCE_TO(CommentState); 1186 } 1187 } 1188 END_STATE() 1189 1190 HTML_BEGIN_STATE(CommentEndBangState) { 1191 if (cc == '-') { 1192 m_token->appendToComment('-'); 1193 m_token->appendToComment('-'); 1194 m_token->appendToComment('!'); 1195 HTML_ADVANCE_TO(CommentEndDashState); 1196 } else if (cc == '>') 1197 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1198 else if (cc == kEndOfFileMarker) { 1199 parseError(); 1200 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1201 } else { 1202 m_token->appendToComment('-'); 1203 m_token->appendToComment('-'); 1204 m_token->appendToComment('!'); 1205 m_token->appendToComment(cc); 1206 HTML_ADVANCE_TO(CommentState); 1207 } 1208 } 1209 END_STATE() 1210 1211 HTML_BEGIN_STATE(DOCTYPEState) { 1212 if (isTokenizerWhitespace(cc)) 1213 HTML_ADVANCE_TO(BeforeDOCTYPENameState); 1214 else if (cc == kEndOfFileMarker) { 1215 parseError(); 1216 m_token->beginDOCTYPE(); 1217 m_token->setForceQuirks(); 1218 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1219 } else { 1220 parseError(); 1221 HTML_RECONSUME_IN(BeforeDOCTYPENameState); 1222 } 1223 } 1224 END_STATE() 1225 1226 HTML_BEGIN_STATE(BeforeDOCTYPENameState) { 1227 if (isTokenizerWhitespace(cc)) 1228 HTML_ADVANCE_TO(BeforeDOCTYPENameState); 1229 else if (isASCIIUpper(cc)) { 1230 m_token->beginDOCTYPE(toLowerCase(cc)); 1231 HTML_ADVANCE_TO(DOCTYPENameState); 1232 } else if (cc == '>') { 1233 parseError(); 1234 m_token->beginDOCTYPE(); 1235 m_token->setForceQuirks(); 1236 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1237 } else if (cc == kEndOfFileMarker) { 1238 parseError(); 1239 m_token->beginDOCTYPE(); 1240 m_token->setForceQuirks(); 1241 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1242 } else { 1243 m_token->beginDOCTYPE(cc); 1244 HTML_ADVANCE_TO(DOCTYPENameState); 1245 } 1246 } 1247 END_STATE() 1248 1249 HTML_BEGIN_STATE(DOCTYPENameState) { 1250 if (isTokenizerWhitespace(cc)) 1251 HTML_ADVANCE_TO(AfterDOCTYPENameState); 1252 else if (cc == '>') 1253 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1254 else if (isASCIIUpper(cc)) { 1255 m_token->appendToName(toLowerCase(cc)); 1256 HTML_ADVANCE_TO(DOCTYPENameState); 1257 } else if (cc == kEndOfFileMarker) { 1258 parseError(); 1259 m_token->setForceQuirks(); 1260 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1261 } else { 1262 m_token->appendToName(cc); 1263 HTML_ADVANCE_TO(DOCTYPENameState); 1264 } 1265 } 1266 END_STATE() 1267 1268 HTML_BEGIN_STATE(AfterDOCTYPENameState) { 1269 if (isTokenizerWhitespace(cc)) 1270 HTML_ADVANCE_TO(AfterDOCTYPENameState); 1271 if (cc == '>') 1272 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1273 else if (cc == kEndOfFileMarker) { 1274 parseError(); 1275 m_token->setForceQuirks(); 1276 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1277 } else { 1278 if (cc == 'P' || cc == 'p') { 1279 SegmentedString::LookAheadResult result = source.lookAheadIgnoringCase(HTMLTokenizerNames::publicString); 1280 if (result == SegmentedString::DidMatch) { 1281 advanceStringAndASSERTIgnoringCase(source, "public"); 1282 HTML_SWITCH_TO(AfterDOCTYPEPublicKeywordState); 1283 } else if (result == SegmentedString::NotEnoughCharacters) 1284 return haveBufferedCharacterToken(); 1285 } else if (cc == 'S' || cc == 's') { 1286 SegmentedString::LookAheadResult result = source.lookAheadIgnoringCase(HTMLTokenizerNames::system); 1287 if (result == SegmentedString::DidMatch) { 1288 advanceStringAndASSERTIgnoringCase(source, "system"); 1289 HTML_SWITCH_TO(AfterDOCTYPESystemKeywordState); 1290 } else if (result == SegmentedString::NotEnoughCharacters) 1291 return haveBufferedCharacterToken(); 1292 } 1293 parseError(); 1294 m_token->setForceQuirks(); 1295 HTML_ADVANCE_TO(BogusDOCTYPEState); 1296 } 1297 } 1298 END_STATE() 1299 1300 HTML_BEGIN_STATE(AfterDOCTYPEPublicKeywordState) { 1301 if (isTokenizerWhitespace(cc)) 1302 HTML_ADVANCE_TO(BeforeDOCTYPEPublicIdentifierState); 1303 else if (cc == '"') { 1304 parseError(); 1305 m_token->setPublicIdentifierToEmptyString(); 1306 HTML_ADVANCE_TO(DOCTYPEPublicIdentifierDoubleQuotedState); 1307 } else if (cc == '\'') { 1308 parseError(); 1309 m_token->setPublicIdentifierToEmptyString(); 1310 HTML_ADVANCE_TO(DOCTYPEPublicIdentifierSingleQuotedState); 1311 } else if (cc == '>') { 1312 parseError(); 1313 m_token->setForceQuirks(); 1314 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1315 } else if (cc == kEndOfFileMarker) { 1316 parseError(); 1317 m_token->setForceQuirks(); 1318 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1319 } else { 1320 parseError(); 1321 m_token->setForceQuirks(); 1322 HTML_ADVANCE_TO(BogusDOCTYPEState); 1323 } 1324 } 1325 END_STATE() 1326 1327 HTML_BEGIN_STATE(BeforeDOCTYPEPublicIdentifierState) { 1328 if (isTokenizerWhitespace(cc)) 1329 HTML_ADVANCE_TO(BeforeDOCTYPEPublicIdentifierState); 1330 else if (cc == '"') { 1331 m_token->setPublicIdentifierToEmptyString(); 1332 HTML_ADVANCE_TO(DOCTYPEPublicIdentifierDoubleQuotedState); 1333 } else if (cc == '\'') { 1334 m_token->setPublicIdentifierToEmptyString(); 1335 HTML_ADVANCE_TO(DOCTYPEPublicIdentifierSingleQuotedState); 1336 } else if (cc == '>') { 1337 parseError(); 1338 m_token->setForceQuirks(); 1339 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1340 } else if (cc == kEndOfFileMarker) { 1341 parseError(); 1342 m_token->setForceQuirks(); 1343 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1344 } else { 1345 parseError(); 1346 m_token->setForceQuirks(); 1347 HTML_ADVANCE_TO(BogusDOCTYPEState); 1348 } 1349 } 1350 END_STATE() 1351 1352 HTML_BEGIN_STATE(DOCTYPEPublicIdentifierDoubleQuotedState) { 1353 if (cc == '"') 1354 HTML_ADVANCE_TO(AfterDOCTYPEPublicIdentifierState); 1355 else if (cc == '>') { 1356 parseError(); 1357 m_token->setForceQuirks(); 1358 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1359 } else if (cc == kEndOfFileMarker) { 1360 parseError(); 1361 m_token->setForceQuirks(); 1362 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1363 } else { 1364 m_token->appendToPublicIdentifier(cc); 1365 HTML_ADVANCE_TO(DOCTYPEPublicIdentifierDoubleQuotedState); 1366 } 1367 } 1368 END_STATE() 1369 1370 HTML_BEGIN_STATE(DOCTYPEPublicIdentifierSingleQuotedState) { 1371 if (cc == '\'') 1372 HTML_ADVANCE_TO(AfterDOCTYPEPublicIdentifierState); 1373 else if (cc == '>') { 1374 parseError(); 1375 m_token->setForceQuirks(); 1376 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1377 } else if (cc == kEndOfFileMarker) { 1378 parseError(); 1379 m_token->setForceQuirks(); 1380 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1381 } else { 1382 m_token->appendToPublicIdentifier(cc); 1383 HTML_ADVANCE_TO(DOCTYPEPublicIdentifierSingleQuotedState); 1384 } 1385 } 1386 END_STATE() 1387 1388 HTML_BEGIN_STATE(AfterDOCTYPEPublicIdentifierState) { 1389 if (isTokenizerWhitespace(cc)) 1390 HTML_ADVANCE_TO(BetweenDOCTYPEPublicAndSystemIdentifiersState); 1391 else if (cc == '>') 1392 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1393 else if (cc == '"') { 1394 parseError(); 1395 m_token->setSystemIdentifierToEmptyString(); 1396 HTML_ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState); 1397 } else if (cc == '\'') { 1398 parseError(); 1399 m_token->setSystemIdentifierToEmptyString(); 1400 HTML_ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState); 1401 } else if (cc == kEndOfFileMarker) { 1402 parseError(); 1403 m_token->setForceQuirks(); 1404 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1405 } else { 1406 parseError(); 1407 m_token->setForceQuirks(); 1408 HTML_ADVANCE_TO(BogusDOCTYPEState); 1409 } 1410 } 1411 END_STATE() 1412 1413 HTML_BEGIN_STATE(BetweenDOCTYPEPublicAndSystemIdentifiersState) { 1414 if (isTokenizerWhitespace(cc)) 1415 HTML_ADVANCE_TO(BetweenDOCTYPEPublicAndSystemIdentifiersState); 1416 else if (cc == '>') 1417 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1418 else if (cc == '"') { 1419 m_token->setSystemIdentifierToEmptyString(); 1420 HTML_ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState); 1421 } else if (cc == '\'') { 1422 m_token->setSystemIdentifierToEmptyString(); 1423 HTML_ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState); 1424 } else if (cc == kEndOfFileMarker) { 1425 parseError(); 1426 m_token->setForceQuirks(); 1427 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1428 } else { 1429 parseError(); 1430 m_token->setForceQuirks(); 1431 HTML_ADVANCE_TO(BogusDOCTYPEState); 1432 } 1433 } 1434 END_STATE() 1435 1436 HTML_BEGIN_STATE(AfterDOCTYPESystemKeywordState) { 1437 if (isTokenizerWhitespace(cc)) 1438 HTML_ADVANCE_TO(BeforeDOCTYPESystemIdentifierState); 1439 else if (cc == '"') { 1440 parseError(); 1441 m_token->setSystemIdentifierToEmptyString(); 1442 HTML_ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState); 1443 } else if (cc == '\'') { 1444 parseError(); 1445 m_token->setSystemIdentifierToEmptyString(); 1446 HTML_ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState); 1447 } else if (cc == '>') { 1448 parseError(); 1449 m_token->setForceQuirks(); 1450 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1451 } else if (cc == kEndOfFileMarker) { 1452 parseError(); 1453 m_token->setForceQuirks(); 1454 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1455 } else { 1456 parseError(); 1457 m_token->setForceQuirks(); 1458 HTML_ADVANCE_TO(BogusDOCTYPEState); 1459 } 1460 } 1461 END_STATE() 1462 1463 HTML_BEGIN_STATE(BeforeDOCTYPESystemIdentifierState) { 1464 if (isTokenizerWhitespace(cc)) 1465 HTML_ADVANCE_TO(BeforeDOCTYPESystemIdentifierState); 1466 if (cc == '"') { 1467 m_token->setSystemIdentifierToEmptyString(); 1468 HTML_ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState); 1469 } else if (cc == '\'') { 1470 m_token->setSystemIdentifierToEmptyString(); 1471 HTML_ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState); 1472 } else if (cc == '>') { 1473 parseError(); 1474 m_token->setForceQuirks(); 1475 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1476 } else if (cc == kEndOfFileMarker) { 1477 parseError(); 1478 m_token->setForceQuirks(); 1479 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1480 } else { 1481 parseError(); 1482 m_token->setForceQuirks(); 1483 HTML_ADVANCE_TO(BogusDOCTYPEState); 1484 } 1485 } 1486 END_STATE() 1487 1488 HTML_BEGIN_STATE(DOCTYPESystemIdentifierDoubleQuotedState) { 1489 if (cc == '"') 1490 HTML_ADVANCE_TO(AfterDOCTYPESystemIdentifierState); 1491 else if (cc == '>') { 1492 parseError(); 1493 m_token->setForceQuirks(); 1494 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1495 } else if (cc == kEndOfFileMarker) { 1496 parseError(); 1497 m_token->setForceQuirks(); 1498 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1499 } else { 1500 m_token->appendToSystemIdentifier(cc); 1501 HTML_ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState); 1502 } 1503 } 1504 END_STATE() 1505 1506 HTML_BEGIN_STATE(DOCTYPESystemIdentifierSingleQuotedState) { 1507 if (cc == '\'') 1508 HTML_ADVANCE_TO(AfterDOCTYPESystemIdentifierState); 1509 else if (cc == '>') { 1510 parseError(); 1511 m_token->setForceQuirks(); 1512 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1513 } else if (cc == kEndOfFileMarker) { 1514 parseError(); 1515 m_token->setForceQuirks(); 1516 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1517 } else { 1518 m_token->appendToSystemIdentifier(cc); 1519 HTML_ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState); 1520 } 1521 } 1522 END_STATE() 1523 1524 HTML_BEGIN_STATE(AfterDOCTYPESystemIdentifierState) { 1525 if (isTokenizerWhitespace(cc)) 1526 HTML_ADVANCE_TO(AfterDOCTYPESystemIdentifierState); 1527 else if (cc == '>') 1528 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1529 else if (cc == kEndOfFileMarker) { 1530 parseError(); 1531 m_token->setForceQuirks(); 1532 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1533 } else { 1534 parseError(); 1535 HTML_ADVANCE_TO(BogusDOCTYPEState); 1536 } 1537 } 1538 END_STATE() 1539 1540 HTML_BEGIN_STATE(BogusDOCTYPEState) { 1541 if (cc == '>') 1542 return emitAndResumeIn(source, HTMLTokenizer::DataState); 1543 else if (cc == kEndOfFileMarker) 1544 return emitAndReconsumeIn(source, HTMLTokenizer::DataState); 1545 HTML_ADVANCE_TO(BogusDOCTYPEState); 1546 } 1547 END_STATE() 1548 1549 HTML_BEGIN_STATE(CDATASectionState) { 1550 if (cc == ']') 1551 HTML_ADVANCE_TO(CDATASectionRightSquareBracketState); 1552 else if (cc == kEndOfFileMarker) 1553 HTML_RECONSUME_IN(DataState); 1554 else { 1555 bufferCharacter(cc); 1556 HTML_ADVANCE_TO(CDATASectionState); 1557 } 1558 } 1559 END_STATE() 1560 1561 HTML_BEGIN_STATE(CDATASectionRightSquareBracketState) { 1562 if (cc == ']') 1563 HTML_ADVANCE_TO(CDATASectionDoubleRightSquareBracketState); 1564 else { 1565 bufferCharacter(']'); 1566 HTML_RECONSUME_IN(CDATASectionState); 1567 } 1568 } 1569 1570 HTML_BEGIN_STATE(CDATASectionDoubleRightSquareBracketState) { 1571 if (cc == '>') 1572 HTML_ADVANCE_TO(DataState); 1573 else { 1574 bufferCharacter(']'); 1575 bufferCharacter(']'); 1576 HTML_RECONSUME_IN(CDATASectionState); 1577 } 1578 } 1579 END_STATE() 1580 1581 } 1582 1583 ASSERT_NOT_REACHED(); 1584 return false; 1585 } 1586 1587 String HTMLTokenizer::bufferedCharacters() const 1588 { 1589 // FIXME: Add an assert about m_state. 1590 StringBuilder characters; 1591 characters.reserveCapacity(numberOfBufferedCharacters()); 1592 characters.append('<'); 1593 characters.append('/'); 1594 characters.append(m_temporaryBuffer.data(), m_temporaryBuffer.size()); 1595 return characters.toString(); 1596 } 1597 1598 void HTMLTokenizer::updateStateFor(const String& tagName) 1599 { 1600 if (threadSafeMatch(tagName, textareaTag) || threadSafeMatch(tagName, titleTag)) 1601 setState(HTMLTokenizer::RCDATAState); 1602 else if (threadSafeMatch(tagName, plaintextTag)) 1603 setState(HTMLTokenizer::PLAINTEXTState); 1604 else if (threadSafeMatch(tagName, scriptTag)) 1605 setState(HTMLTokenizer::ScriptDataState); 1606 else if (threadSafeMatch(tagName, styleTag) 1607 || threadSafeMatch(tagName, iframeTag) 1608 || threadSafeMatch(tagName, xmpTag) 1609 || (threadSafeMatch(tagName, noembedTag) && m_options.pluginsEnabled) 1610 || threadSafeMatch(tagName, noframesTag) 1611 || (threadSafeMatch(tagName, noscriptTag) && m_options.scriptEnabled)) 1612 setState(HTMLTokenizer::RAWTEXTState); 1613 } 1614 1615 inline bool HTMLTokenizer::temporaryBufferIs(const String& expectedString) 1616 { 1617 return vectorEqualsString(m_temporaryBuffer, expectedString); 1618 } 1619 1620 inline void HTMLTokenizer::addToPossibleEndTag(LChar cc) 1621 { 1622 ASSERT(isEndTagBufferingState(m_state)); 1623 m_bufferedEndTagName.append(cc); 1624 } 1625 1626 inline bool HTMLTokenizer::isAppropriateEndTag() 1627 { 1628 if (m_bufferedEndTagName.size() != m_appropriateEndTagName.size()) 1629 return false; 1630 1631 size_t numCharacters = m_bufferedEndTagName.size(); 1632 1633 for (size_t i = 0; i < numCharacters; i++) { 1634 if (m_bufferedEndTagName[i] != m_appropriateEndTagName[i]) 1635 return false; 1636 } 1637 1638 return true; 1639 } 1640 1641 inline void HTMLTokenizer::parseError() 1642 { 1643 notImplemented(); 1644 } 1645 1646 } 1647
