2 * Copyright (c) 2005-2007 Henri Sivonen
3 * Copyright (c) 2007-2017 Mozilla Foundation
4 * Portions of comments Copyright 2004-2010 Apple Computer, Inc., Mozilla
5 * Foundation, and Opera Software ASA.
7 * Permission is hereby granted, free of charge, to any person obtaining a
8 * copy of this software and associated documentation files (the "Software"),
9 * to deal in the Software without restriction, including without limitation
10 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
11 * and/or sell copies of the Software, and to permit persons to whom the
12 * Software is furnished to do so, subject to the following conditions:
14 * The above copyright notice and this permission notice shall be included in
15 * all copies or substantial portions of the Software.
17 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
18 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
19 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
20 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
21 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
22 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
23 * DEALINGS IN THE SOFTWARE.
27 * THIS IS A GENERATED FILE. PLEASE DO NOT EDIT.
28 * Please edit Tokenizer.java instead and regenerate.
31 #define nsHtml5Tokenizer_cpp__
33 #include "nsHtml5AttributeName.h"
34 #include "nsHtml5ElementName.h"
35 #include "nsHtml5TreeBuilder.h"
36 #include "nsHtml5StackNode.h"
37 #include "nsHtml5UTF16Buffer.h"
38 #include "nsHtml5StateSnapshot.h"
39 #include "nsHtml5Portability.h"
41 #include "nsHtml5Tokenizer.h"
43 #include "nsHtml5TokenizerLoopPolicies.h"
45 char16_t
nsHtml5Tokenizer::LT_GT
[] = {'<', '>'};
46 char16_t
nsHtml5Tokenizer::LT_SOLIDUS
[] = {'<', '/'};
47 char16_t
nsHtml5Tokenizer::RSQB_RSQB
[] = {']', ']'};
48 char16_t
nsHtml5Tokenizer::REPLACEMENT_CHARACTER
[] = {0xfffd};
49 char16_t
nsHtml5Tokenizer::LF
[] = {'\n'};
50 char16_t
nsHtml5Tokenizer::CDATA_LSQB
[] = {'C', 'D', 'A', 'T', 'A', '['};
51 char16_t
nsHtml5Tokenizer::OCTYPE
[] = {'o', 'c', 't', 'y', 'p', 'e'};
52 char16_t
nsHtml5Tokenizer::UBLIC
[] = {'u', 'b', 'l', 'i', 'c'};
53 char16_t
nsHtml5Tokenizer::YSTEM
[] = {'y', 's', 't', 'e', 'm'};
54 static char16_t
const TITLE_ARR_DATA
[] = {'t', 'i', 't', 'l', 'e'};
55 staticJArray
<char16_t
, int32_t> nsHtml5Tokenizer::TITLE_ARR
= {
56 TITLE_ARR_DATA
, MOZ_ARRAY_LENGTH(TITLE_ARR_DATA
)};
57 static char16_t
const SCRIPT_ARR_DATA
[] = {'s', 'c', 'r', 'i', 'p', 't'};
58 staticJArray
<char16_t
, int32_t> nsHtml5Tokenizer::SCRIPT_ARR
= {
59 SCRIPT_ARR_DATA
, MOZ_ARRAY_LENGTH(SCRIPT_ARR_DATA
)};
60 static char16_t
const STYLE_ARR_DATA
[] = {'s', 't', 'y', 'l', 'e'};
61 staticJArray
<char16_t
, int32_t> nsHtml5Tokenizer::STYLE_ARR
= {
62 STYLE_ARR_DATA
, MOZ_ARRAY_LENGTH(STYLE_ARR_DATA
)};
63 static char16_t
const PLAINTEXT_ARR_DATA
[] = {'p', 'l', 'a', 'i', 'n',
65 staticJArray
<char16_t
, int32_t> nsHtml5Tokenizer::PLAINTEXT_ARR
= {
66 PLAINTEXT_ARR_DATA
, MOZ_ARRAY_LENGTH(PLAINTEXT_ARR_DATA
)};
67 static char16_t
const XMP_ARR_DATA
[] = {'x', 'm', 'p'};
68 staticJArray
<char16_t
, int32_t> nsHtml5Tokenizer::XMP_ARR
= {
69 XMP_ARR_DATA
, MOZ_ARRAY_LENGTH(XMP_ARR_DATA
)};
70 static char16_t
const TEXTAREA_ARR_DATA
[] = {'t', 'e', 'x', 't',
72 staticJArray
<char16_t
, int32_t> nsHtml5Tokenizer::TEXTAREA_ARR
= {
73 TEXTAREA_ARR_DATA
, MOZ_ARRAY_LENGTH(TEXTAREA_ARR_DATA
)};
74 static char16_t
const IFRAME_ARR_DATA
[] = {'i', 'f', 'r', 'a', 'm', 'e'};
75 staticJArray
<char16_t
, int32_t> nsHtml5Tokenizer::IFRAME_ARR
= {
76 IFRAME_ARR_DATA
, MOZ_ARRAY_LENGTH(IFRAME_ARR_DATA
)};
77 static char16_t
const NOEMBED_ARR_DATA
[] = {'n', 'o', 'e', 'm', 'b', 'e', 'd'};
78 staticJArray
<char16_t
, int32_t> nsHtml5Tokenizer::NOEMBED_ARR
= {
79 NOEMBED_ARR_DATA
, MOZ_ARRAY_LENGTH(NOEMBED_ARR_DATA
)};
80 static char16_t
const NOSCRIPT_ARR_DATA
[] = {'n', 'o', 's', 'c',
82 staticJArray
<char16_t
, int32_t> nsHtml5Tokenizer::NOSCRIPT_ARR
= {
83 NOSCRIPT_ARR_DATA
, MOZ_ARRAY_LENGTH(NOSCRIPT_ARR_DATA
)};
84 static char16_t
const NOFRAMES_ARR_DATA
[] = {'n', 'o', 'f', 'r',
86 staticJArray
<char16_t
, int32_t> nsHtml5Tokenizer::NOFRAMES_ARR
= {
87 NOFRAMES_ARR_DATA
, MOZ_ARRAY_LENGTH(NOFRAMES_ARR_DATA
)};
89 nsHtml5Tokenizer::nsHtml5Tokenizer(nsHtml5TreeBuilder
* tokenHandler
,
90 bool viewingXmlSource
)
91 : tokenHandler(tokenHandler
),
92 encodingDeclarationHandler(nullptr),
107 suspendAfterCurrentNonTextToken(false),
110 charRefBuf(jArray
<char16_t
, int32_t>::newJArray(32)),
112 bmpChar(jArray
<char16_t
, int32_t>::newJArray(1)),
113 astralChar(jArray
<char16_t
, int32_t>::newJArray(2)),
114 endTagExpectation(nullptr),
115 endTagExpectationAsArray(nullptr),
117 containsHyphen(false),
119 nonInternedTagName(new nsHtml5ElementName()),
120 attributeName(nullptr),
121 nonInternedAttributeName(new nsHtml5AttributeName()),
122 doctypeName(nullptr),
123 publicIdentifier(nullptr),
124 systemIdentifier(nullptr),
125 attributes(tokenHandler
->HasBuilder() ? new nsHtml5HtmlAttributes(0)
127 newAttributesEachTime(!tokenHandler
->HasBuilder()),
128 shouldSuspend(false),
133 viewingXmlSource(viewingXmlSource
) {
134 MOZ_COUNT_CTOR(nsHtml5Tokenizer
);
137 void nsHtml5Tokenizer::setInterner(nsHtml5AtomTable
* interner
) {
138 this->interner
= interner
;
141 void nsHtml5Tokenizer::initLocation(nsHtml5String newPublicId
,
142 nsHtml5String newSystemId
) {
143 this->systemId
= newSystemId
;
144 this->publicId
= newPublicId
;
147 bool nsHtml5Tokenizer::isViewingXmlSource() { return viewingXmlSource
; }
149 void nsHtml5Tokenizer::setState(int32_t specialTokenizerState
) {
150 this->stateSave
= specialTokenizerState
;
151 this->endTagExpectation
= nullptr;
152 this->endTagExpectationAsArray
= nullptr;
155 void nsHtml5Tokenizer::setStateAndEndTagExpectation(
156 int32_t specialTokenizerState
, nsHtml5ElementName
* endTagExpectation
) {
157 this->stateSave
= specialTokenizerState
;
158 this->endTagExpectation
= endTagExpectation
;
159 endTagExpectationToArray();
162 void nsHtml5Tokenizer::endTagExpectationToArray() {
163 switch (endTagExpectation
->getGroup()) {
164 case nsHtml5TreeBuilder::TITLE
: {
165 endTagExpectationAsArray
= TITLE_ARR
;
168 case nsHtml5TreeBuilder::SCRIPT
: {
169 endTagExpectationAsArray
= SCRIPT_ARR
;
172 case nsHtml5TreeBuilder::STYLE
: {
173 endTagExpectationAsArray
= STYLE_ARR
;
176 case nsHtml5TreeBuilder::PLAINTEXT
: {
177 endTagExpectationAsArray
= PLAINTEXT_ARR
;
180 case nsHtml5TreeBuilder::XMP
: {
181 endTagExpectationAsArray
= XMP_ARR
;
184 case nsHtml5TreeBuilder::TEXTAREA
: {
185 endTagExpectationAsArray
= TEXTAREA_ARR
;
188 case nsHtml5TreeBuilder::IFRAME
: {
189 endTagExpectationAsArray
= IFRAME_ARR
;
192 case nsHtml5TreeBuilder::NOEMBED
: {
193 endTagExpectationAsArray
= NOEMBED_ARR
;
196 case nsHtml5TreeBuilder::NOSCRIPT
: {
197 endTagExpectationAsArray
= NOSCRIPT_ARR
;
200 case nsHtml5TreeBuilder::NOFRAMES
: {
201 endTagExpectationAsArray
= NOFRAMES_ARR
;
205 MOZ_ASSERT(false, "Bad end tag expectation.");
211 void nsHtml5Tokenizer::setLineNumber(int32_t line
) {
212 this->attributeLine
= line
;
216 nsHtml5HtmlAttributes
* nsHtml5Tokenizer::emptyAttributes() {
217 return nsHtml5HtmlAttributes::EMPTY_ATTRIBUTES
;
220 void nsHtml5Tokenizer::emitOrAppendCharRefBuf(int32_t returnState
) {
221 if ((returnState
& DATA_AND_RCDATA_MASK
)) {
222 appendCharRefBufToStrBuf();
224 if (charRefBufLen
> 0) {
225 tokenHandler
->characters(charRefBuf
, 0, charRefBufLen
);
231 nsHtml5String
nsHtml5Tokenizer::strBufToString() {
232 nsHtml5String str
= nsHtml5Portability::newStringFromBuffer(
233 strBuf
, 0, strBufLen
, tokenHandler
,
234 !newAttributesEachTime
&&
235 attributeName
== nsHtml5AttributeName::ATTR_CLASS
);
236 clearStrBufAfterUse();
240 void nsHtml5Tokenizer::strBufToDoctypeName() {
242 nsHtml5Portability::newLocalNameFromBuffer(strBuf
, strBufLen
, interner
);
243 clearStrBufAfterUse();
246 void nsHtml5Tokenizer::emitStrBuf() {
248 tokenHandler
->characters(strBuf
, 0, strBufLen
);
249 clearStrBufAfterUse();
253 void nsHtml5Tokenizer::appendStrBuf(char16_t
* buffer
, int32_t offset
,
255 int32_t newLen
= nsHtml5Portability::checkedAdd(strBufLen
, length
);
256 MOZ_ASSERT(newLen
<= strBuf
.length
, "Previous buffer length insufficient.");
257 if (MOZ_UNLIKELY(strBuf
.length
< newLen
)) {
258 if (MOZ_UNLIKELY(!EnsureBufferSpace(length
))) {
259 MOZ_CRASH("Unable to recover from buffer reallocation failure");
262 nsHtml5ArrayCopy::arraycopy(buffer
, offset
, strBuf
, strBufLen
, length
);
266 void nsHtml5Tokenizer::emitComment(int32_t provisionalHyphens
, int32_t pos
) {
268 tokenHandler
->comment(strBuf
, 0, strBufLen
- provisionalHyphens
);
269 clearStrBufAfterUse();
271 suspendIfRequestedAfterCurrentNonTextToken();
274 void nsHtml5Tokenizer::flushChars(char16_t
* buf
, int32_t pos
) {
276 tokenHandler
->characters(buf
, cstart
, pos
- cstart
);
281 void nsHtml5Tokenizer::strBufToElementNameString() {
282 if (containsHyphen
) {
283 nsAtom
* annotationName
= nsHtml5ElementName::ELT_ANNOTATION_XML
->getName();
284 if (nsHtml5Portability::localEqualsBuffer(annotationName
, strBuf
,
286 tagName
= nsHtml5ElementName::ELT_ANNOTATION_XML
;
288 nonInternedTagName
->setNameForNonInterned(
289 nsHtml5Portability::newLocalNameFromBuffer(strBuf
, strBufLen
,
292 tagName
= nonInternedTagName
;
295 tagName
= nsHtml5ElementName::elementNameByBuffer(strBuf
, strBufLen
);
297 nonInternedTagName
->setNameForNonInterned(
298 nsHtml5Portability::newLocalNameFromBuffer(strBuf
, strBufLen
,
301 tagName
= nonInternedTagName
;
304 containsHyphen
= false;
305 clearStrBufAfterUse();
308 int32_t nsHtml5Tokenizer::emitCurrentTagToken(bool selfClosing
, int32_t pos
) {
311 maybeErrSlashInEndTag(selfClosing
);
312 stateSave
= nsHtml5Tokenizer::DATA
;
313 nsHtml5HtmlAttributes
* attrs
=
314 (!attributes
? nsHtml5HtmlAttributes::EMPTY_ATTRIBUTES
: attributes
);
316 maybeErrAttributesOnEndTag(attrs
);
317 if (!viewingXmlSource
) {
318 tokenHandler
->endTag(tagName
);
320 if (newAttributesEachTime
) {
322 attributes
= nullptr;
325 if (viewingXmlSource
) {
326 MOZ_ASSERT(newAttributesEachTime
);
328 attributes
= nullptr;
330 tokenHandler
->startTag(tagName
, attrs
, selfClosing
);
334 if (newAttributesEachTime
) {
335 attributes
= nullptr;
337 attributes
->clear(0);
339 suspendIfRequestedAfterCurrentNonTextToken();
343 void nsHtml5Tokenizer::attributeNameComplete() {
345 nsHtml5AttributeName::nameByBuffer(strBuf
, strBufLen
, interner
);
346 if (!attributeName
) {
347 nonInternedAttributeName
->setNameForNonInterned(
348 nsHtml5Portability::newLocalNameFromBuffer(strBuf
, strBufLen
,
350 attributeName
= nonInternedAttributeName
;
352 clearStrBufAfterUse();
354 attributes
= new nsHtml5HtmlAttributes(0);
356 if (attributes
->contains(attributeName
)) {
357 errDuplicateAttribute();
358 attributeName
= nullptr;
362 void nsHtml5Tokenizer::addAttributeWithoutValue() {
364 attributes
->addAttribute(
365 attributeName
, nsHtml5Portability::newEmptyString(), attributeLine
);
366 attributeName
= nullptr;
368 clearStrBufAfterUse();
372 void nsHtml5Tokenizer::addAttributeWithValue() {
374 nsHtml5String val
= strBufToString();
376 mViewSource
->MaybeLinkifyAttributeValue(attributeName
, val
);
378 attributes
->addAttribute(attributeName
, val
, attributeLine
);
379 attributeName
= nullptr;
381 clearStrBufAfterUse();
385 void nsHtml5Tokenizer::start() {
386 initializeWithoutStarting();
387 tokenHandler
->startTokenization(this);
391 nextCharOnNewLine
= false;
392 } else if (tokenHandler
->WantsLineAndColumn()) {
395 nextCharOnNewLine
= true;
399 nextCharOnNewLine
= false;
403 bool nsHtml5Tokenizer::tokenizeBuffer(nsHtml5UTF16Buffer
* buffer
) {
404 int32_t state
= stateSave
;
405 int32_t returnState
= returnStateSave
;
407 shouldSuspend
= false;
409 int32_t start
= buffer
->getStart();
410 int32_t end
= buffer
->getEnd();
411 int32_t pos
= start
- 1;
419 case SCRIPT_DATA_ESCAPED
:
420 case SCRIPT_DATA_ESCAPE_START
:
421 case SCRIPT_DATA_ESCAPE_START_DASH
:
422 case SCRIPT_DATA_ESCAPED_DASH
:
423 case SCRIPT_DATA_ESCAPED_DASH_DASH
:
424 case SCRIPT_DATA_DOUBLE_ESCAPE_START
:
425 case SCRIPT_DATA_DOUBLE_ESCAPED
:
426 case SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN
:
427 case SCRIPT_DATA_DOUBLE_ESCAPED_DASH
:
428 case SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH
:
429 case SCRIPT_DATA_DOUBLE_ESCAPE_END
: {
439 mViewSource
->SetBuffer(buffer
);
440 pos
= stateLoop
<nsHtml5ViewSourcePolicy
>(state
, c
, pos
, buffer
->getBuffer(),
443 mViewSource
->DropBuffer((pos
== buffer
->getEnd()) ? pos
: pos
+ 1);
444 } else if (tokenHandler
->WantsLineAndColumn()) {
445 pos
= stateLoop
<nsHtml5LineColPolicy
>(state
, c
, pos
, buffer
->getBuffer(),
446 false, returnState
, buffer
->getEnd());
448 pos
= stateLoop
<nsHtml5FastestPolicy
>(state
, c
, pos
, buffer
->getBuffer(),
449 false, returnState
, buffer
->getEnd());
452 buffer
->setStart(pos
);
454 buffer
->setStart(pos
+ 1);
460 int32_t nsHtml5Tokenizer::stateLoop(int32_t state
, char16_t c
, int32_t pos
,
461 char16_t
* buf
, bool reconsume
,
462 int32_t returnState
, int32_t endPos
) {
463 bool reportedConsecutiveHyphens
= false;
472 if (++pos
== endPos
) {
473 NS_HTML5_BREAK(stateloop
);
475 c
= P::checkChar(this, buf
, pos
);
479 flushChars(buf
, pos
);
480 MOZ_ASSERT(!charRefBufLen
,
481 "charRefBufLen not reset after previous use!");
483 setAdditionalAndRememberAmpersandLocation('\0');
486 P::transition(mViewSource
.get(),
487 nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE
,
489 NS_HTML5_CONTINUE(stateloop
);
492 flushChars(buf
, pos
);
493 state
= P::transition(mViewSource
.get(),
494 nsHtml5Tokenizer::TAG_OPEN
, reconsume
, pos
);
495 NS_HTML5_BREAK(dataloop
);
498 maybeEmitReplacementCharacter(buf
, pos
);
502 emitCarriageReturn
<P
>(buf
, pos
);
503 NS_HTML5_BREAK(stateloop
);
506 P::silentLineFeed(this);
519 if (++pos
== endPos
) {
520 NS_HTML5_BREAK(stateloop
);
522 c
= P::checkChar(this, buf
, pos
);
523 if (c
>= 'A' && c
<= 'Z') {
525 clearStrBufBeforeUse();
526 appendStrBuf((char16_t
)(c
+ 0x20));
527 containsHyphen
= false;
528 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::TAG_NAME
,
530 NS_HTML5_BREAK(tagopenloop
);
531 } else if (c
>= 'a' && c
<= 'z') {
533 clearStrBufBeforeUse();
535 containsHyphen
= false;
536 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::TAG_NAME
,
538 NS_HTML5_BREAK(tagopenloop
);
542 state
= P::transition(mViewSource
.get(),
543 nsHtml5Tokenizer::MARKUP_DECLARATION_OPEN
,
545 NS_HTML5_CONTINUE(stateloop
);
548 state
= P::transition(mViewSource
.get(),
549 nsHtml5Tokenizer::CLOSE_TAG_OPEN
, reconsume
,
551 NS_HTML5_CONTINUE(stateloop
);
554 if (viewingXmlSource
) {
555 state
= P::transition(mViewSource
.get(),
556 nsHtml5Tokenizer::PROCESSING_INSTRUCTION
,
558 NS_HTML5_CONTINUE(stateloop
);
560 if (P::reportErrors
) {
561 errProcessingInstruction();
563 clearStrBufBeforeUse();
565 state
= P::transition(mViewSource
.get(),
566 nsHtml5Tokenizer::BOGUS_COMMENT
, reconsume
,
568 NS_HTML5_CONTINUE(stateloop
);
571 if (P::reportErrors
) {
574 tokenHandler
->characters(nsHtml5Tokenizer::LT_GT
, 0, 2);
576 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
578 NS_HTML5_CONTINUE(stateloop
);
581 if (P::reportErrors
) {
582 errBadCharAfterLt(c
);
584 tokenHandler
->characters(nsHtml5Tokenizer::LT_GT
, 0, 1);
587 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
589 NS_HTML5_CONTINUE(stateloop
);
598 if (++pos
== endPos
) {
599 NS_HTML5_BREAK(stateloop
);
601 c
= P::checkChar(this, buf
, pos
);
604 P::silentCarriageReturn(this);
605 strBufToElementNameString();
606 state
= P::transition(mViewSource
.get(),
607 nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME
,
609 NS_HTML5_BREAK(stateloop
);
612 P::silentLineFeed(this);
618 strBufToElementNameString();
619 state
= P::transition(mViewSource
.get(),
620 nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME
,
622 NS_HTML5_BREAK(tagnameloop
);
625 strBufToElementNameString();
626 state
= P::transition(mViewSource
.get(),
627 nsHtml5Tokenizer::SELF_CLOSING_START_TAG
,
629 NS_HTML5_CONTINUE(stateloop
);
632 strBufToElementNameString();
633 state
= P::transition(mViewSource
.get(),
634 emitCurrentTagToken(false, pos
), reconsume
,
637 NS_HTML5_BREAK(stateloop
);
639 NS_HTML5_CONTINUE(stateloop
);
646 if (c
>= 'A' && c
<= 'Z') {
648 } else if (c
== '-') {
649 containsHyphen
= true;
659 case BEFORE_ATTRIBUTE_NAME
: {
664 if (++pos
== endPos
) {
665 NS_HTML5_BREAK(stateloop
);
667 c
= P::checkChar(this, buf
, pos
);
671 P::silentCarriageReturn(this);
672 NS_HTML5_BREAK(stateloop
);
675 P::silentLineFeed(this);
684 state
= P::transition(mViewSource
.get(),
685 nsHtml5Tokenizer::SELF_CLOSING_START_TAG
,
687 NS_HTML5_CONTINUE(stateloop
);
690 state
= P::transition(mViewSource
.get(),
691 emitCurrentTagToken(false, pos
), reconsume
,
694 NS_HTML5_BREAK(stateloop
);
696 NS_HTML5_CONTINUE(stateloop
);
706 if (P::reportErrors
) {
707 errBadCharBeforeAttributeNameOrNull(c
);
712 if (c
>= 'A' && c
<= 'Z') {
715 attributeLine
= line
;
716 clearStrBufBeforeUse();
718 state
= P::transition(mViewSource
.get(),
719 nsHtml5Tokenizer::ATTRIBUTE_NAME
, reconsume
,
721 NS_HTML5_BREAK(beforeattributenameloop
);
725 beforeattributenameloop_end
:;
728 case ATTRIBUTE_NAME
: {
730 if (++pos
== endPos
) {
731 NS_HTML5_BREAK(stateloop
);
733 c
= P::checkChar(this, buf
, pos
);
736 P::silentCarriageReturn(this);
737 attributeNameComplete();
738 state
= P::transition(mViewSource
.get(),
739 nsHtml5Tokenizer::AFTER_ATTRIBUTE_NAME
,
741 NS_HTML5_BREAK(stateloop
);
744 P::silentLineFeed(this);
750 attributeNameComplete();
751 state
= P::transition(mViewSource
.get(),
752 nsHtml5Tokenizer::AFTER_ATTRIBUTE_NAME
,
754 NS_HTML5_CONTINUE(stateloop
);
757 attributeNameComplete();
758 addAttributeWithoutValue();
759 state
= P::transition(mViewSource
.get(),
760 nsHtml5Tokenizer::SELF_CLOSING_START_TAG
,
762 NS_HTML5_CONTINUE(stateloop
);
765 attributeNameComplete();
766 state
= P::transition(mViewSource
.get(),
767 nsHtml5Tokenizer::BEFORE_ATTRIBUTE_VALUE
,
769 NS_HTML5_BREAK(attributenameloop
);
772 attributeNameComplete();
773 addAttributeWithoutValue();
774 state
= P::transition(mViewSource
.get(),
775 emitCurrentTagToken(false, pos
), reconsume
,
778 NS_HTML5_BREAK(stateloop
);
780 NS_HTML5_CONTINUE(stateloop
);
789 if (P::reportErrors
) {
790 errQuoteOrLtInAttributeNameOrNull(c
);
795 if (c
>= 'A' && c
<= 'Z') {
803 attributenameloop_end
:;
806 case BEFORE_ATTRIBUTE_VALUE
: {
808 if (++pos
== endPos
) {
809 NS_HTML5_BREAK(stateloop
);
811 c
= P::checkChar(this, buf
, pos
);
814 P::silentCarriageReturn(this);
815 NS_HTML5_BREAK(stateloop
);
818 P::silentLineFeed(this);
827 attributeLine
= line
;
828 clearStrBufBeforeUse();
830 P::transition(mViewSource
.get(),
831 nsHtml5Tokenizer::ATTRIBUTE_VALUE_DOUBLE_QUOTED
,
833 NS_HTML5_BREAK(beforeattributevalueloop
);
836 attributeLine
= line
;
837 clearStrBufBeforeUse();
839 state
= P::transition(mViewSource
.get(),
840 nsHtml5Tokenizer::ATTRIBUTE_VALUE_UNQUOTED
,
843 NS_HTML5_CONTINUE(stateloop
);
846 attributeLine
= line
;
847 clearStrBufBeforeUse();
849 P::transition(mViewSource
.get(),
850 nsHtml5Tokenizer::ATTRIBUTE_VALUE_SINGLE_QUOTED
,
852 NS_HTML5_CONTINUE(stateloop
);
855 if (P::reportErrors
) {
856 errAttributeValueMissing();
858 addAttributeWithoutValue();
859 state
= P::transition(mViewSource
.get(),
860 emitCurrentTagToken(false, pos
), reconsume
,
863 NS_HTML5_BREAK(stateloop
);
865 NS_HTML5_CONTINUE(stateloop
);
874 if (P::reportErrors
) {
875 errLtOrEqualsOrGraveInUnquotedAttributeOrNull(c
);
880 attributeLine
= line
;
881 clearStrBufBeforeUse();
883 state
= P::transition(mViewSource
.get(),
884 nsHtml5Tokenizer::ATTRIBUTE_VALUE_UNQUOTED
,
887 NS_HTML5_CONTINUE(stateloop
);
891 beforeattributevalueloop_end
:;
894 case ATTRIBUTE_VALUE_DOUBLE_QUOTED
: {
899 if (++pos
== endPos
) {
900 NS_HTML5_BREAK(stateloop
);
902 c
= P::checkChar(this, buf
, pos
);
906 addAttributeWithValue();
908 P::transition(mViewSource
.get(),
909 nsHtml5Tokenizer::AFTER_ATTRIBUTE_VALUE_QUOTED
,
911 NS_HTML5_BREAK(attributevaluedoublequotedloop
);
914 MOZ_ASSERT(!charRefBufLen
,
915 "charRefBufLen not reset after previous use!");
917 setAdditionalAndRememberAmpersandLocation('\"');
920 P::transition(mViewSource
.get(),
921 nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE
,
923 NS_HTML5_CONTINUE(stateloop
);
926 appendStrBufCarriageReturn
<P
>();
927 NS_HTML5_BREAK(stateloop
);
930 appendStrBufLineFeed
<P
>();
943 attributevaluedoublequotedloop_end
:;
946 case AFTER_ATTRIBUTE_VALUE_QUOTED
: {
948 if (++pos
== endPos
) {
949 NS_HTML5_BREAK(stateloop
);
951 c
= P::checkChar(this, buf
, pos
);
954 P::silentCarriageReturn(this);
955 state
= P::transition(mViewSource
.get(),
956 nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME
,
958 NS_HTML5_BREAK(stateloop
);
961 P::silentLineFeed(this);
967 state
= P::transition(mViewSource
.get(),
968 nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME
,
970 NS_HTML5_CONTINUE(stateloop
);
973 state
= P::transition(mViewSource
.get(),
974 nsHtml5Tokenizer::SELF_CLOSING_START_TAG
,
976 NS_HTML5_BREAK(afterattributevaluequotedloop
);
979 state
= P::transition(mViewSource
.get(),
980 emitCurrentTagToken(false, pos
), reconsume
,
983 NS_HTML5_BREAK(stateloop
);
985 NS_HTML5_CONTINUE(stateloop
);
988 if (P::reportErrors
) {
989 errNoSpaceBetweenAttributes();
992 state
= P::transition(mViewSource
.get(),
993 nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME
,
995 NS_HTML5_CONTINUE(stateloop
);
999 afterattributevaluequotedloop_end
:;
1002 case SELF_CLOSING_START_TAG
: {
1003 if (++pos
== endPos
) {
1004 NS_HTML5_BREAK(stateloop
);
1006 c
= P::checkChar(this, buf
, pos
);
1010 P::transition(mViewSource
.get(), emitCurrentTagToken(true, pos
),
1012 if (shouldSuspend
) {
1013 NS_HTML5_BREAK(stateloop
);
1015 NS_HTML5_CONTINUE(stateloop
);
1018 if (P::reportErrors
) {
1019 errSlashNotFollowedByGt();
1022 state
= P::transition(mViewSource
.get(),
1023 nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME
,
1025 NS_HTML5_CONTINUE(stateloop
);
1029 case ATTRIBUTE_VALUE_UNQUOTED
: {
1034 if (++pos
== endPos
) {
1035 NS_HTML5_BREAK(stateloop
);
1037 c
= P::checkChar(this, buf
, pos
);
1041 P::silentCarriageReturn(this);
1042 addAttributeWithValue();
1043 state
= P::transition(mViewSource
.get(),
1044 nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME
,
1046 NS_HTML5_BREAK(stateloop
);
1049 P::silentLineFeed(this);
1055 addAttributeWithValue();
1056 state
= P::transition(mViewSource
.get(),
1057 nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME
,
1059 NS_HTML5_CONTINUE(stateloop
);
1062 MOZ_ASSERT(!charRefBufLen
,
1063 "charRefBufLen not reset after previous use!");
1064 appendCharRefBuf(c
);
1065 setAdditionalAndRememberAmpersandLocation('>');
1066 returnState
= state
;
1068 P::transition(mViewSource
.get(),
1069 nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE
,
1071 NS_HTML5_CONTINUE(stateloop
);
1074 addAttributeWithValue();
1075 state
= P::transition(mViewSource
.get(),
1076 emitCurrentTagToken(false, pos
), reconsume
,
1078 if (shouldSuspend
) {
1079 NS_HTML5_BREAK(stateloop
);
1081 NS_HTML5_CONTINUE(stateloop
);
1092 if (P::reportErrors
) {
1093 errUnquotedAttributeValOrNull(c
);
1104 case AFTER_ATTRIBUTE_NAME
: {
1106 if (++pos
== endPos
) {
1107 NS_HTML5_BREAK(stateloop
);
1109 c
= P::checkChar(this, buf
, pos
);
1112 P::silentCarriageReturn(this);
1113 NS_HTML5_BREAK(stateloop
);
1116 P::silentLineFeed(this);
1125 addAttributeWithoutValue();
1126 state
= P::transition(mViewSource
.get(),
1127 nsHtml5Tokenizer::SELF_CLOSING_START_TAG
,
1129 NS_HTML5_CONTINUE(stateloop
);
1132 state
= P::transition(mViewSource
.get(),
1133 nsHtml5Tokenizer::BEFORE_ATTRIBUTE_VALUE
,
1135 NS_HTML5_CONTINUE(stateloop
);
1138 addAttributeWithoutValue();
1139 state
= P::transition(mViewSource
.get(),
1140 emitCurrentTagToken(false, pos
), reconsume
,
1142 if (shouldSuspend
) {
1143 NS_HTML5_BREAK(stateloop
);
1145 NS_HTML5_CONTINUE(stateloop
);
1154 if (P::reportErrors
) {
1155 errQuoteOrLtInAttributeNameOrNull(c
);
1160 addAttributeWithoutValue();
1161 if (c
>= 'A' && c
<= 'Z') {
1164 clearStrBufBeforeUse();
1166 state
= P::transition(mViewSource
.get(),
1167 nsHtml5Tokenizer::ATTRIBUTE_NAME
, reconsume
,
1169 NS_HTML5_CONTINUE(stateloop
);
1174 case MARKUP_DECLARATION_OPEN
: {
1176 if (++pos
== endPos
) {
1177 NS_HTML5_BREAK(stateloop
);
1179 c
= P::checkChar(this, buf
, pos
);
1182 clearStrBufBeforeUse();
1184 state
= P::transition(mViewSource
.get(),
1185 nsHtml5Tokenizer::MARKUP_DECLARATION_HYPHEN
,
1187 NS_HTML5_BREAK(markupdeclarationopenloop
);
1191 clearStrBufBeforeUse();
1194 state
= P::transition(mViewSource
.get(),
1195 nsHtml5Tokenizer::MARKUP_DECLARATION_OCTYPE
,
1197 NS_HTML5_CONTINUE(stateloop
);
1200 if (tokenHandler
->cdataSectionAllowed()) {
1201 clearStrBufBeforeUse();
1204 state
= P::transition(mViewSource
.get(),
1205 nsHtml5Tokenizer::CDATA_START
, reconsume
,
1207 NS_HTML5_CONTINUE(stateloop
);
1212 if (P::reportErrors
) {
1215 clearStrBufBeforeUse();
1217 state
= P::transition(mViewSource
.get(),
1218 nsHtml5Tokenizer::BOGUS_COMMENT
, reconsume
,
1220 NS_HTML5_CONTINUE(stateloop
);
1224 markupdeclarationopenloop_end
:;
1227 case MARKUP_DECLARATION_HYPHEN
: {
1229 if (++pos
== endPos
) {
1230 NS_HTML5_BREAK(stateloop
);
1232 c
= P::checkChar(this, buf
, pos
);
1235 clearStrBufAfterOneHyphen();
1236 state
= P::transition(mViewSource
.get(),
1237 nsHtml5Tokenizer::COMMENT_START
, reconsume
,
1239 NS_HTML5_BREAK(markupdeclarationhyphenloop
);
1242 if (P::reportErrors
) {
1246 state
= P::transition(mViewSource
.get(),
1247 nsHtml5Tokenizer::BOGUS_COMMENT
, reconsume
,
1249 NS_HTML5_CONTINUE(stateloop
);
1253 markupdeclarationhyphenloop_end
:;
1256 case COMMENT_START
: {
1257 reportedConsecutiveHyphens
= false;
1259 if (++pos
== endPos
) {
1260 NS_HTML5_BREAK(stateloop
);
1262 c
= P::checkChar(this, buf
, pos
);
1266 state
= P::transition(mViewSource
.get(),
1267 nsHtml5Tokenizer::COMMENT_START_DASH
,
1269 NS_HTML5_CONTINUE(stateloop
);
1272 if (P::reportErrors
) {
1273 errPrematureEndOfComment();
1275 emitComment(0, pos
);
1276 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
1278 if (shouldSuspend
) {
1279 NS_HTML5_BREAK(stateloop
);
1281 NS_HTML5_CONTINUE(stateloop
);
1285 state
= P::transition(mViewSource
.get(),
1286 nsHtml5Tokenizer::COMMENT_LESSTHAN
,
1288 NS_HTML5_CONTINUE(stateloop
);
1291 appendStrBufCarriageReturn
<P
>();
1292 state
= P::transition(mViewSource
.get(),
1293 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1294 NS_HTML5_BREAK(stateloop
);
1297 appendStrBufLineFeed
<P
>();
1298 state
= P::transition(mViewSource
.get(),
1299 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1300 NS_HTML5_BREAK(commentstartloop
);
1308 state
= P::transition(mViewSource
.get(),
1309 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1310 NS_HTML5_BREAK(commentstartloop
);
1314 commentstartloop_end
:;
1319 if (++pos
== endPos
) {
1320 NS_HTML5_BREAK(stateloop
);
1322 c
= P::checkChar(this, buf
, pos
);
1326 state
= P::transition(mViewSource
.get(),
1327 nsHtml5Tokenizer::COMMENT_END_DASH
,
1329 NS_HTML5_BREAK(commentloop
);
1333 state
= P::transition(mViewSource
.get(),
1334 nsHtml5Tokenizer::COMMENT_LESSTHAN
,
1336 NS_HTML5_CONTINUE(stateloop
);
1339 appendStrBufCarriageReturn
<P
>();
1340 NS_HTML5_BREAK(stateloop
);
1343 appendStrBufLineFeed
<P
>();
1359 case COMMENT_END_DASH
: {
1361 if (++pos
== endPos
) {
1362 NS_HTML5_BREAK(stateloop
);
1364 c
= P::checkChar(this, buf
, pos
);
1369 P::transition(mViewSource
.get(),
1370 nsHtml5Tokenizer::COMMENT_END
, reconsume
, pos
);
1371 NS_HTML5_BREAK(commentenddashloop
);
1375 state
= P::transition(mViewSource
.get(),
1376 nsHtml5Tokenizer::COMMENT_LESSTHAN
,
1378 NS_HTML5_CONTINUE(stateloop
);
1381 appendStrBufCarriageReturn
<P
>();
1382 state
= P::transition(mViewSource
.get(),
1383 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1384 NS_HTML5_BREAK(stateloop
);
1387 appendStrBufLineFeed
<P
>();
1388 state
= P::transition(mViewSource
.get(),
1389 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1390 NS_HTML5_CONTINUE(stateloop
);
1398 state
= P::transition(mViewSource
.get(),
1399 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1400 NS_HTML5_CONTINUE(stateloop
);
1404 commentenddashloop_end
:;
1409 if (++pos
== endPos
) {
1410 NS_HTML5_BREAK(stateloop
);
1412 c
= P::checkChar(this, buf
, pos
);
1415 emitComment(2, pos
);
1416 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
1418 if (shouldSuspend
) {
1419 NS_HTML5_BREAK(stateloop
);
1421 NS_HTML5_CONTINUE(stateloop
);
1424 adjustDoubleHyphenAndAppendToStrBufAndErr(
1425 c
, reportedConsecutiveHyphens
);
1426 reportedConsecutiveHyphens
= true;
1431 state
= P::transition(mViewSource
.get(),
1432 nsHtml5Tokenizer::COMMENT_LESSTHAN
,
1434 NS_HTML5_CONTINUE(stateloop
);
1437 adjustDoubleHyphenAndAppendToStrBufCarriageReturn
<P
>();
1438 state
= P::transition(mViewSource
.get(),
1439 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1440 NS_HTML5_BREAK(stateloop
);
1443 adjustDoubleHyphenAndAppendToStrBufLineFeed
<P
>();
1444 state
= P::transition(mViewSource
.get(),
1445 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1446 NS_HTML5_CONTINUE(stateloop
);
1450 state
= P::transition(mViewSource
.get(),
1451 nsHtml5Tokenizer::COMMENT_END_BANG
,
1453 NS_HTML5_BREAK(commentendloop
);
1460 adjustDoubleHyphenAndAppendToStrBufAndErr(
1461 c
, reportedConsecutiveHyphens
);
1462 reportedConsecutiveHyphens
= true;
1463 state
= P::transition(mViewSource
.get(),
1464 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1465 NS_HTML5_CONTINUE(stateloop
);
1469 commentendloop_end
:;
1472 case COMMENT_END_BANG
: {
1474 if (++pos
== endPos
) {
1475 NS_HTML5_BREAK(stateloop
);
1477 c
= P::checkChar(this, buf
, pos
);
1480 emitComment(3, pos
);
1481 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
1483 if (shouldSuspend
) {
1484 NS_HTML5_BREAK(stateloop
);
1486 NS_HTML5_CONTINUE(stateloop
);
1490 state
= P::transition(mViewSource
.get(),
1491 nsHtml5Tokenizer::COMMENT_END_DASH
,
1493 NS_HTML5_CONTINUE(stateloop
);
1496 appendStrBufCarriageReturn
<P
>();
1497 state
= P::transition(mViewSource
.get(),
1498 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1499 NS_HTML5_BREAK(stateloop
);
1502 appendStrBufLineFeed
<P
>();
1503 state
= P::transition(mViewSource
.get(),
1504 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1505 NS_HTML5_CONTINUE(stateloop
);
1513 state
= P::transition(mViewSource
.get(),
1514 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1515 NS_HTML5_CONTINUE(stateloop
);
1520 case COMMENT_LESSTHAN
: {
1522 if (++pos
== endPos
) {
1523 NS_HTML5_BREAK(stateloop
);
1525 c
= P::checkChar(this, buf
, pos
);
1529 state
= P::transition(mViewSource
.get(),
1530 nsHtml5Tokenizer::COMMENT_LESSTHAN_BANG
,
1532 NS_HTML5_BREAK(commentlessthanloop
);
1540 state
= P::transition(mViewSource
.get(),
1541 nsHtml5Tokenizer::COMMENT_END_DASH
,
1543 NS_HTML5_CONTINUE(stateloop
);
1546 appendStrBufCarriageReturn
<P
>();
1547 state
= P::transition(mViewSource
.get(),
1548 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1549 NS_HTML5_BREAK(stateloop
);
1552 appendStrBufLineFeed
<P
>();
1553 state
= P::transition(mViewSource
.get(),
1554 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1555 NS_HTML5_CONTINUE(stateloop
);
1563 state
= P::transition(mViewSource
.get(),
1564 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1565 NS_HTML5_CONTINUE(stateloop
);
1569 commentlessthanloop_end
:;
1572 case COMMENT_LESSTHAN_BANG
: {
1574 if (++pos
== endPos
) {
1575 NS_HTML5_BREAK(stateloop
);
1577 c
= P::checkChar(this, buf
, pos
);
1581 state
= P::transition(
1583 nsHtml5Tokenizer::COMMENT_LESSTHAN_BANG_DASH
, reconsume
, pos
);
1584 NS_HTML5_BREAK(commentlessthanbangloop
);
1588 state
= P::transition(mViewSource
.get(),
1589 nsHtml5Tokenizer::COMMENT_LESSTHAN
,
1591 NS_HTML5_CONTINUE(stateloop
);
1594 appendStrBufCarriageReturn
<P
>();
1595 state
= P::transition(mViewSource
.get(),
1596 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1597 NS_HTML5_BREAK(stateloop
);
1600 appendStrBufLineFeed
<P
>();
1601 state
= P::transition(mViewSource
.get(),
1602 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1603 NS_HTML5_CONTINUE(stateloop
);
1611 state
= P::transition(mViewSource
.get(),
1612 nsHtml5Tokenizer::COMMENT
, reconsume
, pos
);
1613 NS_HTML5_CONTINUE(stateloop
);
1617 commentlessthanbangloop_end
:;
1620 case COMMENT_LESSTHAN_BANG_DASH
: {
1621 if (++pos
== endPos
) {
1622 NS_HTML5_BREAK(stateloop
);
1624 c
= P::checkChar(this, buf
, pos
);
1629 P::transition(mViewSource
.get(),
1630 nsHtml5Tokenizer::COMMENT_LESSTHAN_BANG_DASH_DASH
,
1636 state
= P::transition(mViewSource
.get(),
1637 nsHtml5Tokenizer::COMMENT_LESSTHAN
, reconsume
,
1639 NS_HTML5_CONTINUE(stateloop
);
1642 appendStrBufCarriageReturn
<P
>();
1643 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::COMMENT
,
1645 NS_HTML5_BREAK(stateloop
);
1648 appendStrBufLineFeed
<P
>();
1649 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::COMMENT
,
1651 NS_HTML5_CONTINUE(stateloop
);
1659 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::COMMENT
,
1661 NS_HTML5_CONTINUE(stateloop
);
1666 case COMMENT_LESSTHAN_BANG_DASH_DASH
: {
1667 if (++pos
== endPos
) {
1668 NS_HTML5_BREAK(stateloop
);
1670 c
= P::checkChar(this, buf
, pos
);
1674 emitComment(3, pos
);
1675 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
1677 if (shouldSuspend
) {
1678 NS_HTML5_BREAK(stateloop
);
1680 NS_HTML5_CONTINUE(stateloop
);
1683 if (P::reportErrors
) {
1686 adjustDoubleHyphenAndAppendToStrBufAndErr(
1687 c
, reportedConsecutiveHyphens
);
1688 reportedConsecutiveHyphens
= true;
1690 P::transition(mViewSource
.get(), nsHtml5Tokenizer::COMMENT_END
,
1692 NS_HTML5_CONTINUE(stateloop
);
1696 P::silentCarriageReturn(this);
1697 if (P::reportErrors
) {
1700 adjustDoubleHyphenAndAppendToStrBufAndErr(
1701 c
, reportedConsecutiveHyphens
);
1702 reportedConsecutiveHyphens
= true;
1703 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::COMMENT
,
1705 NS_HTML5_BREAK(stateloop
);
1708 P::silentLineFeed(this);
1709 if (P::reportErrors
) {
1712 adjustDoubleHyphenAndAppendToStrBufAndErr(
1713 c
, reportedConsecutiveHyphens
);
1714 reportedConsecutiveHyphens
= true;
1715 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::COMMENT
,
1717 NS_HTML5_CONTINUE(stateloop
);
1720 if (P::reportErrors
) {
1723 adjustDoubleHyphenAndAppendToStrBufAndErr(
1724 c
, reportedConsecutiveHyphens
);
1725 reportedConsecutiveHyphens
= true;
1726 state
= P::transition(mViewSource
.get(),
1727 nsHtml5Tokenizer::COMMENT_END_BANG
, reconsume
,
1729 NS_HTML5_CONTINUE(stateloop
);
1736 if (P::reportErrors
) {
1739 adjustDoubleHyphenAndAppendToStrBufAndErr(
1740 c
, reportedConsecutiveHyphens
);
1741 reportedConsecutiveHyphens
= true;
1742 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::COMMENT
,
1744 NS_HTML5_CONTINUE(stateloop
);
1748 case COMMENT_START_DASH
: {
1749 if (++pos
== endPos
) {
1750 NS_HTML5_BREAK(stateloop
);
1752 c
= P::checkChar(this, buf
, pos
);
1757 P::transition(mViewSource
.get(), nsHtml5Tokenizer::COMMENT_END
,
1759 NS_HTML5_CONTINUE(stateloop
);
1762 if (P::reportErrors
) {
1763 errPrematureEndOfComment();
1765 emitComment(1, pos
);
1766 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
1768 if (shouldSuspend
) {
1769 NS_HTML5_BREAK(stateloop
);
1771 NS_HTML5_CONTINUE(stateloop
);
1775 state
= P::transition(mViewSource
.get(),
1776 nsHtml5Tokenizer::COMMENT_LESSTHAN
, reconsume
,
1778 NS_HTML5_CONTINUE(stateloop
);
1781 appendStrBufCarriageReturn
<P
>();
1782 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::COMMENT
,
1784 NS_HTML5_BREAK(stateloop
);
1787 appendStrBufLineFeed
<P
>();
1788 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::COMMENT
,
1790 NS_HTML5_CONTINUE(stateloop
);
1798 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::COMMENT
,
1800 NS_HTML5_CONTINUE(stateloop
);
1806 if (++pos
== endPos
) {
1807 NS_HTML5_BREAK(stateloop
);
1809 c
= P::checkChar(this, buf
, pos
);
1811 if (c
== nsHtml5Tokenizer::CDATA_LSQB
[index
]) {
1814 if (P::reportErrors
) {
1818 state
= P::transition(mViewSource
.get(),
1819 nsHtml5Tokenizer::BOGUS_COMMENT
, reconsume
,
1821 NS_HTML5_CONTINUE(stateloop
);
1826 clearStrBufAfterUse();
1830 P::transition(mViewSource
.get(),
1831 nsHtml5Tokenizer::CDATA_SECTION
, reconsume
, pos
);
1837 case CDATA_SECTION
: {
1842 if (++pos
== endPos
) {
1843 NS_HTML5_BREAK(stateloop
);
1845 c
= P::checkChar(this, buf
, pos
);
1849 flushChars(buf
, pos
);
1851 P::transition(mViewSource
.get(), nsHtml5Tokenizer::CDATA_RSQB
,
1853 NS_HTML5_BREAK(cdatasectionloop
);
1856 maybeEmitReplacementCharacter(buf
, pos
);
1860 emitCarriageReturn
<P
>(buf
, pos
);
1861 NS_HTML5_BREAK(stateloop
);
1864 P::silentLineFeed(this);
1872 cdatasectionloop_end
:;
1876 if (++pos
== endPos
) {
1877 NS_HTML5_BREAK(stateloop
);
1879 c
= P::checkChar(this, buf
, pos
);
1882 state
= P::transition(mViewSource
.get(),
1883 nsHtml5Tokenizer::CDATA_RSQB_RSQB
, reconsume
,
1888 tokenHandler
->characters(nsHtml5Tokenizer::RSQB_RSQB
, 0, 1);
1892 P::transition(mViewSource
.get(),
1893 nsHtml5Tokenizer::CDATA_SECTION
, reconsume
, pos
);
1894 NS_HTML5_CONTINUE(stateloop
);
1899 case CDATA_RSQB_RSQB
: {
1901 if (++pos
== endPos
) {
1902 NS_HTML5_BREAK(stateloop
);
1904 c
= P::checkChar(this, buf
, pos
);
1907 tokenHandler
->characters(nsHtml5Tokenizer::RSQB_RSQB
, 0, 1);
1912 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
1914 suspendIfRequestedAfterCurrentNonTextToken();
1915 if (shouldSuspend
) {
1916 NS_HTML5_BREAK(stateloop
);
1918 NS_HTML5_CONTINUE(stateloop
);
1921 tokenHandler
->characters(nsHtml5Tokenizer::RSQB_RSQB
, 0, 2);
1924 state
= P::transition(mViewSource
.get(),
1925 nsHtml5Tokenizer::CDATA_SECTION
, reconsume
,
1927 NS_HTML5_CONTINUE(stateloop
);
1932 case ATTRIBUTE_VALUE_SINGLE_QUOTED
: {
1937 if (++pos
== endPos
) {
1938 NS_HTML5_BREAK(stateloop
);
1940 c
= P::checkChar(this, buf
, pos
);
1944 addAttributeWithValue();
1946 P::transition(mViewSource
.get(),
1947 nsHtml5Tokenizer::AFTER_ATTRIBUTE_VALUE_QUOTED
,
1949 NS_HTML5_CONTINUE(stateloop
);
1952 MOZ_ASSERT(!charRefBufLen
,
1953 "charRefBufLen not reset after previous use!");
1954 appendCharRefBuf(c
);
1955 setAdditionalAndRememberAmpersandLocation('\'');
1956 returnState
= state
;
1958 P::transition(mViewSource
.get(),
1959 nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE
,
1961 NS_HTML5_BREAK(attributevaluesinglequotedloop
);
1964 appendStrBufCarriageReturn
<P
>();
1965 NS_HTML5_BREAK(stateloop
);
1968 appendStrBufLineFeed
<P
>();
1981 attributevaluesinglequotedloop_end
:;
1984 case CONSUME_CHARACTER_REFERENCE
: {
1985 if (++pos
== endPos
) {
1986 NS_HTML5_BREAK(stateloop
);
1988 c
= P::checkChar(this, buf
, pos
);
1999 emitOrAppendCharRefBuf(returnState
);
2000 if (!(returnState
& DATA_AND_RCDATA_MASK
)) {
2005 P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2006 NS_HTML5_CONTINUE(stateloop
);
2009 appendCharRefBuf('#');
2011 P::transition(mViewSource
.get(), nsHtml5Tokenizer::CONSUME_NCR
,
2013 NS_HTML5_CONTINUE(stateloop
);
2016 if (c
== additional
) {
2017 emitOrAppendCharRefBuf(returnState
);
2020 P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2021 NS_HTML5_CONTINUE(stateloop
);
2023 if (c
>= 'a' && c
<= 'z') {
2024 firstCharKey
= c
- 'a' + 26;
2025 } else if (c
>= 'A' && c
<= 'Z') {
2026 firstCharKey
= c
- 'A';
2029 if (P::reportErrors
) {
2030 errNoNamedCharacterMatch();
2033 emitOrAppendCharRefBuf(returnState
);
2034 if (!(returnState
& DATA_AND_RCDATA_MASK
)) {
2039 P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2040 NS_HTML5_CONTINUE(stateloop
);
2042 appendCharRefBuf(c
);
2044 P::transition(mViewSource
.get(),
2045 nsHtml5Tokenizer::CHARACTER_REFERENCE_HILO_LOOKUP
,
2052 case CHARACTER_REFERENCE_HILO_LOOKUP
: {
2054 if (++pos
== endPos
) {
2055 NS_HTML5_BREAK(stateloop
);
2057 c
= P::checkChar(this, buf
, pos
);
2060 const int32_t* row
= nsHtml5NamedCharactersAccel::HILO_ACCEL
[c
];
2062 hilo
= row
[firstCharKey
];
2067 if (P::reportErrors
) {
2068 errNoNamedCharacterMatch();
2071 emitOrAppendCharRefBuf(returnState
);
2072 if (!(returnState
& DATA_AND_RCDATA_MASK
)) {
2077 P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2078 NS_HTML5_CONTINUE(stateloop
);
2080 appendCharRefBuf(c
);
2086 state
= P::transition(mViewSource
.get(),
2087 nsHtml5Tokenizer::CHARACTER_REFERENCE_TAIL
,
2092 case CHARACTER_REFERENCE_TAIL
: {
2094 if (++pos
== endPos
) {
2095 NS_HTML5_BREAK(stateloop
);
2097 c
= P::checkChar(this, buf
, pos
);
2101 NS_HTML5_BREAK(outer
);
2103 if (entCol
== nsHtml5NamedCharacters::NAMES
[lo
].length()) {
2105 charRefBufMark
= charRefBufLen
;
2107 } else if (entCol
> nsHtml5NamedCharacters::NAMES
[lo
].length()) {
2108 NS_HTML5_BREAK(outer
);
2109 } else if (c
> nsHtml5NamedCharacters::NAMES
[lo
].charAt(entCol
)) {
2112 NS_HTML5_BREAK(loloop
);
2118 NS_HTML5_BREAK(outer
);
2120 if (entCol
== nsHtml5NamedCharacters::NAMES
[hi
].length()) {
2121 NS_HTML5_BREAK(hiloop
);
2123 if (entCol
> nsHtml5NamedCharacters::NAMES
[hi
].length()) {
2124 NS_HTML5_BREAK(outer
);
2125 } else if (c
< nsHtml5NamedCharacters::NAMES
[hi
].charAt(entCol
)) {
2128 NS_HTML5_BREAK(hiloop
);
2133 if (entCol
+ 1 == nsHtml5NamedCharacters::NAMES
[lo
].length()) {
2135 charRefBufMark
= charRefBufLen
;
2137 NS_HTML5_BREAK(outer
);
2140 NS_HTML5_BREAK(outer
);
2142 appendCharRefBuf(c
);
2146 if (candidate
== -1) {
2148 if (P::reportErrors
) {
2149 errNoNamedCharacterMatch();
2152 emitOrAppendCharRefBuf(returnState
);
2153 if (!(returnState
& DATA_AND_RCDATA_MASK
)) {
2157 state
= P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2158 NS_HTML5_CONTINUE(stateloop
);
2160 const nsHtml5CharacterName
& candidateName
=
2161 nsHtml5NamedCharacters::NAMES
[candidate
];
2162 if (!candidateName
.length() ||
2163 candidateName
.charAt(candidateName
.length() - 1) != ';') {
2164 if ((returnState
& DATA_AND_RCDATA_MASK
)) {
2166 if (charRefBufMark
== charRefBufLen
) {
2169 ch
= charRefBuf
[charRefBufMark
];
2171 if (ch
== '=' || (ch
>= '0' && ch
<= '9') ||
2172 (ch
>= 'A' && ch
<= 'Z') || (ch
>= 'a' && ch
<= 'z')) {
2174 if (P::reportErrors
) {
2175 errNoNamedCharacterMatch();
2178 appendCharRefBufToStrBuf();
2180 state
= P::transition(mViewSource
.get(), returnState
, reconsume
,
2182 NS_HTML5_CONTINUE(stateloop
);
2185 if ((returnState
& DATA_AND_RCDATA_MASK
)) {
2186 if (P::reportErrors
) {
2187 errUnescapedAmpersandInterpretedAsCharacterReference();
2190 if (P::reportErrors
) {
2191 errNotSemicolonTerminated();
2195 P::completedNamedCharacterReference(mViewSource
.get());
2196 const char16_t
* val
= nsHtml5NamedCharacters::VALUES
[candidate
];
2198 emitOrAppendOne(val
, returnState
);
2200 emitOrAppendTwo(val
, returnState
);
2202 if (charRefBufMark
< charRefBufLen
) {
2203 if ((returnState
& DATA_AND_RCDATA_MASK
)) {
2204 appendStrBuf(charRefBuf
, charRefBufMark
,
2205 charRefBufLen
- charRefBufMark
);
2207 tokenHandler
->characters(charRefBuf
, charRefBufMark
,
2208 charRefBufLen
- charRefBufMark
);
2211 bool earlyBreak
= (c
== ';' && charRefBufMark
== charRefBufLen
);
2213 if (!(returnState
& DATA_AND_RCDATA_MASK
)) {
2214 cstart
= earlyBreak
? pos
+ 1 : pos
;
2216 reconsume
= !earlyBreak
;
2217 state
= P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2218 NS_HTML5_CONTINUE(stateloop
);
2222 if (++pos
== endPos
) {
2223 NS_HTML5_BREAK(stateloop
);
2225 c
= P::checkChar(this, buf
, pos
);
2231 appendCharRefBuf(c
);
2233 P::transition(mViewSource
.get(), nsHtml5Tokenizer::HEX_NCR_LOOP
,
2235 NS_HTML5_CONTINUE(stateloop
);
2239 state
= P::transition(mViewSource
.get(),
2240 nsHtml5Tokenizer::DECIMAL_NRC_LOOP
, reconsume
,
2247 case DECIMAL_NRC_LOOP
: {
2252 if (++pos
== endPos
) {
2253 NS_HTML5_BREAK(stateloop
);
2255 c
= P::checkChar(this, buf
, pos
);
2257 MOZ_ASSERT(value
>= 0, "value must not become negative.");
2258 if (c
>= '0' && c
<= '9') {
2260 if (value
<= 0x10FFFF) {
2265 } else if (c
== ';') {
2267 if (!(returnState
& DATA_AND_RCDATA_MASK
)) {
2270 state
= P::transition(mViewSource
.get(),
2271 nsHtml5Tokenizer::HANDLE_NCR_VALUE
,
2273 NS_HTML5_BREAK(decimalloop
);
2275 if (P::reportErrors
) {
2278 appendCharRefBuf(';');
2279 emitOrAppendCharRefBuf(returnState
);
2280 if (!(returnState
& DATA_AND_RCDATA_MASK
)) {
2284 P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2285 NS_HTML5_CONTINUE(stateloop
);
2289 if (P::reportErrors
) {
2292 emitOrAppendCharRefBuf(returnState
);
2293 if (!(returnState
& DATA_AND_RCDATA_MASK
)) {
2298 P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2299 NS_HTML5_CONTINUE(stateloop
);
2301 if (P::reportErrors
) {
2302 errCharRefLacksSemicolon();
2304 if (!(returnState
& DATA_AND_RCDATA_MASK
)) {
2308 state
= P::transition(mViewSource
.get(),
2309 nsHtml5Tokenizer::HANDLE_NCR_VALUE
,
2311 NS_HTML5_BREAK(decimalloop
);
2318 case HANDLE_NCR_VALUE
: {
2320 handleNcrValue(returnState
);
2321 state
= P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2322 NS_HTML5_CONTINUE(stateloop
);
2324 case HEX_NCR_LOOP
: {
2326 if (++pos
== endPos
) {
2327 NS_HTML5_BREAK(stateloop
);
2329 c
= P::checkChar(this, buf
, pos
);
2330 MOZ_ASSERT(value
>= 0, "value must not become negative.");
2331 if (c
>= '0' && c
<= '9') {
2333 if (value
<= 0x10FFFF) {
2338 } else if (c
>= 'A' && c
<= 'F') {
2340 if (value
<= 0x10FFFF) {
2342 value
+= c
- 'A' + 10;
2345 } else if (c
>= 'a' && c
<= 'f') {
2347 if (value
<= 0x10FFFF) {
2349 value
+= c
- 'a' + 10;
2352 } else if (c
== ';') {
2354 if (!(returnState
& DATA_AND_RCDATA_MASK
)) {
2357 state
= P::transition(mViewSource
.get(),
2358 nsHtml5Tokenizer::HANDLE_NCR_VALUE
,
2360 NS_HTML5_CONTINUE(stateloop
);
2362 if (P::reportErrors
) {
2365 appendCharRefBuf(';');
2366 emitOrAppendCharRefBuf(returnState
);
2367 if (!(returnState
& DATA_AND_RCDATA_MASK
)) {
2371 P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2372 NS_HTML5_CONTINUE(stateloop
);
2376 if (P::reportErrors
) {
2379 emitOrAppendCharRefBuf(returnState
);
2380 if (!(returnState
& DATA_AND_RCDATA_MASK
)) {
2385 P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2386 NS_HTML5_CONTINUE(stateloop
);
2388 if (P::reportErrors
) {
2389 errCharRefLacksSemicolon();
2391 if (!(returnState
& DATA_AND_RCDATA_MASK
)) {
2395 state
= P::transition(mViewSource
.get(),
2396 nsHtml5Tokenizer::HANDLE_NCR_VALUE
,
2398 NS_HTML5_CONTINUE(stateloop
);
2408 if (++pos
== endPos
) {
2409 NS_HTML5_BREAK(stateloop
);
2411 c
= P::checkChar(this, buf
, pos
);
2415 emitPlaintextReplacementCharacter(buf
, pos
);
2419 emitCarriageReturn
<P
>(buf
, pos
);
2420 NS_HTML5_BREAK(stateloop
);
2423 P::silentLineFeed(this);
2432 case CLOSE_TAG_OPEN
: {
2433 if (++pos
== endPos
) {
2434 NS_HTML5_BREAK(stateloop
);
2436 c
= P::checkChar(this, buf
, pos
);
2439 if (P::reportErrors
) {
2443 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
2445 NS_HTML5_CONTINUE(stateloop
);
2448 P::silentCarriageReturn(this);
2449 if (P::reportErrors
) {
2450 errGarbageAfterLtSlash();
2452 clearStrBufBeforeUse();
2455 P::transition(mViewSource
.get(),
2456 nsHtml5Tokenizer::BOGUS_COMMENT
, reconsume
, pos
);
2457 NS_HTML5_BREAK(stateloop
);
2460 P::silentLineFeed(this);
2461 if (P::reportErrors
) {
2462 errGarbageAfterLtSlash();
2464 clearStrBufBeforeUse();
2467 P::transition(mViewSource
.get(),
2468 nsHtml5Tokenizer::BOGUS_COMMENT
, reconsume
, pos
);
2469 NS_HTML5_CONTINUE(stateloop
);
2476 if (c
>= 'A' && c
<= 'Z') {
2479 if (c
>= 'a' && c
<= 'z') {
2481 clearStrBufBeforeUse();
2483 containsHyphen
= false;
2484 state
= P::transition(mViewSource
.get(),
2485 nsHtml5Tokenizer::TAG_NAME
, reconsume
, pos
);
2486 NS_HTML5_CONTINUE(stateloop
);
2488 if (P::reportErrors
) {
2489 errGarbageAfterLtSlash();
2491 clearStrBufBeforeUse();
2493 state
= P::transition(mViewSource
.get(),
2494 nsHtml5Tokenizer::BOGUS_COMMENT
, reconsume
,
2496 NS_HTML5_CONTINUE(stateloop
);
2506 if (++pos
== endPos
) {
2507 NS_HTML5_BREAK(stateloop
);
2509 c
= P::checkChar(this, buf
, pos
);
2513 flushChars(buf
, pos
);
2514 MOZ_ASSERT(!charRefBufLen
,
2515 "charRefBufLen not reset after previous use!");
2516 appendCharRefBuf(c
);
2517 setAdditionalAndRememberAmpersandLocation('\0');
2518 returnState
= state
;
2520 P::transition(mViewSource
.get(),
2521 nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE
,
2523 NS_HTML5_CONTINUE(stateloop
);
2526 flushChars(buf
, pos
);
2527 returnState
= state
;
2529 P::transition(mViewSource
.get(),
2530 nsHtml5Tokenizer::RAWTEXT_RCDATA_LESS_THAN_SIGN
,
2532 NS_HTML5_CONTINUE(stateloop
);
2535 emitReplacementCharacter(buf
, pos
);
2539 emitCarriageReturn
<P
>(buf
, pos
);
2540 NS_HTML5_BREAK(stateloop
);
2543 P::silentLineFeed(this);
2557 if (++pos
== endPos
) {
2558 NS_HTML5_BREAK(stateloop
);
2560 c
= P::checkChar(this, buf
, pos
);
2564 flushChars(buf
, pos
);
2565 returnState
= state
;
2567 P::transition(mViewSource
.get(),
2568 nsHtml5Tokenizer::RAWTEXT_RCDATA_LESS_THAN_SIGN
,
2570 NS_HTML5_BREAK(rawtextloop
);
2573 emitReplacementCharacter(buf
, pos
);
2577 emitCarriageReturn
<P
>(buf
, pos
);
2578 NS_HTML5_BREAK(stateloop
);
2581 P::silentLineFeed(this);
2592 case RAWTEXT_RCDATA_LESS_THAN_SIGN
: {
2594 if (++pos
== endPos
) {
2595 NS_HTML5_BREAK(stateloop
);
2597 c
= P::checkChar(this, buf
, pos
);
2601 clearStrBufBeforeUse();
2602 state
= P::transition(mViewSource
.get(),
2603 nsHtml5Tokenizer::NON_DATA_END_TAG_NAME
,
2605 NS_HTML5_BREAK(rawtextrcdatalessthansignloop
);
2608 tokenHandler
->characters(nsHtml5Tokenizer::LT_GT
, 0, 1);
2612 P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2613 NS_HTML5_CONTINUE(stateloop
);
2617 rawtextrcdatalessthansignloop_end
:;
2620 case NON_DATA_END_TAG_NAME
: {
2622 if (++pos
== endPos
) {
2623 NS_HTML5_BREAK(stateloop
);
2625 c
= P::checkChar(this, buf
, pos
);
2626 if (!endTagExpectationAsArray
) {
2627 tokenHandler
->characters(nsHtml5Tokenizer::LT_SOLIDUS
, 0, 2);
2631 P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2632 NS_HTML5_CONTINUE(stateloop
);
2633 } else if (index
< endTagExpectationAsArray
.length
) {
2634 char16_t e
= endTagExpectationAsArray
[index
];
2635 char16_t folded
= c
;
2636 if (c
>= 'A' && c
<= 'Z') {
2640 tokenHandler
->characters(nsHtml5Tokenizer::LT_SOLIDUS
, 0, 2);
2645 P::transition(mViewSource
.get(), returnState
, reconsume
, pos
);
2646 NS_HTML5_CONTINUE(stateloop
);
2653 tagName
= endTagExpectation
;
2656 P::silentCarriageReturn(this);
2657 clearStrBufAfterUse();
2658 state
= P::transition(mViewSource
.get(),
2659 nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME
,
2661 NS_HTML5_BREAK(stateloop
);
2664 P::silentLineFeed(this);
2670 clearStrBufAfterUse();
2671 state
= P::transition(mViewSource
.get(),
2672 nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME
,
2674 NS_HTML5_CONTINUE(stateloop
);
2677 clearStrBufAfterUse();
2678 state
= P::transition(mViewSource
.get(),
2679 nsHtml5Tokenizer::SELF_CLOSING_START_TAG
,
2681 NS_HTML5_CONTINUE(stateloop
);
2684 clearStrBufAfterUse();
2685 state
= P::transition(mViewSource
.get(),
2686 emitCurrentTagToken(false, pos
),
2688 if (shouldSuspend
) {
2689 NS_HTML5_BREAK(stateloop
);
2691 NS_HTML5_CONTINUE(stateloop
);
2694 tokenHandler
->characters(nsHtml5Tokenizer::LT_SOLIDUS
, 0, 2);
2698 state
= P::transition(mViewSource
.get(), returnState
, reconsume
,
2700 NS_HTML5_CONTINUE(stateloop
);
2706 case BOGUS_COMMENT
: {
2711 if (++pos
== endPos
) {
2712 NS_HTML5_BREAK(stateloop
);
2714 c
= P::checkChar(this, buf
, pos
);
2718 emitComment(0, pos
);
2719 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
2721 if (shouldSuspend
) {
2722 NS_HTML5_BREAK(stateloop
);
2724 NS_HTML5_CONTINUE(stateloop
);
2728 state
= P::transition(mViewSource
.get(),
2729 nsHtml5Tokenizer::BOGUS_COMMENT_HYPHEN
,
2731 NS_HTML5_BREAK(boguscommentloop
);
2734 appendStrBufCarriageReturn
<P
>();
2735 NS_HTML5_BREAK(stateloop
);
2738 appendStrBufLineFeed
<P
>();
2751 boguscommentloop_end
:;
2754 case BOGUS_COMMENT_HYPHEN
: {
2755 boguscommenthyphenloop
:
2757 if (++pos
== endPos
) {
2758 NS_HTML5_BREAK(stateloop
);
2760 c
= P::checkChar(this, buf
, pos
);
2763 emitComment(0, pos
);
2764 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
2766 if (shouldSuspend
) {
2767 NS_HTML5_BREAK(stateloop
);
2769 NS_HTML5_CONTINUE(stateloop
);
2772 appendSecondHyphenToBogusComment();
2773 NS_HTML5_CONTINUE(boguscommenthyphenloop
);
2776 appendStrBufCarriageReturn
<P
>();
2777 state
= P::transition(mViewSource
.get(),
2778 nsHtml5Tokenizer::BOGUS_COMMENT
, reconsume
,
2780 NS_HTML5_BREAK(stateloop
);
2783 appendStrBufLineFeed
<P
>();
2784 state
= P::transition(mViewSource
.get(),
2785 nsHtml5Tokenizer::BOGUS_COMMENT
, reconsume
,
2787 NS_HTML5_CONTINUE(stateloop
);
2795 state
= P::transition(mViewSource
.get(),
2796 nsHtml5Tokenizer::BOGUS_COMMENT
, reconsume
,
2798 NS_HTML5_CONTINUE(stateloop
);
2808 if (++pos
== endPos
) {
2809 NS_HTML5_BREAK(stateloop
);
2811 c
= P::checkChar(this, buf
, pos
);
2815 flushChars(buf
, pos
);
2816 returnState
= state
;
2817 state
= P::transition(
2819 nsHtml5Tokenizer::SCRIPT_DATA_LESS_THAN_SIGN
, reconsume
, pos
);
2820 NS_HTML5_BREAK(scriptdataloop
);
2823 emitReplacementCharacter(buf
, pos
);
2827 emitCarriageReturn
<P
>(buf
, pos
);
2828 NS_HTML5_BREAK(stateloop
);
2831 P::silentLineFeed(this);
2839 scriptdataloop_end
:;
2842 case SCRIPT_DATA_LESS_THAN_SIGN
: {
2844 if (++pos
== endPos
) {
2845 NS_HTML5_BREAK(stateloop
);
2847 c
= P::checkChar(this, buf
, pos
);
2851 clearStrBufBeforeUse();
2852 state
= P::transition(mViewSource
.get(),
2853 nsHtml5Tokenizer::NON_DATA_END_TAG_NAME
,
2855 NS_HTML5_CONTINUE(stateloop
);
2858 tokenHandler
->characters(nsHtml5Tokenizer::LT_GT
, 0, 1);
2860 state
= P::transition(mViewSource
.get(),
2861 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPE_START
,
2863 NS_HTML5_BREAK(scriptdatalessthansignloop
);
2866 tokenHandler
->characters(nsHtml5Tokenizer::LT_GT
, 0, 1);
2870 P::transition(mViewSource
.get(),
2871 nsHtml5Tokenizer::SCRIPT_DATA
, reconsume
, pos
);
2872 NS_HTML5_CONTINUE(stateloop
);
2876 scriptdatalessthansignloop_end
:;
2879 case SCRIPT_DATA_ESCAPE_START
: {
2881 if (++pos
== endPos
) {
2882 NS_HTML5_BREAK(stateloop
);
2884 c
= P::checkChar(this, buf
, pos
);
2888 P::transition(mViewSource
.get(),
2889 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPE_START_DASH
,
2891 NS_HTML5_BREAK(scriptdataescapestartloop
);
2896 P::transition(mViewSource
.get(),
2897 nsHtml5Tokenizer::SCRIPT_DATA
, reconsume
, pos
);
2898 NS_HTML5_CONTINUE(stateloop
);
2902 scriptdataescapestartloop_end
:;
2905 case SCRIPT_DATA_ESCAPE_START_DASH
: {
2907 if (++pos
== endPos
) {
2908 NS_HTML5_BREAK(stateloop
);
2910 c
= P::checkChar(this, buf
, pos
);
2914 P::transition(mViewSource
.get(),
2915 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_DASH_DASH
,
2917 NS_HTML5_BREAK(scriptdataescapestartdashloop
);
2922 P::transition(mViewSource
.get(),
2923 nsHtml5Tokenizer::SCRIPT_DATA
, reconsume
, pos
);
2924 NS_HTML5_CONTINUE(stateloop
);
2928 scriptdataescapestartdashloop_end
:;
2931 case SCRIPT_DATA_ESCAPED_DASH_DASH
: {
2933 if (++pos
== endPos
) {
2934 NS_HTML5_BREAK(stateloop
);
2936 c
= P::checkChar(this, buf
, pos
);
2942 flushChars(buf
, pos
);
2943 state
= P::transition(
2945 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN
,
2947 NS_HTML5_CONTINUE(stateloop
);
2951 P::transition(mViewSource
.get(),
2952 nsHtml5Tokenizer::SCRIPT_DATA
, reconsume
, pos
);
2953 NS_HTML5_CONTINUE(stateloop
);
2956 emitReplacementCharacter(buf
, pos
);
2957 state
= P::transition(mViewSource
.get(),
2958 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED
,
2960 NS_HTML5_BREAK(scriptdataescapeddashdashloop
);
2963 emitCarriageReturn
<P
>(buf
, pos
);
2964 state
= P::transition(mViewSource
.get(),
2965 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED
,
2967 NS_HTML5_BREAK(stateloop
);
2970 P::silentLineFeed(this);
2974 state
= P::transition(mViewSource
.get(),
2975 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED
,
2977 NS_HTML5_BREAK(scriptdataescapeddashdashloop
);
2981 scriptdataescapeddashdashloop_end
:;
2984 case SCRIPT_DATA_ESCAPED
: {
2989 if (++pos
== endPos
) {
2990 NS_HTML5_BREAK(stateloop
);
2992 c
= P::checkChar(this, buf
, pos
);
2996 state
= P::transition(mViewSource
.get(),
2997 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_DASH
,
2999 NS_HTML5_BREAK(scriptdataescapedloop
);
3002 flushChars(buf
, pos
);
3003 state
= P::transition(
3005 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN
,
3007 NS_HTML5_CONTINUE(stateloop
);
3010 emitReplacementCharacter(buf
, pos
);
3014 emitCarriageReturn
<P
>(buf
, pos
);
3015 NS_HTML5_BREAK(stateloop
);
3018 P::silentLineFeed(this);
3026 scriptdataescapedloop_end
:;
3029 case SCRIPT_DATA_ESCAPED_DASH
: {
3031 if (++pos
== endPos
) {
3032 NS_HTML5_BREAK(stateloop
);
3034 c
= P::checkChar(this, buf
, pos
);
3038 P::transition(mViewSource
.get(),
3039 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_DASH_DASH
,
3041 NS_HTML5_CONTINUE(stateloop
);
3044 flushChars(buf
, pos
);
3045 state
= P::transition(
3047 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN
,
3049 NS_HTML5_BREAK(scriptdataescapeddashloop
);
3052 emitReplacementCharacter(buf
, pos
);
3053 state
= P::transition(mViewSource
.get(),
3054 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED
,
3056 NS_HTML5_CONTINUE(stateloop
);
3059 emitCarriageReturn
<P
>(buf
, pos
);
3060 state
= P::transition(mViewSource
.get(),
3061 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED
,
3063 NS_HTML5_BREAK(stateloop
);
3066 P::silentLineFeed(this);
3070 state
= P::transition(mViewSource
.get(),
3071 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED
,
3073 NS_HTML5_CONTINUE(stateloop
);
3077 scriptdataescapeddashloop_end
:;
3080 case SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN
: {
3082 if (++pos
== endPos
) {
3083 NS_HTML5_BREAK(stateloop
);
3085 c
= P::checkChar(this, buf
, pos
);
3089 clearStrBufBeforeUse();
3090 returnState
= nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED
;
3091 state
= P::transition(mViewSource
.get(),
3092 nsHtml5Tokenizer::NON_DATA_END_TAG_NAME
,
3094 NS_HTML5_CONTINUE(stateloop
);
3098 tokenHandler
->characters(nsHtml5Tokenizer::LT_GT
, 0, 1);
3101 state
= P::transition(
3103 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPE_START
, reconsume
,
3105 NS_HTML5_BREAK(scriptdataescapedlessthanloop
);
3108 tokenHandler
->characters(nsHtml5Tokenizer::LT_GT
, 0, 1);
3111 state
= P::transition(mViewSource
.get(),
3112 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED
,
3114 NS_HTML5_CONTINUE(stateloop
);
3118 scriptdataescapedlessthanloop_end
:;
3121 case SCRIPT_DATA_DOUBLE_ESCAPE_START
: {
3123 if (++pos
== endPos
) {
3124 NS_HTML5_BREAK(stateloop
);
3126 c
= P::checkChar(this, buf
, pos
);
3127 MOZ_ASSERT(index
> 0);
3129 char16_t folded
= c
;
3130 if (c
>= 'A' && c
<= 'Z') {
3133 if (folded
!= nsHtml5Tokenizer::SCRIPT_ARR
[index
]) {
3135 state
= P::transition(mViewSource
.get(),
3136 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED
,
3138 NS_HTML5_CONTINUE(stateloop
);
3145 emitCarriageReturn
<P
>(buf
, pos
);
3146 state
= P::transition(
3148 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED
, reconsume
, pos
);
3149 NS_HTML5_BREAK(stateloop
);
3152 P::silentLineFeed(this);
3160 state
= P::transition(
3162 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED
, reconsume
, pos
);
3163 NS_HTML5_BREAK(scriptdatadoubleescapestartloop
);
3167 state
= P::transition(mViewSource
.get(),
3168 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED
,
3170 NS_HTML5_CONTINUE(stateloop
);
3174 scriptdatadoubleescapestartloop_end
:;
3177 case SCRIPT_DATA_DOUBLE_ESCAPED
: {
3182 if (++pos
== endPos
) {
3183 NS_HTML5_BREAK(stateloop
);
3185 c
= P::checkChar(this, buf
, pos
);
3189 state
= P::transition(
3191 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_DASH
, reconsume
,
3193 NS_HTML5_BREAK(scriptdatadoubleescapedloop
);
3196 state
= P::transition(
3198 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN
,
3200 NS_HTML5_CONTINUE(stateloop
);
3203 emitReplacementCharacter(buf
, pos
);
3207 emitCarriageReturn
<P
>(buf
, pos
);
3208 NS_HTML5_BREAK(stateloop
);
3211 P::silentLineFeed(this);
3219 scriptdatadoubleescapedloop_end
:;
3222 case SCRIPT_DATA_DOUBLE_ESCAPED_DASH
: {
3224 if (++pos
== endPos
) {
3225 NS_HTML5_BREAK(stateloop
);
3227 c
= P::checkChar(this, buf
, pos
);
3230 state
= P::transition(
3232 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH
,
3234 NS_HTML5_BREAK(scriptdatadoubleescapeddashloop
);
3237 state
= P::transition(
3239 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN
,
3241 NS_HTML5_CONTINUE(stateloop
);
3244 emitReplacementCharacter(buf
, pos
);
3245 state
= P::transition(
3247 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED
, reconsume
, pos
);
3248 NS_HTML5_CONTINUE(stateloop
);
3251 emitCarriageReturn
<P
>(buf
, pos
);
3252 state
= P::transition(
3254 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED
, reconsume
, pos
);
3255 NS_HTML5_BREAK(stateloop
);
3258 P::silentLineFeed(this);
3262 state
= P::transition(
3264 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED
, reconsume
, pos
);
3265 NS_HTML5_CONTINUE(stateloop
);
3269 scriptdatadoubleescapeddashloop_end
:;
3272 case SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH
: {
3274 if (++pos
== endPos
) {
3275 NS_HTML5_BREAK(stateloop
);
3277 c
= P::checkChar(this, buf
, pos
);
3283 state
= P::transition(
3285 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN
,
3287 NS_HTML5_BREAK(scriptdatadoubleescapeddashdashloop
);
3291 P::transition(mViewSource
.get(),
3292 nsHtml5Tokenizer::SCRIPT_DATA
, reconsume
, pos
);
3293 NS_HTML5_CONTINUE(stateloop
);
3296 emitReplacementCharacter(buf
, pos
);
3297 state
= P::transition(
3299 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED
, reconsume
, pos
);
3300 NS_HTML5_CONTINUE(stateloop
);
3303 emitCarriageReturn
<P
>(buf
, pos
);
3304 state
= P::transition(
3306 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED
, reconsume
, pos
);
3307 NS_HTML5_BREAK(stateloop
);
3310 P::silentLineFeed(this);
3314 state
= P::transition(
3316 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED
, reconsume
, pos
);
3317 NS_HTML5_CONTINUE(stateloop
);
3321 scriptdatadoubleescapeddashdashloop_end
:;
3324 case SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN
: {
3326 if (++pos
== endPos
) {
3327 NS_HTML5_BREAK(stateloop
);
3329 c
= P::checkChar(this, buf
, pos
);
3334 P::transition(mViewSource
.get(),
3335 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPE_END
,
3337 NS_HTML5_BREAK(scriptdatadoubleescapedlessthanloop
);
3341 state
= P::transition(
3343 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED
, reconsume
, pos
);
3344 NS_HTML5_CONTINUE(stateloop
);
3348 scriptdatadoubleescapedlessthanloop_end
:;
3351 case SCRIPT_DATA_DOUBLE_ESCAPE_END
: {
3353 if (++pos
== endPos
) {
3354 NS_HTML5_BREAK(stateloop
);
3356 c
= P::checkChar(this, buf
, pos
);
3358 char16_t folded
= c
;
3359 if (c
>= 'A' && c
<= 'Z') {
3362 if (folded
!= nsHtml5Tokenizer::SCRIPT_ARR
[index
]) {
3364 state
= P::transition(
3366 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED
, reconsume
, pos
);
3367 NS_HTML5_CONTINUE(stateloop
);
3374 emitCarriageReturn
<P
>(buf
, pos
);
3375 state
= P::transition(mViewSource
.get(),
3376 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED
,
3378 NS_HTML5_BREAK(stateloop
);
3381 P::silentLineFeed(this);
3389 state
= P::transition(mViewSource
.get(),
3390 nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED
,
3392 NS_HTML5_CONTINUE(stateloop
);
3396 state
= P::transition(
3398 nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED
, reconsume
, pos
);
3399 NS_HTML5_CONTINUE(stateloop
);
3404 case MARKUP_DECLARATION_OCTYPE
: {
3406 if (++pos
== endPos
) {
3407 NS_HTML5_BREAK(stateloop
);
3409 c
= P::checkChar(this, buf
, pos
);
3411 char16_t folded
= c
;
3412 if (c
>= 'A' && c
<= 'Z') {
3415 if (folded
== nsHtml5Tokenizer::OCTYPE
[index
]) {
3418 if (P::reportErrors
) {
3422 state
= P::transition(mViewSource
.get(),
3423 nsHtml5Tokenizer::BOGUS_COMMENT
, reconsume
,
3425 NS_HTML5_CONTINUE(stateloop
);
3431 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DOCTYPE
,
3433 NS_HTML5_BREAK(markupdeclarationdoctypeloop
);
3436 markupdeclarationdoctypeloop_end
:;
3444 if (++pos
== endPos
) {
3445 NS_HTML5_BREAK(stateloop
);
3447 c
= P::checkChar(this, buf
, pos
);
3449 initDoctypeFields();
3452 P::silentCarriageReturn(this);
3453 state
= P::transition(mViewSource
.get(),
3454 nsHtml5Tokenizer::BEFORE_DOCTYPE_NAME
,
3456 NS_HTML5_BREAK(stateloop
);
3459 P::silentLineFeed(this);
3465 state
= P::transition(mViewSource
.get(),
3466 nsHtml5Tokenizer::BEFORE_DOCTYPE_NAME
,
3468 NS_HTML5_BREAK(doctypeloop
);
3471 if (P::reportErrors
) {
3472 errMissingSpaceBeforeDoctypeName();
3475 state
= P::transition(mViewSource
.get(),
3476 nsHtml5Tokenizer::BEFORE_DOCTYPE_NAME
,
3478 NS_HTML5_BREAK(doctypeloop
);
3485 case BEFORE_DOCTYPE_NAME
: {
3490 if (++pos
== endPos
) {
3491 NS_HTML5_BREAK(stateloop
);
3493 c
= P::checkChar(this, buf
, pos
);
3497 P::silentCarriageReturn(this);
3498 NS_HTML5_BREAK(stateloop
);
3501 P::silentLineFeed(this);
3510 if (P::reportErrors
) {
3511 errNamelessDoctype();
3514 emitDoctypeToken(pos
);
3515 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
3517 if (shouldSuspend
) {
3518 NS_HTML5_BREAK(stateloop
);
3520 NS_HTML5_CONTINUE(stateloop
);
3527 if (c
>= 'A' && c
<= 'Z') {
3530 clearStrBufBeforeUse();
3533 P::transition(mViewSource
.get(),
3534 nsHtml5Tokenizer::DOCTYPE_NAME
, reconsume
, pos
);
3535 NS_HTML5_BREAK(beforedoctypenameloop
);
3539 beforedoctypenameloop_end
:;
3542 case DOCTYPE_NAME
: {
3544 if (++pos
== endPos
) {
3545 NS_HTML5_BREAK(stateloop
);
3547 c
= P::checkChar(this, buf
, pos
);
3550 P::silentCarriageReturn(this);
3551 strBufToDoctypeName();
3552 state
= P::transition(mViewSource
.get(),
3553 nsHtml5Tokenizer::AFTER_DOCTYPE_NAME
,
3555 NS_HTML5_BREAK(stateloop
);
3558 P::silentLineFeed(this);
3564 strBufToDoctypeName();
3565 state
= P::transition(mViewSource
.get(),
3566 nsHtml5Tokenizer::AFTER_DOCTYPE_NAME
,
3568 NS_HTML5_BREAK(doctypenameloop
);
3571 strBufToDoctypeName();
3572 emitDoctypeToken(pos
);
3573 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
3575 if (shouldSuspend
) {
3576 NS_HTML5_BREAK(stateloop
);
3578 NS_HTML5_CONTINUE(stateloop
);
3585 if (c
>= 'A' && c
<= 'Z') {
3593 doctypenameloop_end
:;
3596 case AFTER_DOCTYPE_NAME
: {
3598 if (++pos
== endPos
) {
3599 NS_HTML5_BREAK(stateloop
);
3601 c
= P::checkChar(this, buf
, pos
);
3604 P::silentCarriageReturn(this);
3605 NS_HTML5_BREAK(stateloop
);
3608 P::silentLineFeed(this);
3617 emitDoctypeToken(pos
);
3618 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
3620 if (shouldSuspend
) {
3621 NS_HTML5_BREAK(stateloop
);
3623 NS_HTML5_CONTINUE(stateloop
);
3628 state
= P::transition(mViewSource
.get(),
3629 nsHtml5Tokenizer::DOCTYPE_UBLIC
, reconsume
,
3631 NS_HTML5_BREAK(afterdoctypenameloop
);
3636 state
= P::transition(mViewSource
.get(),
3637 nsHtml5Tokenizer::DOCTYPE_YSTEM
, reconsume
,
3639 NS_HTML5_CONTINUE(stateloop
);
3643 state
= P::transition(mViewSource
.get(),
3644 nsHtml5Tokenizer::BOGUS_DOCTYPE
, reconsume
,
3646 NS_HTML5_CONTINUE(stateloop
);
3650 afterdoctypenameloop_end
:;
3653 case DOCTYPE_UBLIC
: {
3655 if (++pos
== endPos
) {
3656 NS_HTML5_BREAK(stateloop
);
3658 c
= P::checkChar(this, buf
, pos
);
3660 char16_t folded
= c
;
3661 if (c
>= 'A' && c
<= 'Z') {
3664 if (folded
!= nsHtml5Tokenizer::UBLIC
[index
]) {
3667 state
= P::transition(mViewSource
.get(),
3668 nsHtml5Tokenizer::BOGUS_DOCTYPE
, reconsume
,
3670 NS_HTML5_CONTINUE(stateloop
);
3676 state
= P::transition(
3678 nsHtml5Tokenizer::AFTER_DOCTYPE_PUBLIC_KEYWORD
, reconsume
, pos
);
3679 NS_HTML5_BREAK(doctypeublicloop
);
3682 doctypeublicloop_end
:;
3685 case AFTER_DOCTYPE_PUBLIC_KEYWORD
: {
3690 if (++pos
== endPos
) {
3691 NS_HTML5_BREAK(stateloop
);
3693 c
= P::checkChar(this, buf
, pos
);
3697 P::silentCarriageReturn(this);
3698 state
= P::transition(
3700 nsHtml5Tokenizer::BEFORE_DOCTYPE_PUBLIC_IDENTIFIER
, reconsume
,
3702 NS_HTML5_BREAK(stateloop
);
3705 P::silentLineFeed(this);
3711 state
= P::transition(
3713 nsHtml5Tokenizer::BEFORE_DOCTYPE_PUBLIC_IDENTIFIER
, reconsume
,
3715 NS_HTML5_BREAK(afterdoctypepublickeywordloop
);
3718 if (P::reportErrors
) {
3719 errNoSpaceBetweenDoctypePublicKeywordAndQuote();
3721 clearStrBufBeforeUse();
3722 state
= P::transition(
3724 nsHtml5Tokenizer::DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED
,
3726 NS_HTML5_CONTINUE(stateloop
);
3729 if (P::reportErrors
) {
3730 errNoSpaceBetweenDoctypePublicKeywordAndQuote();
3732 clearStrBufBeforeUse();
3733 state
= P::transition(
3735 nsHtml5Tokenizer::DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED
,
3737 NS_HTML5_CONTINUE(stateloop
);
3740 if (P::reportErrors
) {
3741 errExpectedPublicId();
3744 emitDoctypeToken(pos
);
3745 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
3747 if (shouldSuspend
) {
3748 NS_HTML5_BREAK(stateloop
);
3750 NS_HTML5_CONTINUE(stateloop
);
3754 state
= P::transition(mViewSource
.get(),
3755 nsHtml5Tokenizer::BOGUS_DOCTYPE
, reconsume
,
3757 NS_HTML5_CONTINUE(stateloop
);
3761 afterdoctypepublickeywordloop_end
:;
3764 case BEFORE_DOCTYPE_PUBLIC_IDENTIFIER
: {
3766 if (++pos
== endPos
) {
3767 NS_HTML5_BREAK(stateloop
);
3769 c
= P::checkChar(this, buf
, pos
);
3772 P::silentCarriageReturn(this);
3773 NS_HTML5_BREAK(stateloop
);
3776 P::silentLineFeed(this);
3785 clearStrBufBeforeUse();
3786 state
= P::transition(
3788 nsHtml5Tokenizer::DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED
,
3790 NS_HTML5_BREAK(beforedoctypepublicidentifierloop
);
3793 clearStrBufBeforeUse();
3794 state
= P::transition(
3796 nsHtml5Tokenizer::DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED
,
3798 NS_HTML5_CONTINUE(stateloop
);
3801 if (P::reportErrors
) {
3802 errExpectedPublicId();
3805 emitDoctypeToken(pos
);
3806 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
3808 if (shouldSuspend
) {
3809 NS_HTML5_BREAK(stateloop
);
3811 NS_HTML5_CONTINUE(stateloop
);
3815 state
= P::transition(mViewSource
.get(),
3816 nsHtml5Tokenizer::BOGUS_DOCTYPE
, reconsume
,
3818 NS_HTML5_CONTINUE(stateloop
);
3822 beforedoctypepublicidentifierloop_end
:;
3825 case DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED
: {
3827 if (++pos
== endPos
) {
3828 NS_HTML5_BREAK(stateloop
);
3830 c
= P::checkChar(this, buf
, pos
);
3833 publicIdentifier
= strBufToString();
3834 state
= P::transition(
3836 nsHtml5Tokenizer::AFTER_DOCTYPE_PUBLIC_IDENTIFIER
, reconsume
,
3838 NS_HTML5_BREAK(doctypepublicidentifierdoublequotedloop
);
3841 if (P::reportErrors
) {
3845 publicIdentifier
= strBufToString();
3846 emitDoctypeToken(pos
);
3847 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
3849 if (shouldSuspend
) {
3850 NS_HTML5_BREAK(stateloop
);
3852 NS_HTML5_CONTINUE(stateloop
);
3855 appendStrBufCarriageReturn
<P
>();
3856 NS_HTML5_BREAK(stateloop
);
3859 appendStrBufLineFeed
<P
>();
3872 doctypepublicidentifierdoublequotedloop_end
:;
3875 case AFTER_DOCTYPE_PUBLIC_IDENTIFIER
: {
3877 if (++pos
== endPos
) {
3878 NS_HTML5_BREAK(stateloop
);
3880 c
= P::checkChar(this, buf
, pos
);
3883 P::silentCarriageReturn(this);
3884 state
= P::transition(
3887 BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS
,
3889 NS_HTML5_BREAK(stateloop
);
3892 P::silentLineFeed(this);
3898 state
= P::transition(
3901 BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS
,
3903 NS_HTML5_BREAK(afterdoctypepublicidentifierloop
);
3906 emitDoctypeToken(pos
);
3907 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
3909 if (shouldSuspend
) {
3910 NS_HTML5_BREAK(stateloop
);
3912 NS_HTML5_CONTINUE(stateloop
);
3915 if (P::reportErrors
) {
3916 errNoSpaceBetweenPublicAndSystemIds();
3918 clearStrBufBeforeUse();
3919 state
= P::transition(
3921 nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED
,
3923 NS_HTML5_CONTINUE(stateloop
);
3926 if (P::reportErrors
) {
3927 errNoSpaceBetweenPublicAndSystemIds();
3929 clearStrBufBeforeUse();
3930 state
= P::transition(
3932 nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED
,
3934 NS_HTML5_CONTINUE(stateloop
);
3938 state
= P::transition(mViewSource
.get(),
3939 nsHtml5Tokenizer::BOGUS_DOCTYPE
, reconsume
,
3941 NS_HTML5_CONTINUE(stateloop
);
3945 afterdoctypepublicidentifierloop_end
:;
3948 case BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS
: {
3950 if (++pos
== endPos
) {
3951 NS_HTML5_BREAK(stateloop
);
3953 c
= P::checkChar(this, buf
, pos
);
3956 P::silentCarriageReturn(this);
3957 NS_HTML5_BREAK(stateloop
);
3960 P::silentLineFeed(this);
3969 emitDoctypeToken(pos
);
3970 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
3972 if (shouldSuspend
) {
3973 NS_HTML5_BREAK(stateloop
);
3975 NS_HTML5_CONTINUE(stateloop
);
3978 clearStrBufBeforeUse();
3979 state
= P::transition(
3981 nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED
,
3983 NS_HTML5_BREAK(betweendoctypepublicandsystemidentifiersloop
);
3986 clearStrBufBeforeUse();
3987 state
= P::transition(
3989 nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED
,
3991 NS_HTML5_CONTINUE(stateloop
);
3995 state
= P::transition(mViewSource
.get(),
3996 nsHtml5Tokenizer::BOGUS_DOCTYPE
, reconsume
,
3998 NS_HTML5_CONTINUE(stateloop
);
4002 betweendoctypepublicandsystemidentifiersloop_end
:;
4005 case DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED
: {
4007 if (++pos
== endPos
) {
4008 NS_HTML5_BREAK(stateloop
);
4010 c
= P::checkChar(this, buf
, pos
);
4013 systemIdentifier
= strBufToString();
4014 state
= P::transition(
4016 nsHtml5Tokenizer::AFTER_DOCTYPE_SYSTEM_IDENTIFIER
, reconsume
,
4018 NS_HTML5_BREAK(doctypesystemidentifierdoublequotedloop
);
4021 if (P::reportErrors
) {
4025 systemIdentifier
= strBufToString();
4026 emitDoctypeToken(pos
);
4027 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
4029 if (shouldSuspend
) {
4030 NS_HTML5_BREAK(stateloop
);
4032 NS_HTML5_CONTINUE(stateloop
);
4035 appendStrBufCarriageReturn
<P
>();
4036 NS_HTML5_BREAK(stateloop
);
4039 appendStrBufLineFeed
<P
>();
4052 doctypesystemidentifierdoublequotedloop_end
:;
4055 case AFTER_DOCTYPE_SYSTEM_IDENTIFIER
: {
4057 if (++pos
== endPos
) {
4058 NS_HTML5_BREAK(stateloop
);
4060 c
= P::checkChar(this, buf
, pos
);
4063 P::silentCarriageReturn(this);
4064 NS_HTML5_BREAK(stateloop
);
4067 P::silentLineFeed(this);
4076 emitDoctypeToken(pos
);
4077 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
4079 if (shouldSuspend
) {
4080 NS_HTML5_BREAK(stateloop
);
4082 NS_HTML5_CONTINUE(stateloop
);
4085 bogusDoctypeWithoutQuirks();
4086 state
= P::transition(mViewSource
.get(),
4087 nsHtml5Tokenizer::BOGUS_DOCTYPE
, reconsume
,
4089 NS_HTML5_BREAK(afterdoctypesystemidentifierloop
);
4093 afterdoctypesystemidentifierloop_end
:;
4096 case BOGUS_DOCTYPE
: {
4101 if (++pos
== endPos
) {
4102 NS_HTML5_BREAK(stateloop
);
4104 c
= P::checkChar(this, buf
, pos
);
4108 emitDoctypeToken(pos
);
4109 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
4111 if (shouldSuspend
) {
4112 NS_HTML5_BREAK(stateloop
);
4114 NS_HTML5_CONTINUE(stateloop
);
4117 P::silentCarriageReturn(this);
4118 NS_HTML5_BREAK(stateloop
);
4121 P::silentLineFeed(this);
4130 case DOCTYPE_YSTEM
: {
4132 if (++pos
== endPos
) {
4133 NS_HTML5_BREAK(stateloop
);
4135 c
= P::checkChar(this, buf
, pos
);
4137 char16_t folded
= c
;
4138 if (c
>= 'A' && c
<= 'Z') {
4141 if (folded
!= nsHtml5Tokenizer::YSTEM
[index
]) {
4144 state
= P::transition(mViewSource
.get(),
4145 nsHtml5Tokenizer::BOGUS_DOCTYPE
, reconsume
,
4147 NS_HTML5_CONTINUE(stateloop
);
4150 NS_HTML5_CONTINUE(stateloop
);
4153 state
= P::transition(
4155 nsHtml5Tokenizer::AFTER_DOCTYPE_SYSTEM_KEYWORD
, reconsume
, pos
);
4156 NS_HTML5_BREAK(doctypeystemloop
);
4159 doctypeystemloop_end
:;
4162 case AFTER_DOCTYPE_SYSTEM_KEYWORD
: {
4167 if (++pos
== endPos
) {
4168 NS_HTML5_BREAK(stateloop
);
4170 c
= P::checkChar(this, buf
, pos
);
4174 P::silentCarriageReturn(this);
4175 state
= P::transition(
4177 nsHtml5Tokenizer::BEFORE_DOCTYPE_SYSTEM_IDENTIFIER
, reconsume
,
4179 NS_HTML5_BREAK(stateloop
);
4182 P::silentLineFeed(this);
4188 state
= P::transition(
4190 nsHtml5Tokenizer::BEFORE_DOCTYPE_SYSTEM_IDENTIFIER
, reconsume
,
4192 NS_HTML5_BREAK(afterdoctypesystemkeywordloop
);
4195 if (P::reportErrors
) {
4196 errNoSpaceBetweenDoctypeSystemKeywordAndQuote();
4198 clearStrBufBeforeUse();
4199 state
= P::transition(
4201 nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED
,
4203 NS_HTML5_CONTINUE(stateloop
);
4206 if (P::reportErrors
) {
4207 errNoSpaceBetweenDoctypeSystemKeywordAndQuote();
4209 clearStrBufBeforeUse();
4210 state
= P::transition(
4212 nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED
,
4214 NS_HTML5_CONTINUE(stateloop
);
4217 if (P::reportErrors
) {
4218 errExpectedPublicId();
4221 emitDoctypeToken(pos
);
4222 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
4224 if (shouldSuspend
) {
4225 NS_HTML5_BREAK(stateloop
);
4227 NS_HTML5_CONTINUE(stateloop
);
4231 state
= P::transition(mViewSource
.get(),
4232 nsHtml5Tokenizer::BOGUS_DOCTYPE
, reconsume
,
4234 NS_HTML5_CONTINUE(stateloop
);
4238 afterdoctypesystemkeywordloop_end
:;
4241 case BEFORE_DOCTYPE_SYSTEM_IDENTIFIER
: {
4243 if (++pos
== endPos
) {
4244 NS_HTML5_BREAK(stateloop
);
4246 c
= P::checkChar(this, buf
, pos
);
4249 P::silentCarriageReturn(this);
4250 NS_HTML5_BREAK(stateloop
);
4253 P::silentLineFeed(this);
4262 clearStrBufBeforeUse();
4263 state
= P::transition(
4265 nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED
,
4267 NS_HTML5_CONTINUE(stateloop
);
4270 clearStrBufBeforeUse();
4271 state
= P::transition(
4273 nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED
,
4275 NS_HTML5_BREAK(beforedoctypesystemidentifierloop
);
4278 if (P::reportErrors
) {
4279 errExpectedSystemId();
4282 emitDoctypeToken(pos
);
4283 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
4285 if (shouldSuspend
) {
4286 NS_HTML5_BREAK(stateloop
);
4288 NS_HTML5_CONTINUE(stateloop
);
4292 state
= P::transition(mViewSource
.get(),
4293 nsHtml5Tokenizer::BOGUS_DOCTYPE
, reconsume
,
4295 NS_HTML5_CONTINUE(stateloop
);
4299 beforedoctypesystemidentifierloop_end
:;
4302 case DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED
: {
4304 if (++pos
== endPos
) {
4305 NS_HTML5_BREAK(stateloop
);
4307 c
= P::checkChar(this, buf
, pos
);
4310 systemIdentifier
= strBufToString();
4311 state
= P::transition(
4313 nsHtml5Tokenizer::AFTER_DOCTYPE_SYSTEM_IDENTIFIER
, reconsume
,
4315 NS_HTML5_CONTINUE(stateloop
);
4318 if (P::reportErrors
) {
4322 systemIdentifier
= strBufToString();
4323 emitDoctypeToken(pos
);
4324 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
4326 if (shouldSuspend
) {
4327 NS_HTML5_BREAK(stateloop
);
4329 NS_HTML5_CONTINUE(stateloop
);
4332 appendStrBufCarriageReturn
<P
>();
4333 NS_HTML5_BREAK(stateloop
);
4336 appendStrBufLineFeed
<P
>();
4350 case DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED
: {
4352 if (++pos
== endPos
) {
4353 NS_HTML5_BREAK(stateloop
);
4355 c
= P::checkChar(this, buf
, pos
);
4358 publicIdentifier
= strBufToString();
4359 state
= P::transition(
4361 nsHtml5Tokenizer::AFTER_DOCTYPE_PUBLIC_IDENTIFIER
, reconsume
,
4363 NS_HTML5_CONTINUE(stateloop
);
4366 if (P::reportErrors
) {
4370 publicIdentifier
= strBufToString();
4371 emitDoctypeToken(pos
);
4372 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
4374 if (shouldSuspend
) {
4375 NS_HTML5_BREAK(stateloop
);
4377 NS_HTML5_CONTINUE(stateloop
);
4380 appendStrBufCarriageReturn
<P
>();
4381 NS_HTML5_BREAK(stateloop
);
4384 appendStrBufLineFeed
<P
>();
4398 case PROCESSING_INSTRUCTION
: {
4400 if (++pos
== endPos
) {
4401 NS_HTML5_BREAK(stateloop
);
4403 c
= P::checkChar(this, buf
, pos
);
4406 state
= P::transition(
4408 nsHtml5Tokenizer::PROCESSING_INSTRUCTION_QUESTION_MARK
,
4410 NS_HTML5_BREAK(processinginstructionloop
);
4417 processinginstructionloop_end
:;
4420 case PROCESSING_INSTRUCTION_QUESTION_MARK
: {
4421 if (++pos
== endPos
) {
4422 NS_HTML5_BREAK(stateloop
);
4424 c
= P::checkChar(this, buf
, pos
);
4427 state
= P::transition(mViewSource
.get(), nsHtml5Tokenizer::DATA
,
4429 suspendIfRequestedAfterCurrentNonTextToken();
4430 if (shouldSuspend
) {
4431 NS_HTML5_BREAK(stateloop
);
4433 NS_HTML5_CONTINUE(stateloop
);
4436 state
= P::transition(mViewSource
.get(),
4437 nsHtml5Tokenizer::PROCESSING_INSTRUCTION
,
4439 NS_HTML5_CONTINUE(stateloop
);
4446 flushChars(buf
, pos
);
4448 returnStateSave
= returnState
;
4452 void nsHtml5Tokenizer::initDoctypeFields() {
4453 clearStrBufAfterUse();
4454 doctypeName
= nullptr;
4455 if (systemIdentifier
) {
4456 systemIdentifier
.Release();
4457 systemIdentifier
= nullptr;
4459 if (publicIdentifier
) {
4460 publicIdentifier
.Release();
4461 publicIdentifier
= nullptr;
4463 forceQuirks
= false;
4467 void nsHtml5Tokenizer::adjustDoubleHyphenAndAppendToStrBufCarriageReturn() {
4468 P::silentCarriageReturn(this);
4469 adjustDoubleHyphenAndAppendToStrBufAndErr('\n', false);
4473 void nsHtml5Tokenizer::adjustDoubleHyphenAndAppendToStrBufLineFeed() {
4474 P::silentLineFeed(this);
4475 adjustDoubleHyphenAndAppendToStrBufAndErr('\n', false);
4479 void nsHtml5Tokenizer::appendStrBufLineFeed() {
4480 P::silentLineFeed(this);
4485 void nsHtml5Tokenizer::appendStrBufCarriageReturn() {
4486 P::silentCarriageReturn(this);
4491 void nsHtml5Tokenizer::emitCarriageReturn(char16_t
* buf
, int32_t pos
) {
4492 P::silentCarriageReturn(this);
4493 flushChars(buf
, pos
);
4494 tokenHandler
->characters(nsHtml5Tokenizer::LF
, 0, 1);
4498 void nsHtml5Tokenizer::emitReplacementCharacter(char16_t
* buf
, int32_t pos
) {
4499 flushChars(buf
, pos
);
4500 tokenHandler
->zeroOriginatingReplacementCharacter();
4504 void nsHtml5Tokenizer::maybeEmitReplacementCharacter(char16_t
* buf
,
4506 flushChars(buf
, pos
);
4507 tokenHandler
->zeroOrReplacementCharacter();
4511 void nsHtml5Tokenizer::emitPlaintextReplacementCharacter(char16_t
* buf
,
4513 flushChars(buf
, pos
);
4514 tokenHandler
->characters(REPLACEMENT_CHARACTER
, 0, 1);
4518 void nsHtml5Tokenizer::setAdditionalAndRememberAmpersandLocation(char16_t add
) {
4522 void nsHtml5Tokenizer::bogusDoctype() {
4527 void nsHtml5Tokenizer::bogusDoctypeWithoutQuirks() {
4529 forceQuirks
= false;
4532 void nsHtml5Tokenizer::handleNcrValue(int32_t returnState
) {
4533 if (value
<= 0xFFFF) {
4534 if (value
>= 0x80 && value
<= 0x9f) {
4536 char16_t
* val
= nsHtml5NamedCharacters::WINDOWS_1252
[value
- 0x80];
4537 emitOrAppendOne(val
, returnState
);
4538 } else if (value
== 0x0) {
4540 emitOrAppendOne(nsHtml5Tokenizer::REPLACEMENT_CHARACTER
, returnState
);
4541 } else if ((value
& 0xF800) == 0xD800) {
4543 emitOrAppendOne(nsHtml5Tokenizer::REPLACEMENT_CHARACTER
, returnState
);
4545 char16_t ch
= (char16_t
)value
;
4547 emitOrAppendOne(bmpChar
, returnState
);
4549 } else if (value
<= 0x10FFFF) {
4550 astralChar
[0] = (char16_t
)(nsHtml5Tokenizer::LEAD_OFFSET
+ (value
>> 10));
4551 astralChar
[1] = (char16_t
)(0xDC00 + (value
& 0x3FF));
4552 emitOrAppendTwo(astralChar
, returnState
);
4555 emitOrAppendOne(nsHtml5Tokenizer::REPLACEMENT_CHARACTER
, returnState
);
4559 void nsHtml5Tokenizer::eof() {
4560 int32_t state
= stateSave
;
4561 int32_t returnState
= returnStateSave
;
4565 case SCRIPT_DATA_LESS_THAN_SIGN
:
4566 case SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN
: {
4567 tokenHandler
->characters(nsHtml5Tokenizer::LT_GT
, 0, 1);
4568 NS_HTML5_BREAK(eofloop
);
4572 tokenHandler
->characters(nsHtml5Tokenizer::LT_GT
, 0, 1);
4573 NS_HTML5_BREAK(eofloop
);
4575 case RAWTEXT_RCDATA_LESS_THAN_SIGN
: {
4576 tokenHandler
->characters(nsHtml5Tokenizer::LT_GT
, 0, 1);
4577 NS_HTML5_BREAK(eofloop
);
4579 case NON_DATA_END_TAG_NAME
: {
4580 tokenHandler
->characters(nsHtml5Tokenizer::LT_SOLIDUS
, 0, 2);
4582 NS_HTML5_BREAK(eofloop
);
4584 case CLOSE_TAG_OPEN
: {
4586 tokenHandler
->characters(nsHtml5Tokenizer::LT_SOLIDUS
, 0, 2);
4587 NS_HTML5_BREAK(eofloop
);
4591 NS_HTML5_BREAK(eofloop
);
4593 case BEFORE_ATTRIBUTE_NAME
:
4594 case AFTER_ATTRIBUTE_VALUE_QUOTED
:
4595 case SELF_CLOSING_START_TAG
: {
4597 NS_HTML5_BREAK(eofloop
);
4599 case ATTRIBUTE_NAME
: {
4600 errEofInAttributeName();
4601 NS_HTML5_BREAK(eofloop
);
4603 case AFTER_ATTRIBUTE_NAME
:
4604 case BEFORE_ATTRIBUTE_VALUE
: {
4606 NS_HTML5_BREAK(eofloop
);
4608 case ATTRIBUTE_VALUE_DOUBLE_QUOTED
:
4609 case ATTRIBUTE_VALUE_SINGLE_QUOTED
:
4610 case ATTRIBUTE_VALUE_UNQUOTED
: {
4611 errEofInAttributeValue();
4612 NS_HTML5_BREAK(eofloop
);
4614 case BOGUS_COMMENT
: {
4616 NS_HTML5_BREAK(eofloop
);
4618 case BOGUS_COMMENT_HYPHEN
: {
4620 NS_HTML5_BREAK(eofloop
);
4622 case MARKUP_DECLARATION_OPEN
: {
4625 NS_HTML5_BREAK(eofloop
);
4627 case MARKUP_DECLARATION_HYPHEN
: {
4630 NS_HTML5_BREAK(eofloop
);
4632 case MARKUP_DECLARATION_OCTYPE
: {
4638 doctypeName
= nullptr;
4639 if (systemIdentifier
) {
4640 systemIdentifier
.Release();
4641 systemIdentifier
= nullptr;
4643 if (publicIdentifier
) {
4644 publicIdentifier
.Release();
4645 publicIdentifier
= nullptr;
4648 emitDoctypeToken(0);
4649 NS_HTML5_BREAK(eofloop
);
4651 NS_HTML5_BREAK(eofloop
);
4655 case COMMENT_LESSTHAN
:
4656 case COMMENT_LESSTHAN_BANG
: {
4659 NS_HTML5_BREAK(eofloop
);
4662 case COMMENT_LESSTHAN_BANG_DASH_DASH
: {
4665 NS_HTML5_BREAK(eofloop
);
4667 case COMMENT_END_DASH
:
4668 case COMMENT_START_DASH
:
4669 case COMMENT_LESSTHAN_BANG_DASH
: {
4672 NS_HTML5_BREAK(eofloop
);
4674 case COMMENT_END_BANG
: {
4677 NS_HTML5_BREAK(eofloop
);
4680 case BEFORE_DOCTYPE_NAME
: {
4683 emitDoctypeToken(0);
4684 NS_HTML5_BREAK(eofloop
);
4686 case DOCTYPE_NAME
: {
4688 strBufToDoctypeName();
4690 emitDoctypeToken(0);
4691 NS_HTML5_BREAK(eofloop
);
4695 case AFTER_DOCTYPE_NAME
:
4696 case AFTER_DOCTYPE_PUBLIC_KEYWORD
:
4697 case AFTER_DOCTYPE_SYSTEM_KEYWORD
:
4698 case BEFORE_DOCTYPE_PUBLIC_IDENTIFIER
: {
4701 emitDoctypeToken(0);
4702 NS_HTML5_BREAK(eofloop
);
4704 case DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED
:
4705 case DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED
: {
4708 publicIdentifier
= strBufToString();
4709 emitDoctypeToken(0);
4710 NS_HTML5_BREAK(eofloop
);
4712 case AFTER_DOCTYPE_PUBLIC_IDENTIFIER
:
4713 case BEFORE_DOCTYPE_SYSTEM_IDENTIFIER
:
4714 case BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS
: {
4717 emitDoctypeToken(0);
4718 NS_HTML5_BREAK(eofloop
);
4720 case DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED
:
4721 case DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED
: {
4724 systemIdentifier
= strBufToString();
4725 emitDoctypeToken(0);
4726 NS_HTML5_BREAK(eofloop
);
4728 case AFTER_DOCTYPE_SYSTEM_IDENTIFIER
: {
4731 emitDoctypeToken(0);
4732 NS_HTML5_BREAK(eofloop
);
4734 case BOGUS_DOCTYPE
: {
4735 emitDoctypeToken(0);
4736 NS_HTML5_BREAK(eofloop
);
4738 case CONSUME_CHARACTER_REFERENCE
: {
4739 emitOrAppendCharRefBuf(returnState
);
4740 state
= returnState
;
4743 case CHARACTER_REFERENCE_HILO_LOOKUP
: {
4744 emitOrAppendCharRefBuf(returnState
);
4745 state
= returnState
;
4748 case CHARACTER_REFERENCE_TAIL
: {
4754 NS_HTML5_BREAK(hiloop
);
4756 if (entCol
== nsHtml5NamedCharacters::NAMES
[hi
].length()) {
4757 NS_HTML5_BREAK(hiloop
);
4759 if (entCol
> nsHtml5NamedCharacters::NAMES
[hi
].length()) {
4760 NS_HTML5_BREAK(outer
);
4761 } else if (c
< nsHtml5NamedCharacters::NAMES
[hi
].charAt(entCol
)) {
4764 NS_HTML5_BREAK(hiloop
);
4770 NS_HTML5_BREAK(outer
);
4772 if (entCol
== nsHtml5NamedCharacters::NAMES
[lo
].length()) {
4774 charRefBufMark
= charRefBufLen
;
4776 } else if (entCol
> nsHtml5NamedCharacters::NAMES
[lo
].length()) {
4777 NS_HTML5_BREAK(outer
);
4778 } else if (c
> nsHtml5NamedCharacters::NAMES
[lo
].charAt(entCol
)) {
4781 NS_HTML5_BREAK(loloop
);
4786 NS_HTML5_BREAK(outer
);
4791 if (candidate
== -1) {
4792 emitOrAppendCharRefBuf(returnState
);
4793 state
= returnState
;
4794 NS_HTML5_CONTINUE(eofloop
);
4796 const nsHtml5CharacterName
& candidateName
=
4797 nsHtml5NamedCharacters::NAMES
[candidate
];
4798 if (!candidateName
.length() ||
4799 candidateName
.charAt(candidateName
.length() - 1) != ';') {
4800 if ((returnState
& DATA_AND_RCDATA_MASK
)) {
4802 if (charRefBufMark
== charRefBufLen
) {
4805 ch
= charRefBuf
[charRefBufMark
];
4807 if ((ch
>= '0' && ch
<= '9') || (ch
>= 'A' && ch
<= 'Z') ||
4808 (ch
>= 'a' && ch
<= 'z')) {
4809 appendCharRefBufToStrBuf();
4810 state
= returnState
;
4811 NS_HTML5_CONTINUE(eofloop
);
4814 if ((returnState
& DATA_AND_RCDATA_MASK
)) {
4815 errUnescapedAmpersandInterpretedAsCharacterReference();
4817 errNotSemicolonTerminated();
4820 const char16_t
* val
= nsHtml5NamedCharacters::VALUES
[candidate
];
4822 emitOrAppendOne(val
, returnState
);
4824 emitOrAppendTwo(val
, returnState
);
4826 if (charRefBufMark
< charRefBufLen
) {
4827 if ((returnState
& DATA_AND_RCDATA_MASK
)) {
4828 appendStrBuf(charRefBuf
, charRefBufMark
,
4829 charRefBufLen
- charRefBufMark
);
4831 tokenHandler
->characters(charRefBuf
, charRefBufMark
,
4832 charRefBufLen
- charRefBufMark
);
4836 state
= returnState
;
4837 NS_HTML5_CONTINUE(eofloop
);
4841 case DECIMAL_NRC_LOOP
:
4842 case HEX_NCR_LOOP
: {
4845 emitOrAppendCharRefBuf(returnState
);
4846 state
= returnState
;
4849 errCharRefLacksSemicolon();
4851 handleNcrValue(returnState
);
4852 state
= returnState
;
4856 tokenHandler
->characters(nsHtml5Tokenizer::RSQB_RSQB
, 0, 1);
4857 NS_HTML5_BREAK(eofloop
);
4859 case CDATA_RSQB_RSQB
: {
4860 tokenHandler
->characters(nsHtml5Tokenizer::RSQB_RSQB
, 0, 2);
4861 NS_HTML5_BREAK(eofloop
);
4865 NS_HTML5_BREAK(eofloop
);
4870 tokenHandler
->eof();
4874 void nsHtml5Tokenizer::emitDoctypeToken(int32_t pos
) {
4877 tokenHandler
->doctype(doctypeName
, publicIdentifier
, systemIdentifier
,
4879 doctypeName
= nullptr;
4880 publicIdentifier
.Release();
4881 publicIdentifier
= nullptr;
4882 systemIdentifier
.Release();
4883 systemIdentifier
= nullptr;
4884 suspendIfRequestedAfterCurrentNonTextToken();
4887 void nsHtml5Tokenizer::suspendIfRequestedAfterCurrentNonTextToken() {
4888 if (suspendAfterCurrentNonTextToken
) {
4889 suspendAfterCurrentNonTextToken
= false;
4890 shouldSuspend
= true;
4894 void nsHtml5Tokenizer::suspendAfterCurrentTokenIfNotInText() {
4895 switch (stateSave
) {
4900 case SCRIPT_DATA_ESCAPED
:
4902 case NON_DATA_END_TAG_NAME
:
4903 case SCRIPT_DATA_LESS_THAN_SIGN
:
4904 case SCRIPT_DATA_ESCAPE_START
:
4905 case SCRIPT_DATA_ESCAPE_START_DASH
:
4906 case SCRIPT_DATA_ESCAPED_DASH
:
4907 case SCRIPT_DATA_ESCAPED_DASH_DASH
:
4908 case RAWTEXT_RCDATA_LESS_THAN_SIGN
:
4909 case SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN
:
4910 case SCRIPT_DATA_DOUBLE_ESCAPE_START
:
4911 case SCRIPT_DATA_DOUBLE_ESCAPED
:
4912 case SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN
:
4913 case SCRIPT_DATA_DOUBLE_ESCAPED_DASH
:
4914 case SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH
:
4915 case SCRIPT_DATA_DOUBLE_ESCAPE_END
: {
4919 case BEFORE_ATTRIBUTE_NAME
:
4920 case ATTRIBUTE_NAME
:
4921 case AFTER_ATTRIBUTE_NAME
:
4922 case BEFORE_ATTRIBUTE_VALUE
:
4923 case AFTER_ATTRIBUTE_VALUE_QUOTED
:
4925 case MARKUP_DECLARATION_OPEN
:
4927 case BEFORE_DOCTYPE_NAME
:
4929 case AFTER_DOCTYPE_NAME
:
4930 case BEFORE_DOCTYPE_PUBLIC_IDENTIFIER
:
4931 case DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED
:
4932 case DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED
:
4933 case AFTER_DOCTYPE_PUBLIC_IDENTIFIER
:
4934 case BEFORE_DOCTYPE_SYSTEM_IDENTIFIER
:
4935 case DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED
:
4936 case DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED
:
4937 case AFTER_DOCTYPE_SYSTEM_IDENTIFIER
:
4940 case COMMENT_START_DASH
:
4942 case COMMENT_END_DASH
:
4944 case COMMENT_END_BANG
:
4946 case CLOSE_TAG_OPEN
:
4947 case MARKUP_DECLARATION_HYPHEN
:
4948 case MARKUP_DECLARATION_OCTYPE
:
4951 case AFTER_DOCTYPE_PUBLIC_KEYWORD
:
4952 case BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS
:
4953 case AFTER_DOCTYPE_SYSTEM_KEYWORD
:
4954 case SELF_CLOSING_START_TAG
:
4955 case ATTRIBUTE_VALUE_DOUBLE_QUOTED
:
4956 case ATTRIBUTE_VALUE_SINGLE_QUOTED
:
4957 case ATTRIBUTE_VALUE_UNQUOTED
:
4958 case BOGUS_COMMENT_HYPHEN
:
4959 case COMMENT_LESSTHAN
:
4960 case COMMENT_LESSTHAN_BANG
:
4961 case COMMENT_LESSTHAN_BANG_DASH
:
4962 case COMMENT_LESSTHAN_BANG_DASH_DASH
:
4966 case CDATA_RSQB_RSQB
:
4967 case PROCESSING_INSTRUCTION
:
4968 case PROCESSING_INSTRUCTION_QUESTION_MARK
: {
4971 case CONSUME_CHARACTER_REFERENCE
:
4973 case CHARACTER_REFERENCE_TAIL
:
4975 case DECIMAL_NRC_LOOP
:
4976 case HANDLE_NCR_VALUE
:
4977 case HANDLE_NCR_VALUE_RECONSUME
:
4978 case CHARACTER_REFERENCE_HILO_LOOKUP
: {
4979 if (returnStateSave
== DATA
|| returnStateSave
== RCDATA
) {
4985 MOZ_ASSERT(false, "Incomplete switch");
4989 suspendAfterCurrentNonTextToken
= true;
4992 bool nsHtml5Tokenizer::suspensionAfterCurrentNonTextTokenPending() {
4993 return suspendAfterCurrentNonTextToken
;
4996 bool nsHtml5Tokenizer::internalEncodingDeclaration(
4997 nsHtml5String internalCharset
) {
4998 if (encodingDeclarationHandler
) {
4999 return encodingDeclarationHandler
->internalEncodingDeclaration(
5005 void nsHtml5Tokenizer::emitOrAppendTwo(const char16_t
* val
,
5006 int32_t returnState
) {
5007 if ((returnState
& DATA_AND_RCDATA_MASK
)) {
5008 appendStrBuf(val
[0]);
5009 appendStrBuf(val
[1]);
5011 tokenHandler
->characters(val
, 0, 2);
5015 void nsHtml5Tokenizer::emitOrAppendOne(const char16_t
* val
,
5016 int32_t returnState
) {
5017 if ((returnState
& DATA_AND_RCDATA_MASK
)) {
5018 appendStrBuf(val
[0]);
5020 tokenHandler
->characters(val
, 0, 1);
5024 void nsHtml5Tokenizer::end() {
5026 doctypeName
= nullptr;
5027 if (systemIdentifier
) {
5028 systemIdentifier
.Release();
5029 systemIdentifier
= nullptr;
5031 if (publicIdentifier
) {
5032 publicIdentifier
.Release();
5033 publicIdentifier
= nullptr;
5036 nonInternedTagName
->setNameForNonInterned(nullptr, false);
5037 attributeName
= nullptr;
5038 nonInternedAttributeName
->setNameForNonInterned(nullptr);
5039 tokenHandler
->endTokenization();
5041 attributes
->clear(0);
5045 void nsHtml5Tokenizer::requestSuspension() { shouldSuspend
= true; }
5047 bool nsHtml5Tokenizer::isInDataState() { return (stateSave
== DATA
); }
5049 void nsHtml5Tokenizer::resetToDataState() {
5050 clearStrBufAfterUse();
5052 stateSave
= nsHtml5Tokenizer::DATA
;
5055 forceQuirks
= false;
5065 suspendAfterCurrentNonTextToken
= false;
5067 shouldSuspend
= false;
5068 initDoctypeFields();
5069 containsHyphen
= false;
5071 attributeName
= nullptr;
5072 if (newAttributesEachTime
) {
5075 attributes
= nullptr;
5080 void nsHtml5Tokenizer::loadState(nsHtml5Tokenizer
* other
) {
5081 strBufLen
= other
->strBufLen
;
5082 if (strBufLen
> strBuf
.length
) {
5083 strBuf
= jArray
<char16_t
, int32_t>::newJArray(strBufLen
);
5085 nsHtml5ArrayCopy::arraycopy(other
->strBuf
, strBuf
, strBufLen
);
5086 charRefBufLen
= other
->charRefBufLen
;
5087 nsHtml5ArrayCopy::arraycopy(other
->charRefBuf
, charRefBuf
, charRefBufLen
);
5088 stateSave
= other
->stateSave
;
5089 returnStateSave
= other
->returnStateSave
;
5090 endTagExpectation
= other
->endTagExpectation
;
5091 endTagExpectationAsArray
= other
->endTagExpectationAsArray
;
5092 lastCR
= other
->lastCR
;
5093 index
= other
->index
;
5094 forceQuirks
= other
->forceQuirks
;
5095 additional
= other
->additional
;
5096 entCol
= other
->entCol
;
5097 firstCharKey
= other
->firstCharKey
;
5100 candidate
= other
->candidate
;
5101 charRefBufMark
= other
->charRefBufMark
;
5102 value
= other
->value
;
5103 seenDigits
= other
->seenDigits
;
5104 endTag
= other
->endTag
;
5105 shouldSuspend
= false;
5106 suspendAfterCurrentNonTextToken
= false;
5107 doctypeName
= other
->doctypeName
;
5108 systemIdentifier
.Release();
5109 if (!other
->systemIdentifier
) {
5110 systemIdentifier
= nullptr;
5113 nsHtml5Portability::newStringFromString(other
->systemIdentifier
);
5115 publicIdentifier
.Release();
5116 if (!other
->publicIdentifier
) {
5117 publicIdentifier
= nullptr;
5120 nsHtml5Portability::newStringFromString(other
->publicIdentifier
);
5122 containsHyphen
= other
->containsHyphen
;
5123 if (!other
->tagName
) {
5125 } else if (other
->tagName
->isInterned()) {
5126 tagName
= other
->tagName
;
5128 nonInternedTagName
->setNameForNonInterned(other
->tagName
->getName(),
5129 other
->tagName
->isCustom());
5130 tagName
= nonInternedTagName
;
5132 if (!other
->attributeName
) {
5133 attributeName
= nullptr;
5134 } else if (other
->attributeName
->isInterned()) {
5135 attributeName
= other
->attributeName
;
5137 nonInternedAttributeName
->setNameForNonInterned(
5138 other
->attributeName
->getLocal(nsHtml5AttributeName::HTML
));
5139 attributeName
= nonInternedAttributeName
;
5142 if (!other
->attributes
) {
5143 attributes
= nullptr;
5145 attributes
= other
->attributes
->cloneAttributes();
5149 void nsHtml5Tokenizer::initializeWithoutStarting() {
5157 void nsHtml5Tokenizer::setEncodingDeclarationHandler(
5158 nsHtml5StreamParser
* encodingDeclarationHandler
) {
5159 this->encodingDeclarationHandler
= encodingDeclarationHandler
;
5162 nsHtml5Tokenizer::~nsHtml5Tokenizer() {
5163 MOZ_COUNT_DTOR(nsHtml5Tokenizer
);
5164 delete nonInternedTagName
;
5165 nonInternedTagName
= nullptr;
5166 delete nonInternedAttributeName
;
5167 nonInternedAttributeName
= nullptr;
5169 attributes
= nullptr;
5172 void nsHtml5Tokenizer::initializeStatics() {}
5174 void nsHtml5Tokenizer::releaseStatics() {}
5176 #include "nsHtml5TokenizerCppSupplement.h"