Line data Source code
1 : /*
2 : * Copyright (c) 2005-2007 Henri Sivonen
3 : * Copyright (c) 2007-2015 Mozilla Foundation
4 : * Portions of comments Copyright 2004-2010 Apple Computer, Inc., Mozilla
5 : * Foundation, and Opera Software ASA.
6 : *
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:
13 : *
14 : * The above copyright notice and this permission notice shall be included in
15 : * all copies or substantial portions of the Software.
16 : *
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.
24 : */
25 :
26 : /*
27 : * THIS IS A GENERATED FILE. PLEASE DO NOT EDIT.
28 : * Please edit Tokenizer.java instead and regenerate.
29 : */
30 :
31 : #define nsHtml5Tokenizer_cpp__
32 :
33 : #include "nsIAtom.h"
34 : #include "nsHtml5AtomTable.h"
35 : #include "nsHtml5String.h"
36 : #include "nsIContent.h"
37 : #include "nsTraceRefcnt.h"
38 : #include "jArray.h"
39 : #include "nsHtml5DocumentMode.h"
40 : #include "nsHtml5ArrayCopy.h"
41 : #include "nsHtml5NamedCharacters.h"
42 : #include "nsHtml5NamedCharactersAccel.h"
43 : #include "nsGkAtoms.h"
44 : #include "nsAHtml5TreeBuilderState.h"
45 : #include "nsHtml5Macros.h"
46 : #include "nsHtml5Highlighter.h"
47 : #include "nsHtml5TokenizerLoopPolicies.h"
48 :
49 : #include "nsHtml5AttributeName.h"
50 : #include "nsHtml5ElementName.h"
51 : #include "nsHtml5TreeBuilder.h"
52 : #include "nsHtml5MetaScanner.h"
53 : #include "nsHtml5StackNode.h"
54 : #include "nsHtml5UTF16Buffer.h"
55 : #include "nsHtml5StateSnapshot.h"
56 : #include "nsHtml5Portability.h"
57 :
58 : #include "nsHtml5Tokenizer.h"
59 :
60 : char16_t nsHtml5Tokenizer::LT_GT[] = { '<', '>' };
61 : char16_t nsHtml5Tokenizer::LT_SOLIDUS[] = { '<', '/' };
62 : char16_t nsHtml5Tokenizer::RSQB_RSQB[] = { ']', ']' };
63 : char16_t nsHtml5Tokenizer::REPLACEMENT_CHARACTER[] = { 0xfffd };
64 : char16_t nsHtml5Tokenizer::LF[] = { '\n' };
65 : char16_t nsHtml5Tokenizer::CDATA_LSQB[] = { 'C', 'D', 'A', 'T', 'A', '[' };
66 : char16_t nsHtml5Tokenizer::OCTYPE[] = { 'o', 'c', 't', 'y', 'p', 'e' };
67 : char16_t nsHtml5Tokenizer::UBLIC[] = { 'u', 'b', 'l', 'i', 'c' };
68 : char16_t nsHtml5Tokenizer::YSTEM[] = { 'y', 's', 't', 'e', 'm' };
69 : static char16_t const TITLE_ARR_DATA[] = { 't', 'i', 't', 'l', 'e' };
70 : staticJArray<char16_t,int32_t> nsHtml5Tokenizer::TITLE_ARR = { TITLE_ARR_DATA, MOZ_ARRAY_LENGTH(TITLE_ARR_DATA) };
71 : static char16_t const SCRIPT_ARR_DATA[] = { 's', 'c', 'r', 'i', 'p', 't' };
72 : staticJArray<char16_t,int32_t> nsHtml5Tokenizer::SCRIPT_ARR = { SCRIPT_ARR_DATA, MOZ_ARRAY_LENGTH(SCRIPT_ARR_DATA) };
73 : static char16_t const STYLE_ARR_DATA[] = { 's', 't', 'y', 'l', 'e' };
74 : staticJArray<char16_t,int32_t> nsHtml5Tokenizer::STYLE_ARR = { STYLE_ARR_DATA, MOZ_ARRAY_LENGTH(STYLE_ARR_DATA) };
75 : static char16_t const PLAINTEXT_ARR_DATA[] = { 'p', 'l', 'a', 'i', 'n', 't', 'e', 'x', 't' };
76 : staticJArray<char16_t,int32_t> nsHtml5Tokenizer::PLAINTEXT_ARR = { PLAINTEXT_ARR_DATA, MOZ_ARRAY_LENGTH(PLAINTEXT_ARR_DATA) };
77 : static char16_t const XMP_ARR_DATA[] = { 'x', 'm', 'p' };
78 : staticJArray<char16_t,int32_t> nsHtml5Tokenizer::XMP_ARR = { XMP_ARR_DATA, MOZ_ARRAY_LENGTH(XMP_ARR_DATA) };
79 : static char16_t const TEXTAREA_ARR_DATA[] = { 't', 'e', 'x', 't', 'a', 'r', 'e', 'a' };
80 : staticJArray<char16_t,int32_t> nsHtml5Tokenizer::TEXTAREA_ARR = { TEXTAREA_ARR_DATA, MOZ_ARRAY_LENGTH(TEXTAREA_ARR_DATA) };
81 : static char16_t const IFRAME_ARR_DATA[] = { 'i', 'f', 'r', 'a', 'm', 'e' };
82 : staticJArray<char16_t,int32_t> nsHtml5Tokenizer::IFRAME_ARR = { IFRAME_ARR_DATA, MOZ_ARRAY_LENGTH(IFRAME_ARR_DATA) };
83 : static char16_t const NOEMBED_ARR_DATA[] = { 'n', 'o', 'e', 'm', 'b', 'e', 'd' };
84 : staticJArray<char16_t,int32_t> nsHtml5Tokenizer::NOEMBED_ARR = { NOEMBED_ARR_DATA, MOZ_ARRAY_LENGTH(NOEMBED_ARR_DATA) };
85 : static char16_t const NOSCRIPT_ARR_DATA[] = { 'n', 'o', 's', 'c', 'r', 'i', 'p', 't' };
86 : staticJArray<char16_t,int32_t> nsHtml5Tokenizer::NOSCRIPT_ARR = { NOSCRIPT_ARR_DATA, MOZ_ARRAY_LENGTH(NOSCRIPT_ARR_DATA) };
87 : static char16_t const NOFRAMES_ARR_DATA[] = { 'n', 'o', 'f', 'r', 'a', 'm', 'e', 's' };
88 : staticJArray<char16_t,int32_t> nsHtml5Tokenizer::NOFRAMES_ARR = { NOFRAMES_ARR_DATA, MOZ_ARRAY_LENGTH(NOFRAMES_ARR_DATA) };
89 :
90 4 : nsHtml5Tokenizer::nsHtml5Tokenizer(nsHtml5TreeBuilder* tokenHandler,
91 4 : bool viewingXmlSource)
92 : : tokenHandler(tokenHandler)
93 : , encodingDeclarationHandler(nullptr)
94 8 : , charRefBuf(jArray<char16_t, int32_t>::newJArray(32))
95 8 : , bmpChar(jArray<char16_t, int32_t>::newJArray(1))
96 8 : , astralChar(jArray<char16_t, int32_t>::newJArray(2))
97 : , containsHyphen(false)
98 : , tagName(nullptr)
99 4 : , nonInternedTagName(new nsHtml5ElementName())
100 : , attributeName(nullptr)
101 4 : , nonInternedAttributeName(new nsHtml5AttributeName())
102 : , doctypeName(nullptr)
103 : , publicIdentifier(nullptr)
104 : , systemIdentifier(nullptr)
105 4 : , attributes(tokenHandler->HasBuilder() ? new nsHtml5HtmlAttributes(0)
106 : : nullptr)
107 4 : , newAttributesEachTime(!tokenHandler->HasBuilder())
108 36 : , viewingXmlSource(viewingXmlSource)
109 : {
110 4 : MOZ_COUNT_CTOR(nsHtml5Tokenizer);
111 4 : }
112 :
113 : void
114 4 : nsHtml5Tokenizer::setInterner(nsHtml5AtomTable* interner)
115 : {
116 4 : this->interner = interner;
117 4 : }
118 :
119 : void
120 0 : nsHtml5Tokenizer::initLocation(nsHtml5String newPublicId,
121 : nsHtml5String newSystemId)
122 : {
123 0 : this->systemId = newSystemId;
124 0 : this->publicId = newPublicId;
125 0 : }
126 :
127 : bool
128 27 : nsHtml5Tokenizer::isViewingXmlSource()
129 : {
130 27 : return viewingXmlSource;
131 : }
132 :
133 : void
134 0 : nsHtml5Tokenizer::setStateAndEndTagExpectation(int32_t specialTokenizerState, nsIAtom* endTagExpectation)
135 : {
136 0 : this->stateSave = specialTokenizerState;
137 0 : if (specialTokenizerState == nsHtml5Tokenizer::DATA) {
138 0 : return;
139 : }
140 0 : autoJArray<char16_t,int32_t> asArray = nsHtml5Portability::newCharArrayFromLocal(endTagExpectation);
141 0 : this->endTagExpectation = nsHtml5ElementName::elementNameByBuffer(asArray, 0, asArray.length, interner);
142 0 : MOZ_ASSERT(!!this->endTagExpectation);
143 0 : endTagExpectationToArray();
144 : }
145 :
146 : void
147 6 : nsHtml5Tokenizer::setStateAndEndTagExpectation(int32_t specialTokenizerState, nsHtml5ElementName* endTagExpectation)
148 : {
149 6 : this->stateSave = specialTokenizerState;
150 6 : this->endTagExpectation = endTagExpectation;
151 6 : endTagExpectationToArray();
152 6 : }
153 :
154 : void
155 6 : nsHtml5Tokenizer::endTagExpectationToArray()
156 : {
157 6 : switch(endTagExpectation->getGroup()) {
158 : case nsHtml5TreeBuilder::TITLE: {
159 1 : endTagExpectationAsArray = TITLE_ARR;
160 1 : return;
161 : }
162 : case nsHtml5TreeBuilder::SCRIPT: {
163 5 : endTagExpectationAsArray = SCRIPT_ARR;
164 5 : return;
165 : }
166 : case nsHtml5TreeBuilder::STYLE: {
167 0 : endTagExpectationAsArray = STYLE_ARR;
168 0 : return;
169 : }
170 : case nsHtml5TreeBuilder::PLAINTEXT: {
171 0 : endTagExpectationAsArray = PLAINTEXT_ARR;
172 0 : return;
173 : }
174 : case nsHtml5TreeBuilder::XMP: {
175 0 : endTagExpectationAsArray = XMP_ARR;
176 0 : return;
177 : }
178 : case nsHtml5TreeBuilder::TEXTAREA: {
179 0 : endTagExpectationAsArray = TEXTAREA_ARR;
180 0 : return;
181 : }
182 : case nsHtml5TreeBuilder::IFRAME: {
183 0 : endTagExpectationAsArray = IFRAME_ARR;
184 0 : return;
185 : }
186 : case nsHtml5TreeBuilder::NOEMBED: {
187 0 : endTagExpectationAsArray = NOEMBED_ARR;
188 0 : return;
189 : }
190 : case nsHtml5TreeBuilder::NOSCRIPT: {
191 0 : endTagExpectationAsArray = NOSCRIPT_ARR;
192 0 : return;
193 : }
194 : case nsHtml5TreeBuilder::NOFRAMES: {
195 0 : endTagExpectationAsArray = NOFRAMES_ARR;
196 0 : return;
197 : }
198 : default: {
199 0 : MOZ_ASSERT(false, "Bad end tag expectation.");
200 : return;
201 : }
202 : }
203 : }
204 :
205 : void
206 5 : nsHtml5Tokenizer::setLineNumber(int32_t line)
207 : {
208 5 : this->attributeLine = line;
209 5 : this->line = line;
210 5 : }
211 :
212 : nsHtml5HtmlAttributes*
213 4 : nsHtml5Tokenizer::emptyAttributes()
214 : {
215 4 : return nsHtml5HtmlAttributes::EMPTY_ATTRIBUTES;
216 : }
217 :
218 : void
219 0 : nsHtml5Tokenizer::emitOrAppendCharRefBuf(int32_t returnState)
220 : {
221 0 : if ((returnState & DATA_AND_RCDATA_MASK)) {
222 0 : appendCharRefBufToStrBuf();
223 : } else {
224 0 : if (charRefBufLen > 0) {
225 0 : tokenHandler->characters(charRefBuf, 0, charRefBufLen);
226 0 : charRefBufLen = 0;
227 : }
228 : }
229 0 : }
230 :
231 : nsHtml5String
232 17 : nsHtml5Tokenizer::strBufToString()
233 : {
234 : nsHtml5String str =
235 17 : nsHtml5Portability::newStringFromBuffer(strBuf, 0, strBufLen, tokenHandler);
236 17 : clearStrBufAfterUse();
237 17 : return str;
238 : }
239 :
240 : void
241 1 : nsHtml5Tokenizer::strBufToDoctypeName()
242 : {
243 1 : doctypeName = nsHtml5Portability::newLocalNameFromBuffer(strBuf, 0, strBufLen, interner);
244 1 : clearStrBufAfterUse();
245 1 : }
246 :
247 : void
248 0 : nsHtml5Tokenizer::emitStrBuf()
249 : {
250 0 : if (strBufLen > 0) {
251 0 : tokenHandler->characters(strBuf, 0, strBufLen);
252 0 : clearStrBufAfterUse();
253 : }
254 0 : }
255 :
256 : void
257 0 : nsHtml5Tokenizer::appendStrBuf(char16_t* buffer, int32_t offset, int32_t length)
258 : {
259 0 : int32_t newLen = strBufLen + length;
260 0 : MOZ_ASSERT(newLen <= strBuf.length, "Previous buffer length insufficient.");
261 0 : if (MOZ_UNLIKELY(strBuf.length < newLen)) {
262 0 : if (MOZ_UNLIKELY(!EnsureBufferSpace(length))) {
263 0 : MOZ_CRASH("Unable to recover from buffer reallocation failure");
264 : }
265 : }
266 0 : nsHtml5ArrayCopy::arraycopy(buffer, offset, strBuf, strBufLen, length);
267 0 : strBufLen = newLen;
268 0 : }
269 :
270 : void
271 5 : nsHtml5Tokenizer::emitComment(int32_t provisionalHyphens, int32_t pos)
272 : {
273 5 : tokenHandler->comment(strBuf, 0, strBufLen - provisionalHyphens);
274 5 : clearStrBufAfterUse();
275 5 : cstart = pos + 1;
276 5 : }
277 :
278 : void
279 42 : nsHtml5Tokenizer::flushChars(char16_t* buf, int32_t pos)
280 : {
281 42 : if (pos > cstart) {
282 20 : tokenHandler->characters(buf, cstart, pos - cstart);
283 : }
284 42 : cstart = INT32_MAX;
285 42 : }
286 :
287 : void
288 18 : nsHtml5Tokenizer::strBufToElementNameString()
289 : {
290 18 : if (containsHyphen) {
291 0 : nsIAtom* annotationName = nsHtml5ElementName::ELT_ANNOTATION_XML->getName();
292 0 : if (nsHtml5Portability::localEqualsBuffer(
293 : annotationName, strBuf, 0, strBufLen)) {
294 0 : tagName = nsHtml5ElementName::ELT_ANNOTATION_XML;
295 : } else {
296 0 : nonInternedTagName->setNameForNonInterned(
297 : nsHtml5Portability::newLocalNameFromBuffer(
298 0 : strBuf, 0, strBufLen, interner));
299 0 : tagName = nonInternedTagName;
300 : }
301 : } else {
302 18 : tagName =
303 18 : nsHtml5ElementName::elementNameByBuffer(strBuf, 0, strBufLen, interner);
304 18 : if (!tagName) {
305 0 : nonInternedTagName->setNameForNonInterned(
306 : nsHtml5Portability::newLocalNameFromBuffer(
307 0 : strBuf, 0, strBufLen, interner));
308 0 : tagName = nonInternedTagName;
309 : }
310 : }
311 18 : containsHyphen = false;
312 18 : clearStrBufAfterUse();
313 18 : }
314 :
315 : int32_t
316 24 : nsHtml5Tokenizer::emitCurrentTagToken(bool selfClosing, int32_t pos)
317 : {
318 24 : cstart = pos + 1;
319 24 : maybeErrSlashInEndTag(selfClosing);
320 24 : stateSave = nsHtml5Tokenizer::DATA;
321 24 : nsHtml5HtmlAttributes* attrs = (!attributes ? nsHtml5HtmlAttributes::EMPTY_ATTRIBUTES : attributes);
322 24 : if (endTag) {
323 11 : maybeErrAttributesOnEndTag(attrs);
324 11 : if (!viewingXmlSource) {
325 11 : tokenHandler->endTag(tagName);
326 : }
327 11 : if (newAttributesEachTime) {
328 11 : delete attributes;
329 11 : attributes = nullptr;
330 : }
331 : } else {
332 13 : if (viewingXmlSource) {
333 0 : MOZ_ASSERT(newAttributesEachTime);
334 0 : delete attributes;
335 0 : attributes = nullptr;
336 : } else {
337 13 : tokenHandler->startTag(tagName, attrs, selfClosing);
338 : }
339 : }
340 24 : tagName = nullptr;
341 24 : if (newAttributesEachTime) {
342 24 : attributes = nullptr;
343 : } else {
344 0 : attributes->clear(0);
345 : }
346 24 : return stateSave;
347 : }
348 :
349 : void
350 16 : nsHtml5Tokenizer::attributeNameComplete()
351 : {
352 16 : attributeName = nsHtml5AttributeName::nameByBuffer(strBuf, 0, strBufLen, interner);
353 16 : if (!attributeName) {
354 0 : nonInternedAttributeName->setNameForNonInterned(
355 : nsHtml5Portability::newLocalNameFromBuffer(
356 0 : strBuf, 0, strBufLen, interner));
357 0 : attributeName = nonInternedAttributeName;
358 : }
359 16 : clearStrBufAfterUse();
360 16 : if (!attributes) {
361 7 : attributes = new nsHtml5HtmlAttributes(0);
362 : }
363 16 : if (attributes->contains(attributeName)) {
364 0 : errDuplicateAttribute();
365 0 : attributeName = nullptr;
366 : }
367 16 : }
368 :
369 : void
370 0 : nsHtml5Tokenizer::addAttributeWithoutValue()
371 : {
372 :
373 0 : if (attributeName) {
374 0 : attributes->addAttribute(attributeName, nsHtml5Portability::newEmptyString(), attributeLine);
375 0 : attributeName = nullptr;
376 : } else {
377 0 : clearStrBufAfterUse();
378 : }
379 0 : }
380 :
381 : void
382 16 : nsHtml5Tokenizer::addAttributeWithValue()
383 : {
384 16 : if (attributeName) {
385 16 : nsHtml5String val = strBufToString();
386 16 : if (mViewSource) {
387 0 : mViewSource->MaybeLinkifyAttributeValue(attributeName, val);
388 : }
389 16 : attributes->addAttribute(attributeName, val, attributeLine);
390 16 : attributeName = nullptr;
391 : } else {
392 0 : clearStrBufAfterUse();
393 : }
394 16 : }
395 :
396 : void
397 4 : nsHtml5Tokenizer::start()
398 : {
399 4 : initializeWithoutStarting();
400 4 : tokenHandler->startTokenization(this);
401 4 : }
402 :
403 : bool
404 9 : nsHtml5Tokenizer::tokenizeBuffer(nsHtml5UTF16Buffer* buffer)
405 : {
406 9 : int32_t state = stateSave;
407 9 : int32_t returnState = returnStateSave;
408 9 : char16_t c = '\0';
409 9 : shouldSuspend = false;
410 9 : lastCR = false;
411 9 : int32_t start = buffer->getStart();
412 9 : int32_t end = buffer->getEnd();
413 9 : int32_t pos = start - 1;
414 9 : switch(state) {
415 : case DATA:
416 : case RCDATA:
417 : case SCRIPT_DATA:
418 : case PLAINTEXT:
419 : case RAWTEXT:
420 : case CDATA_SECTION:
421 : case SCRIPT_DATA_ESCAPED:
422 : case SCRIPT_DATA_ESCAPE_START:
423 : case SCRIPT_DATA_ESCAPE_START_DASH:
424 : case SCRIPT_DATA_ESCAPED_DASH:
425 : case SCRIPT_DATA_ESCAPED_DASH_DASH:
426 : case SCRIPT_DATA_DOUBLE_ESCAPE_START:
427 : case SCRIPT_DATA_DOUBLE_ESCAPED:
428 : case SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN:
429 : case SCRIPT_DATA_DOUBLE_ESCAPED_DASH:
430 : case SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH:
431 : case SCRIPT_DATA_DOUBLE_ESCAPE_END: {
432 9 : cstart = start;
433 9 : break;
434 : }
435 : default: {
436 0 : cstart = INT32_MAX;
437 0 : break;
438 : }
439 : }
440 9 : if (mViewSource) {
441 0 : mViewSource->SetBuffer(buffer);
442 0 : pos = stateLoop<nsHtml5ViewSourcePolicy>(state, c, pos, buffer->getBuffer(), false, returnState, buffer->getEnd());
443 0 : mViewSource->DropBuffer((pos == buffer->getEnd()) ? pos : pos + 1);
444 : } else {
445 9 : pos = stateLoop<nsHtml5SilentPolicy>(state, c, pos, buffer->getBuffer(), false, returnState, buffer->getEnd());
446 : }
447 9 : if (pos == end) {
448 4 : buffer->setStart(pos);
449 : } else {
450 5 : buffer->setStart(pos + 1);
451 : }
452 9 : return lastCR;
453 : }
454 :
455 : template<class P>
456 : int32_t
457 75 : nsHtml5Tokenizer::stateLoop(int32_t state, char16_t c, int32_t pos, char16_t* buf, bool reconsume, int32_t returnState, int32_t endPos)
458 : {
459 0 : stateloop: for (; ; ) {
460 75 : switch(state) {
461 : case DATA: {
462 : for (; ; ) {
463 56 : if (reconsume) {
464 0 : reconsume = false;
465 : } else {
466 41 : if (++pos == endPos) {
467 2 : NS_HTML5_BREAK(stateloop);
468 : }
469 39 : c = checkChar(buf, pos);
470 : }
471 39 : switch(c) {
472 : case '&': {
473 0 : flushChars(buf, pos);
474 0 : MOZ_ASSERT(!charRefBufLen, "charRefBufLen not reset after previous use!");
475 0 : appendCharRefBuf(c);
476 0 : setAdditionalAndRememberAmpersandLocation('\0');
477 0 : returnState = state;
478 0 : state =
479 0 : P::transition(mViewSource,
480 : nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE,
481 : reconsume,
482 : pos);
483 0 : NS_HTML5_CONTINUE(stateloop);
484 : }
485 : case '<': {
486 24 : flushChars(buf, pos);
487 24 : state = P::transition(
488 : mViewSource, nsHtml5Tokenizer::TAG_OPEN, reconsume, pos);
489 24 : NS_HTML5_BREAK(dataloop);
490 : }
491 : case '\0': {
492 0 : emitReplacementCharacter(buf, pos);
493 0 : continue;
494 : }
495 : case '\r': {
496 0 : emitCarriageReturn(buf, pos);
497 0 : NS_HTML5_BREAK(stateloop);
498 : }
499 : case '\n': {
500 15 : silentLineFeed();
501 : }
502 : default: {
503 15 : continue;
504 : }
505 : }
506 : }
507 : dataloop_end: ;
508 : }
509 : case TAG_OPEN: {
510 : for (; ; ) {
511 24 : if (++pos == endPos) {
512 0 : NS_HTML5_BREAK(stateloop);
513 : }
514 24 : c = checkChar(buf, pos);
515 24 : if (c >= 'A' && c <= 'Z') {
516 0 : endTag = false;
517 0 : clearStrBufBeforeUse();
518 0 : appendStrBuf((char16_t) (c + 0x20));
519 0 : containsHyphen = false;
520 0 : state = P::transition(
521 : mViewSource, nsHtml5Tokenizer::TAG_NAME, reconsume, pos);
522 0 : NS_HTML5_BREAK(tagopenloop);
523 24 : } else if (c >= 'a' && c <= 'z') {
524 13 : endTag = false;
525 13 : clearStrBufBeforeUse();
526 13 : appendStrBuf(c);
527 13 : containsHyphen = false;
528 13 : state = P::transition(
529 : mViewSource, nsHtml5Tokenizer::TAG_NAME, reconsume, pos);
530 13 : NS_HTML5_BREAK(tagopenloop);
531 : }
532 11 : switch(c) {
533 : case '!': {
534 6 : state = P::transition(mViewSource,
535 : nsHtml5Tokenizer::MARKUP_DECLARATION_OPEN,
536 : reconsume,
537 : pos);
538 6 : NS_HTML5_CONTINUE(stateloop);
539 : }
540 : case '/': {
541 5 : state = P::transition(
542 : mViewSource, nsHtml5Tokenizer::CLOSE_TAG_OPEN, reconsume, pos);
543 5 : NS_HTML5_CONTINUE(stateloop);
544 : }
545 : case '\?': {
546 0 : if (viewingXmlSource) {
547 0 : state = P::transition(mViewSource,
548 : nsHtml5Tokenizer::PROCESSING_INSTRUCTION,
549 : reconsume,
550 : pos);
551 0 : NS_HTML5_CONTINUE(stateloop);
552 : }
553 : if (P::reportErrors) {
554 0 : errProcessingInstruction();
555 : }
556 0 : clearStrBufBeforeUse();
557 0 : appendStrBuf(c);
558 0 : state = P::transition(
559 : mViewSource, nsHtml5Tokenizer::BOGUS_COMMENT, reconsume, pos);
560 0 : NS_HTML5_CONTINUE(stateloop);
561 : }
562 : case '>': {
563 : if (P::reportErrors) {
564 0 : errLtGt();
565 : }
566 0 : tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 2);
567 0 : cstart = pos + 1;
568 0 : state = P::transition(
569 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
570 0 : NS_HTML5_CONTINUE(stateloop);
571 : }
572 : default: {
573 : if (P::reportErrors) {
574 0 : errBadCharAfterLt(c);
575 : }
576 0 : tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
577 0 : cstart = pos;
578 0 : reconsume = true;
579 0 : state = P::transition(
580 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
581 0 : NS_HTML5_CONTINUE(stateloop);
582 : }
583 : }
584 : }
585 : tagopenloop_end: ;
586 : }
587 : case TAG_NAME: {
588 : for (; ; ) {
589 148 : if (++pos == endPos) {
590 0 : NS_HTML5_BREAK(stateloop);
591 : }
592 83 : c = checkChar(buf, pos);
593 83 : switch(c) {
594 : case '\r': {
595 0 : silentCarriageReturn();
596 0 : strBufToElementNameString();
597 0 : state = P::transition(mViewSource,
598 : nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
599 : reconsume,
600 : pos);
601 0 : NS_HTML5_BREAK(stateloop);
602 : }
603 : case '\n': {
604 0 : silentLineFeed();
605 : }
606 : case ' ':
607 : case '\t':
608 : case '\f': {
609 7 : strBufToElementNameString();
610 7 : state = P::transition(mViewSource,
611 : nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
612 : reconsume,
613 : pos);
614 7 : NS_HTML5_BREAK(tagnameloop);
615 : }
616 : case '/': {
617 0 : strBufToElementNameString();
618 0 : state = P::transition(mViewSource,
619 : nsHtml5Tokenizer::SELF_CLOSING_START_TAG,
620 : reconsume,
621 : pos);
622 0 : NS_HTML5_CONTINUE(stateloop);
623 : }
624 : case '>': {
625 11 : strBufToElementNameString();
626 11 : state = P::transition(mViewSource, emitCurrentTagToken(false, pos), reconsume, pos);
627 11 : if (shouldSuspend) {
628 0 : NS_HTML5_BREAK(stateloop);
629 : }
630 11 : NS_HTML5_CONTINUE(stateloop);
631 : }
632 : case '\0': {
633 0 : c = 0xfffd;
634 : }
635 : default: {
636 65 : if (c >= 'A' && c <= 'Z') {
637 0 : c += 0x20;
638 65 : } else if (c == '-') {
639 0 : containsHyphen = true;
640 : }
641 65 : appendStrBuf(c);
642 65 : continue;
643 : }
644 : }
645 : }
646 : tagnameloop_end: ;
647 : }
648 : case BEFORE_ATTRIBUTE_NAME: {
649 : for (; ; ) {
650 16 : if (reconsume) {
651 0 : reconsume = false;
652 : } else {
653 16 : if (++pos == endPos) {
654 0 : NS_HTML5_BREAK(stateloop);
655 : }
656 16 : c = checkChar(buf, pos);
657 : }
658 16 : switch(c) {
659 : case '\r': {
660 0 : silentCarriageReturn();
661 0 : NS_HTML5_BREAK(stateloop);
662 : }
663 : case '\n': {
664 0 : silentLineFeed();
665 : }
666 : case ' ':
667 : case '\t':
668 : case '\f': {
669 0 : continue;
670 : }
671 : case '/': {
672 0 : state = P::transition(mViewSource,
673 : nsHtml5Tokenizer::SELF_CLOSING_START_TAG,
674 : reconsume,
675 : pos);
676 0 : NS_HTML5_CONTINUE(stateloop);
677 : }
678 : case '>': {
679 0 : state = P::transition(mViewSource, emitCurrentTagToken(false, pos), reconsume, pos);
680 0 : if (shouldSuspend) {
681 0 : NS_HTML5_BREAK(stateloop);
682 : }
683 0 : NS_HTML5_CONTINUE(stateloop);
684 : }
685 : case '\0': {
686 0 : c = 0xfffd;
687 : }
688 : case '\"':
689 : case '\'':
690 : case '<':
691 : case '=': {
692 : if (P::reportErrors) {
693 0 : errBadCharBeforeAttributeNameOrNull(c);
694 : }
695 : }
696 : default: {
697 16 : if (c >= 'A' && c <= 'Z') {
698 0 : c += 0x20;
699 : }
700 16 : attributeLine = line;
701 16 : clearStrBufBeforeUse();
702 16 : appendStrBuf(c);
703 16 : state = P::transition(
704 : mViewSource, nsHtml5Tokenizer::ATTRIBUTE_NAME, reconsume, pos);
705 16 : NS_HTML5_BREAK(beforeattributenameloop);
706 : }
707 : }
708 : }
709 : beforeattributenameloop_end: ;
710 : }
711 : case ATTRIBUTE_NAME: {
712 : for (; ; ) {
713 156 : if (++pos == endPos) {
714 0 : NS_HTML5_BREAK(stateloop);
715 : }
716 86 : c = checkChar(buf, pos);
717 86 : switch(c) {
718 : case '\r': {
719 0 : silentCarriageReturn();
720 0 : attributeNameComplete();
721 0 : state = P::transition(mViewSource,
722 : nsHtml5Tokenizer::AFTER_ATTRIBUTE_NAME,
723 : reconsume,
724 : pos);
725 0 : NS_HTML5_BREAK(stateloop);
726 : }
727 : case '\n': {
728 0 : silentLineFeed();
729 : }
730 : case ' ':
731 : case '\t':
732 : case '\f': {
733 0 : attributeNameComplete();
734 0 : state = P::transition(mViewSource,
735 : nsHtml5Tokenizer::AFTER_ATTRIBUTE_NAME,
736 : reconsume,
737 : pos);
738 0 : NS_HTML5_CONTINUE(stateloop);
739 : }
740 : case '/': {
741 0 : attributeNameComplete();
742 0 : addAttributeWithoutValue();
743 0 : state = P::transition(mViewSource,
744 : nsHtml5Tokenizer::SELF_CLOSING_START_TAG,
745 : reconsume,
746 : pos);
747 0 : NS_HTML5_CONTINUE(stateloop);
748 : }
749 : case '=': {
750 16 : attributeNameComplete();
751 16 : state = P::transition(mViewSource,
752 : nsHtml5Tokenizer::BEFORE_ATTRIBUTE_VALUE,
753 : reconsume,
754 : pos);
755 16 : NS_HTML5_BREAK(attributenameloop);
756 : }
757 : case '>': {
758 0 : attributeNameComplete();
759 0 : addAttributeWithoutValue();
760 0 : state = P::transition(mViewSource, emitCurrentTagToken(false, pos), reconsume, pos);
761 0 : if (shouldSuspend) {
762 0 : NS_HTML5_BREAK(stateloop);
763 : }
764 0 : NS_HTML5_CONTINUE(stateloop);
765 : }
766 : case '\0': {
767 0 : c = 0xfffd;
768 : }
769 : case '\"':
770 : case '\'':
771 : case '<': {
772 : if (P::reportErrors) {
773 0 : errQuoteOrLtInAttributeNameOrNull(c);
774 : }
775 : }
776 : default: {
777 70 : if (c >= 'A' && c <= 'Z') {
778 0 : c += 0x20;
779 : }
780 70 : appendStrBuf(c);
781 70 : continue;
782 : }
783 : }
784 : }
785 : attributenameloop_end: ;
786 : }
787 : case BEFORE_ATTRIBUTE_VALUE: {
788 : for (; ; ) {
789 16 : if (++pos == endPos) {
790 0 : NS_HTML5_BREAK(stateloop);
791 : }
792 16 : c = checkChar(buf, pos);
793 16 : switch(c) {
794 : case '\r': {
795 0 : silentCarriageReturn();
796 0 : NS_HTML5_BREAK(stateloop);
797 : }
798 : case '\n': {
799 0 : silentLineFeed();
800 : }
801 : case ' ':
802 : case '\t':
803 : case '\f': {
804 0 : continue;
805 : }
806 : case '\"': {
807 16 : attributeLine = line;
808 16 : clearStrBufBeforeUse();
809 16 : state =
810 16 : P::transition(mViewSource,
811 : nsHtml5Tokenizer::ATTRIBUTE_VALUE_DOUBLE_QUOTED,
812 : reconsume,
813 : pos);
814 16 : NS_HTML5_BREAK(beforeattributevalueloop);
815 : }
816 : case '&': {
817 0 : attributeLine = line;
818 0 : clearStrBufBeforeUse();
819 0 : reconsume = true;
820 0 : state = P::transition(mViewSource,
821 : nsHtml5Tokenizer::ATTRIBUTE_VALUE_UNQUOTED,
822 : reconsume,
823 : pos);
824 :
825 0 : NS_HTML5_CONTINUE(stateloop);
826 : }
827 : case '\'': {
828 0 : attributeLine = line;
829 0 : clearStrBufBeforeUse();
830 0 : state =
831 0 : P::transition(mViewSource,
832 : nsHtml5Tokenizer::ATTRIBUTE_VALUE_SINGLE_QUOTED,
833 : reconsume,
834 : pos);
835 0 : NS_HTML5_CONTINUE(stateloop);
836 : }
837 : case '>': {
838 : if (P::reportErrors) {
839 0 : errAttributeValueMissing();
840 : }
841 0 : addAttributeWithoutValue();
842 0 : state = P::transition(mViewSource, emitCurrentTagToken(false, pos), reconsume, pos);
843 0 : if (shouldSuspend) {
844 0 : NS_HTML5_BREAK(stateloop);
845 : }
846 0 : NS_HTML5_CONTINUE(stateloop);
847 : }
848 : case '\0': {
849 0 : c = 0xfffd;
850 : }
851 : case '<':
852 : case '=':
853 : case '`': {
854 : if (P::reportErrors) {
855 0 : errLtOrEqualsOrGraveInUnquotedAttributeOrNull(c);
856 : }
857 : }
858 : default: {
859 0 : attributeLine = line;
860 0 : clearStrBufBeforeUse();
861 0 : appendStrBuf(c);
862 0 : state = P::transition(mViewSource,
863 : nsHtml5Tokenizer::ATTRIBUTE_VALUE_UNQUOTED,
864 : reconsume,
865 : pos);
866 :
867 0 : NS_HTML5_CONTINUE(stateloop);
868 : }
869 : }
870 : }
871 : beforeattributevalueloop_end: ;
872 : }
873 : case ATTRIBUTE_VALUE_DOUBLE_QUOTED: {
874 : for (; ; ) {
875 620 : if (reconsume) {
876 0 : reconsume = false;
877 : } else {
878 318 : if (++pos == endPos) {
879 0 : NS_HTML5_BREAK(stateloop);
880 : }
881 318 : c = checkChar(buf, pos);
882 : }
883 318 : switch(c) {
884 : case '\"': {
885 16 : addAttributeWithValue();
886 16 : state =
887 16 : P::transition(mViewSource,
888 : nsHtml5Tokenizer::AFTER_ATTRIBUTE_VALUE_QUOTED,
889 : reconsume,
890 : pos);
891 16 : NS_HTML5_BREAK(attributevaluedoublequotedloop);
892 : }
893 : case '&': {
894 0 : MOZ_ASSERT(!charRefBufLen, "charRefBufLen not reset after previous use!");
895 0 : appendCharRefBuf(c);
896 0 : setAdditionalAndRememberAmpersandLocation('\"');
897 0 : returnState = state;
898 0 : state =
899 0 : P::transition(mViewSource,
900 : nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE,
901 : reconsume,
902 : pos);
903 0 : NS_HTML5_CONTINUE(stateloop);
904 : }
905 : case '\r': {
906 0 : appendStrBufCarriageReturn();
907 0 : NS_HTML5_BREAK(stateloop);
908 : }
909 : case '\n': {
910 0 : appendStrBufLineFeed();
911 0 : continue;
912 : }
913 : case '\0': {
914 0 : c = 0xfffd;
915 : }
916 : default: {
917 302 : appendStrBuf(c);
918 302 : continue;
919 : }
920 : }
921 : }
922 : attributevaluedoublequotedloop_end: ;
923 : }
924 : case AFTER_ATTRIBUTE_VALUE_QUOTED: {
925 : for (; ; ) {
926 16 : if (++pos == endPos) {
927 0 : NS_HTML5_BREAK(stateloop);
928 : }
929 16 : c = checkChar(buf, pos);
930 16 : switch(c) {
931 : case '\r': {
932 0 : silentCarriageReturn();
933 0 : state = P::transition(mViewSource,
934 : nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
935 : reconsume,
936 : pos);
937 0 : NS_HTML5_BREAK(stateloop);
938 : }
939 : case '\n': {
940 0 : silentLineFeed();
941 : }
942 : case ' ':
943 : case '\t':
944 : case '\f': {
945 9 : state = P::transition(mViewSource,
946 : nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
947 : reconsume,
948 : pos);
949 9 : NS_HTML5_CONTINUE(stateloop);
950 : }
951 : case '/': {
952 0 : state = P::transition(mViewSource,
953 : nsHtml5Tokenizer::SELF_CLOSING_START_TAG,
954 : reconsume,
955 : pos);
956 0 : NS_HTML5_BREAK(afterattributevaluequotedloop);
957 : }
958 : case '>': {
959 7 : state = P::transition(mViewSource, emitCurrentTagToken(false, pos), reconsume, pos);
960 7 : if (shouldSuspend) {
961 0 : NS_HTML5_BREAK(stateloop);
962 : }
963 7 : NS_HTML5_CONTINUE(stateloop);
964 : }
965 : default: {
966 : if (P::reportErrors) {
967 0 : errNoSpaceBetweenAttributes();
968 : }
969 0 : reconsume = true;
970 0 : state = P::transition(mViewSource,
971 : nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
972 : reconsume,
973 : pos);
974 0 : NS_HTML5_CONTINUE(stateloop);
975 : }
976 : }
977 : }
978 : afterattributevaluequotedloop_end: ;
979 : }
980 : case SELF_CLOSING_START_TAG: {
981 0 : if (++pos == endPos) {
982 0 : NS_HTML5_BREAK(stateloop);
983 : }
984 0 : c = checkChar(buf, pos);
985 0 : switch(c) {
986 : case '>': {
987 0 : state = P::transition(mViewSource, emitCurrentTagToken(true, pos), reconsume, pos);
988 0 : if (shouldSuspend) {
989 0 : NS_HTML5_BREAK(stateloop);
990 : }
991 0 : NS_HTML5_CONTINUE(stateloop);
992 : }
993 : default: {
994 : if (P::reportErrors) {
995 0 : errSlashNotFollowedByGt();
996 : }
997 0 : reconsume = true;
998 0 : state = P::transition(mViewSource,
999 : nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
1000 : reconsume,
1001 : pos);
1002 0 : NS_HTML5_CONTINUE(stateloop);
1003 : }
1004 : }
1005 : }
1006 : case ATTRIBUTE_VALUE_UNQUOTED: {
1007 : for (; ; ) {
1008 0 : if (reconsume) {
1009 0 : reconsume = false;
1010 : } else {
1011 0 : if (++pos == endPos) {
1012 0 : NS_HTML5_BREAK(stateloop);
1013 : }
1014 0 : c = checkChar(buf, pos);
1015 : }
1016 0 : switch(c) {
1017 : case '\r': {
1018 0 : silentCarriageReturn();
1019 0 : addAttributeWithValue();
1020 0 : state = P::transition(mViewSource,
1021 : nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
1022 : reconsume,
1023 : pos);
1024 0 : NS_HTML5_BREAK(stateloop);
1025 : }
1026 : case '\n': {
1027 0 : silentLineFeed();
1028 : }
1029 : case ' ':
1030 : case '\t':
1031 : case '\f': {
1032 0 : addAttributeWithValue();
1033 0 : state = P::transition(mViewSource,
1034 : nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
1035 : reconsume,
1036 : pos);
1037 0 : NS_HTML5_CONTINUE(stateloop);
1038 : }
1039 : case '&': {
1040 0 : MOZ_ASSERT(!charRefBufLen, "charRefBufLen not reset after previous use!");
1041 0 : appendCharRefBuf(c);
1042 0 : setAdditionalAndRememberAmpersandLocation('>');
1043 0 : returnState = state;
1044 0 : state =
1045 0 : P::transition(mViewSource,
1046 : nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE,
1047 : reconsume,
1048 : pos);
1049 0 : NS_HTML5_CONTINUE(stateloop);
1050 : }
1051 : case '>': {
1052 0 : addAttributeWithValue();
1053 0 : state = P::transition(mViewSource, emitCurrentTagToken(false, pos), reconsume, pos);
1054 0 : if (shouldSuspend) {
1055 0 : NS_HTML5_BREAK(stateloop);
1056 : }
1057 0 : NS_HTML5_CONTINUE(stateloop);
1058 : }
1059 : case '\0': {
1060 0 : c = 0xfffd;
1061 : }
1062 : case '<':
1063 : case '\"':
1064 : case '\'':
1065 : case '=':
1066 : case '`': {
1067 : if (P::reportErrors) {
1068 0 : errUnquotedAttributeValOrNull(c);
1069 : }
1070 : }
1071 : default: {
1072 :
1073 0 : appendStrBuf(c);
1074 0 : continue;
1075 : }
1076 : }
1077 : }
1078 : }
1079 : case AFTER_ATTRIBUTE_NAME: {
1080 : for (; ; ) {
1081 0 : if (++pos == endPos) {
1082 0 : NS_HTML5_BREAK(stateloop);
1083 : }
1084 0 : c = checkChar(buf, pos);
1085 0 : switch(c) {
1086 : case '\r': {
1087 0 : silentCarriageReturn();
1088 0 : NS_HTML5_BREAK(stateloop);
1089 : }
1090 : case '\n': {
1091 0 : silentLineFeed();
1092 : }
1093 : case ' ':
1094 : case '\t':
1095 : case '\f': {
1096 0 : continue;
1097 : }
1098 : case '/': {
1099 0 : addAttributeWithoutValue();
1100 0 : state = P::transition(mViewSource,
1101 : nsHtml5Tokenizer::SELF_CLOSING_START_TAG,
1102 : reconsume,
1103 : pos);
1104 0 : NS_HTML5_CONTINUE(stateloop);
1105 : }
1106 : case '=': {
1107 0 : state = P::transition(mViewSource,
1108 : nsHtml5Tokenizer::BEFORE_ATTRIBUTE_VALUE,
1109 : reconsume,
1110 : pos);
1111 0 : NS_HTML5_CONTINUE(stateloop);
1112 : }
1113 : case '>': {
1114 0 : addAttributeWithoutValue();
1115 0 : state = P::transition(mViewSource, emitCurrentTagToken(false, pos), reconsume, pos);
1116 0 : if (shouldSuspend) {
1117 0 : NS_HTML5_BREAK(stateloop);
1118 : }
1119 0 : NS_HTML5_CONTINUE(stateloop);
1120 : }
1121 : case '\0': {
1122 0 : c = 0xfffd;
1123 : }
1124 : case '\"':
1125 : case '\'':
1126 : case '<': {
1127 : if (P::reportErrors) {
1128 0 : errQuoteOrLtInAttributeNameOrNull(c);
1129 : }
1130 : }
1131 : default: {
1132 0 : addAttributeWithoutValue();
1133 0 : if (c >= 'A' && c <= 'Z') {
1134 0 : c += 0x20;
1135 : }
1136 0 : clearStrBufBeforeUse();
1137 0 : appendStrBuf(c);
1138 0 : state = P::transition(
1139 : mViewSource, nsHtml5Tokenizer::ATTRIBUTE_NAME, reconsume, pos);
1140 0 : NS_HTML5_CONTINUE(stateloop);
1141 : }
1142 : }
1143 : }
1144 : }
1145 : case MARKUP_DECLARATION_OPEN: {
1146 : for (; ; ) {
1147 6 : if (++pos == endPos) {
1148 0 : NS_HTML5_BREAK(stateloop);
1149 : }
1150 6 : c = checkChar(buf, pos);
1151 6 : switch(c) {
1152 : case '-': {
1153 5 : clearStrBufBeforeUse();
1154 5 : appendStrBuf(c);
1155 5 : state = P::transition(mViewSource,
1156 : nsHtml5Tokenizer::MARKUP_DECLARATION_HYPHEN,
1157 : reconsume,
1158 : pos);
1159 5 : NS_HTML5_BREAK(markupdeclarationopenloop);
1160 : }
1161 : case 'd':
1162 : case 'D': {
1163 1 : clearStrBufBeforeUse();
1164 1 : appendStrBuf(c);
1165 1 : index = 0;
1166 1 : state = P::transition(mViewSource,
1167 : nsHtml5Tokenizer::MARKUP_DECLARATION_OCTYPE,
1168 : reconsume,
1169 : pos);
1170 1 : NS_HTML5_CONTINUE(stateloop);
1171 : }
1172 : case '[': {
1173 0 : if (tokenHandler->cdataSectionAllowed()) {
1174 0 : clearStrBufBeforeUse();
1175 0 : appendStrBuf(c);
1176 0 : index = 0;
1177 0 : state = P::transition(
1178 : mViewSource, nsHtml5Tokenizer::CDATA_START, reconsume, pos);
1179 0 : NS_HTML5_CONTINUE(stateloop);
1180 : }
1181 : }
1182 : default: {
1183 : if (P::reportErrors) {
1184 0 : errBogusComment();
1185 : }
1186 0 : clearStrBufBeforeUse();
1187 0 : reconsume = true;
1188 0 : state = P::transition(
1189 : mViewSource, nsHtml5Tokenizer::BOGUS_COMMENT, reconsume, pos);
1190 0 : NS_HTML5_CONTINUE(stateloop);
1191 : }
1192 : }
1193 : }
1194 : markupdeclarationopenloop_end: ;
1195 : }
1196 : case MARKUP_DECLARATION_HYPHEN: {
1197 : for (; ; ) {
1198 5 : if (++pos == endPos) {
1199 0 : NS_HTML5_BREAK(stateloop);
1200 : }
1201 5 : c = checkChar(buf, pos);
1202 5 : switch(c) {
1203 : case '\0': {
1204 0 : NS_HTML5_BREAK(stateloop);
1205 : }
1206 : case '-': {
1207 5 : clearStrBufAfterOneHyphen();
1208 5 : state = P::transition(
1209 : mViewSource, nsHtml5Tokenizer::COMMENT_START, reconsume, pos);
1210 5 : NS_HTML5_BREAK(markupdeclarationhyphenloop);
1211 : }
1212 : default: {
1213 : if (P::reportErrors) {
1214 0 : errBogusComment();
1215 : }
1216 0 : reconsume = true;
1217 0 : state = P::transition(
1218 : mViewSource, nsHtml5Tokenizer::BOGUS_COMMENT, reconsume, pos);
1219 0 : NS_HTML5_CONTINUE(stateloop);
1220 : }
1221 : }
1222 : }
1223 : markupdeclarationhyphenloop_end: ;
1224 : }
1225 : case COMMENT_START: {
1226 : for (; ; ) {
1227 5 : if (++pos == endPos) {
1228 0 : NS_HTML5_BREAK(stateloop);
1229 : }
1230 5 : c = checkChar(buf, pos);
1231 5 : switch(c) {
1232 : case '-': {
1233 0 : appendStrBuf(c);
1234 0 : state = P::transition(mViewSource,
1235 : nsHtml5Tokenizer::COMMENT_START_DASH,
1236 : reconsume,
1237 : pos);
1238 0 : NS_HTML5_CONTINUE(stateloop);
1239 : }
1240 : case '>': {
1241 : if (P::reportErrors) {
1242 0 : errPrematureEndOfComment();
1243 : }
1244 0 : emitComment(0, pos);
1245 0 : state = P::transition(
1246 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
1247 0 : NS_HTML5_CONTINUE(stateloop);
1248 : }
1249 : case '\r': {
1250 0 : appendStrBufCarriageReturn();
1251 0 : state = P::transition(
1252 : mViewSource, nsHtml5Tokenizer::COMMENT, reconsume, pos);
1253 0 : NS_HTML5_BREAK(stateloop);
1254 : }
1255 : case '\n': {
1256 0 : appendStrBufLineFeed();
1257 0 : state = P::transition(
1258 : mViewSource, nsHtml5Tokenizer::COMMENT, reconsume, pos);
1259 0 : NS_HTML5_BREAK(commentstartloop);
1260 : }
1261 : case '\0': {
1262 0 : c = 0xfffd;
1263 : }
1264 : default: {
1265 5 : appendStrBuf(c);
1266 5 : state = P::transition(
1267 : mViewSource, nsHtml5Tokenizer::COMMENT, reconsume, pos);
1268 5 : NS_HTML5_BREAK(commentstartloop);
1269 : }
1270 : }
1271 : }
1272 : commentstartloop_end: ;
1273 : }
1274 : case COMMENT: {
1275 : for (; ; ) {
1276 1125 : if (++pos == endPos) {
1277 0 : NS_HTML5_BREAK(stateloop);
1278 : }
1279 568 : c = checkChar(buf, pos);
1280 568 : switch(c) {
1281 : case '-': {
1282 11 : appendStrBuf(c);
1283 11 : state = P::transition(mViewSource,
1284 : nsHtml5Tokenizer::COMMENT_END_DASH,
1285 : reconsume,
1286 : pos);
1287 11 : NS_HTML5_BREAK(commentloop);
1288 : }
1289 : case '\r': {
1290 0 : appendStrBufCarriageReturn();
1291 0 : NS_HTML5_BREAK(stateloop);
1292 : }
1293 : case '\n': {
1294 4 : appendStrBufLineFeed();
1295 4 : continue;
1296 : }
1297 : case '\0': {
1298 0 : c = 0xfffd;
1299 : }
1300 : default: {
1301 553 : appendStrBuf(c);
1302 553 : continue;
1303 : }
1304 : }
1305 : }
1306 : commentloop_end: ;
1307 : }
1308 : case COMMENT_END_DASH: {
1309 : for (; ; ) {
1310 11 : if (++pos == endPos) {
1311 0 : NS_HTML5_BREAK(stateloop);
1312 : }
1313 11 : c = checkChar(buf, pos);
1314 11 : switch(c) {
1315 : case '-': {
1316 5 : appendStrBuf(c);
1317 5 : state = P::transition(
1318 : mViewSource, nsHtml5Tokenizer::COMMENT_END, reconsume, pos);
1319 5 : NS_HTML5_BREAK(commentenddashloop);
1320 : }
1321 : case '\r': {
1322 0 : appendStrBufCarriageReturn();
1323 0 : state = P::transition(
1324 : mViewSource, nsHtml5Tokenizer::COMMENT, reconsume, pos);
1325 0 : NS_HTML5_BREAK(stateloop);
1326 : }
1327 : case '\n': {
1328 0 : appendStrBufLineFeed();
1329 0 : state = P::transition(
1330 : mViewSource, nsHtml5Tokenizer::COMMENT, reconsume, pos);
1331 0 : NS_HTML5_CONTINUE(stateloop);
1332 : }
1333 : case '\0': {
1334 0 : c = 0xfffd;
1335 : }
1336 : default: {
1337 6 : appendStrBuf(c);
1338 6 : state = P::transition(
1339 : mViewSource, nsHtml5Tokenizer::COMMENT, reconsume, pos);
1340 6 : NS_HTML5_CONTINUE(stateloop);
1341 : }
1342 : }
1343 : }
1344 : commentenddashloop_end: ;
1345 : }
1346 : case COMMENT_END: {
1347 : for (; ; ) {
1348 5 : if (++pos == endPos) {
1349 0 : NS_HTML5_BREAK(stateloop);
1350 : }
1351 5 : c = checkChar(buf, pos);
1352 5 : switch(c) {
1353 : case '>': {
1354 5 : emitComment(2, pos);
1355 5 : state = P::transition(
1356 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
1357 5 : NS_HTML5_CONTINUE(stateloop);
1358 : }
1359 : case '-': {
1360 0 : adjustDoubleHyphenAndAppendToStrBufAndErr(c);
1361 0 : continue;
1362 : }
1363 : case '\r': {
1364 0 : adjustDoubleHyphenAndAppendToStrBufCarriageReturn();
1365 0 : state = P::transition(
1366 : mViewSource, nsHtml5Tokenizer::COMMENT, reconsume, pos);
1367 0 : NS_HTML5_BREAK(stateloop);
1368 : }
1369 : case '\n': {
1370 0 : adjustDoubleHyphenAndAppendToStrBufLineFeed();
1371 0 : state = P::transition(
1372 : mViewSource, nsHtml5Tokenizer::COMMENT, reconsume, pos);
1373 0 : NS_HTML5_CONTINUE(stateloop);
1374 : }
1375 : case '!': {
1376 : if (P::reportErrors) {
1377 0 : errHyphenHyphenBang();
1378 : }
1379 0 : appendStrBuf(c);
1380 0 : state = P::transition(mViewSource,
1381 : nsHtml5Tokenizer::COMMENT_END_BANG,
1382 : reconsume,
1383 : pos);
1384 0 : NS_HTML5_CONTINUE(stateloop);
1385 : }
1386 : case '\0': {
1387 0 : c = 0xfffd;
1388 : }
1389 : default: {
1390 0 : adjustDoubleHyphenAndAppendToStrBufAndErr(c);
1391 0 : state = P::transition(
1392 : mViewSource, nsHtml5Tokenizer::COMMENT, reconsume, pos);
1393 0 : NS_HTML5_CONTINUE(stateloop);
1394 : }
1395 : }
1396 : }
1397 :
1398 : }
1399 : case COMMENT_END_BANG: {
1400 : for (; ; ) {
1401 0 : if (++pos == endPos) {
1402 0 : NS_HTML5_BREAK(stateloop);
1403 : }
1404 0 : c = checkChar(buf, pos);
1405 0 : switch(c) {
1406 : case '>': {
1407 0 : emitComment(3, pos);
1408 0 : state = P::transition(
1409 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
1410 0 : NS_HTML5_CONTINUE(stateloop);
1411 : }
1412 : case '-': {
1413 0 : appendStrBuf(c);
1414 0 : state = P::transition(mViewSource,
1415 : nsHtml5Tokenizer::COMMENT_END_DASH,
1416 : reconsume,
1417 : pos);
1418 0 : NS_HTML5_CONTINUE(stateloop);
1419 : }
1420 : case '\r': {
1421 0 : appendStrBufCarriageReturn();
1422 0 : NS_HTML5_BREAK(stateloop);
1423 : }
1424 : case '\n': {
1425 0 : appendStrBufLineFeed();
1426 0 : continue;
1427 : }
1428 : case '\0': {
1429 0 : c = 0xfffd;
1430 : }
1431 : default: {
1432 0 : appendStrBuf(c);
1433 0 : state = P::transition(
1434 : mViewSource, nsHtml5Tokenizer::COMMENT, reconsume, pos);
1435 0 : NS_HTML5_CONTINUE(stateloop);
1436 : }
1437 : }
1438 : }
1439 : }
1440 : case COMMENT_START_DASH: {
1441 0 : if (++pos == endPos) {
1442 0 : NS_HTML5_BREAK(stateloop);
1443 : }
1444 0 : c = checkChar(buf, pos);
1445 0 : switch(c) {
1446 : case '-': {
1447 0 : appendStrBuf(c);
1448 0 : state = P::transition(
1449 : mViewSource, nsHtml5Tokenizer::COMMENT_END, reconsume, pos);
1450 0 : NS_HTML5_CONTINUE(stateloop);
1451 : }
1452 : case '>': {
1453 : if (P::reportErrors) {
1454 0 : errPrematureEndOfComment();
1455 : }
1456 0 : emitComment(1, pos);
1457 0 : state = P::transition(
1458 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
1459 0 : NS_HTML5_CONTINUE(stateloop);
1460 : }
1461 : case '\r': {
1462 0 : appendStrBufCarriageReturn();
1463 0 : state = P::transition(
1464 : mViewSource, nsHtml5Tokenizer::COMMENT, reconsume, pos);
1465 0 : NS_HTML5_BREAK(stateloop);
1466 : }
1467 : case '\n': {
1468 0 : appendStrBufLineFeed();
1469 0 : state = P::transition(
1470 : mViewSource, nsHtml5Tokenizer::COMMENT, reconsume, pos);
1471 0 : NS_HTML5_CONTINUE(stateloop);
1472 : }
1473 : case '\0': {
1474 0 : c = 0xfffd;
1475 : }
1476 : default: {
1477 0 : appendStrBuf(c);
1478 0 : state = P::transition(
1479 : mViewSource, nsHtml5Tokenizer::COMMENT, reconsume, pos);
1480 0 : NS_HTML5_CONTINUE(stateloop);
1481 : }
1482 : }
1483 : }
1484 : case CDATA_START: {
1485 : for (; ; ) {
1486 0 : if (++pos == endPos) {
1487 0 : NS_HTML5_BREAK(stateloop);
1488 : }
1489 0 : c = checkChar(buf, pos);
1490 0 : if (index < 6) {
1491 0 : if (c == nsHtml5Tokenizer::CDATA_LSQB[index]) {
1492 0 : appendStrBuf(c);
1493 : } else {
1494 : if (P::reportErrors) {
1495 0 : errBogusComment();
1496 : }
1497 0 : reconsume = true;
1498 0 : state = P::transition(
1499 : mViewSource, nsHtml5Tokenizer::BOGUS_COMMENT, reconsume, pos);
1500 0 : NS_HTML5_CONTINUE(stateloop);
1501 : }
1502 0 : index++;
1503 0 : continue;
1504 : } else {
1505 0 : clearStrBufAfterUse();
1506 0 : cstart = pos;
1507 0 : reconsume = true;
1508 0 : state = P::transition(
1509 : mViewSource, nsHtml5Tokenizer::CDATA_SECTION, reconsume, pos);
1510 0 : break;
1511 : }
1512 : }
1513 : }
1514 : case CDATA_SECTION: {
1515 : for (; ; ) {
1516 0 : if (reconsume) {
1517 0 : reconsume = false;
1518 : } else {
1519 0 : if (++pos == endPos) {
1520 0 : NS_HTML5_BREAK(stateloop);
1521 : }
1522 0 : c = checkChar(buf, pos);
1523 : }
1524 0 : switch(c) {
1525 : case ']': {
1526 0 : flushChars(buf, pos);
1527 0 : state = P::transition(
1528 : mViewSource, nsHtml5Tokenizer::CDATA_RSQB, reconsume, pos);
1529 0 : NS_HTML5_BREAK(cdatasectionloop);
1530 : }
1531 : case '\0': {
1532 0 : emitReplacementCharacter(buf, pos);
1533 0 : continue;
1534 : }
1535 : case '\r': {
1536 0 : emitCarriageReturn(buf, pos);
1537 0 : NS_HTML5_BREAK(stateloop);
1538 : }
1539 : case '\n': {
1540 0 : silentLineFeed();
1541 : }
1542 : default: {
1543 0 : continue;
1544 : }
1545 : }
1546 : }
1547 : cdatasectionloop_end: ;
1548 : }
1549 : case CDATA_RSQB: {
1550 : for (; ; ) {
1551 0 : if (++pos == endPos) {
1552 0 : NS_HTML5_BREAK(stateloop);
1553 : }
1554 0 : c = checkChar(buf, pos);
1555 0 : switch(c) {
1556 : case ']': {
1557 0 : state = P::transition(
1558 : mViewSource, nsHtml5Tokenizer::CDATA_RSQB_RSQB, reconsume, pos);
1559 0 : NS_HTML5_BREAK(cdatarsqb);
1560 : }
1561 : default: {
1562 0 : tokenHandler->characters(nsHtml5Tokenizer::RSQB_RSQB, 0, 1);
1563 0 : cstart = pos;
1564 0 : reconsume = true;
1565 0 : state = P::transition(
1566 : mViewSource, nsHtml5Tokenizer::CDATA_SECTION, reconsume, pos);
1567 0 : NS_HTML5_CONTINUE(stateloop);
1568 : }
1569 : }
1570 : }
1571 : cdatarsqb_end: ;
1572 : }
1573 : case CDATA_RSQB_RSQB: {
1574 : for (; ; ) {
1575 0 : if (++pos == endPos) {
1576 0 : NS_HTML5_BREAK(stateloop);
1577 : }
1578 0 : c = checkChar(buf, pos);
1579 0 : switch(c) {
1580 : case ']': {
1581 0 : tokenHandler->characters(nsHtml5Tokenizer::RSQB_RSQB, 0, 1);
1582 0 : continue;
1583 : }
1584 : case '>': {
1585 0 : cstart = pos + 1;
1586 0 : state = P::transition(
1587 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
1588 0 : NS_HTML5_CONTINUE(stateloop);
1589 : }
1590 : default: {
1591 0 : tokenHandler->characters(nsHtml5Tokenizer::RSQB_RSQB, 0, 2);
1592 0 : cstart = pos;
1593 0 : reconsume = true;
1594 0 : state = P::transition(
1595 : mViewSource, nsHtml5Tokenizer::CDATA_SECTION, reconsume, pos);
1596 0 : NS_HTML5_CONTINUE(stateloop);
1597 : }
1598 : }
1599 : }
1600 :
1601 : }
1602 : case ATTRIBUTE_VALUE_SINGLE_QUOTED: {
1603 : for (; ; ) {
1604 0 : if (reconsume) {
1605 0 : reconsume = false;
1606 : } else {
1607 0 : if (++pos == endPos) {
1608 0 : NS_HTML5_BREAK(stateloop);
1609 : }
1610 0 : c = checkChar(buf, pos);
1611 : }
1612 0 : switch(c) {
1613 : case '\'': {
1614 0 : addAttributeWithValue();
1615 0 : state =
1616 0 : P::transition(mViewSource,
1617 : nsHtml5Tokenizer::AFTER_ATTRIBUTE_VALUE_QUOTED,
1618 : reconsume,
1619 : pos);
1620 0 : NS_HTML5_CONTINUE(stateloop);
1621 : }
1622 : case '&': {
1623 0 : MOZ_ASSERT(!charRefBufLen, "charRefBufLen not reset after previous use!");
1624 0 : appendCharRefBuf(c);
1625 0 : setAdditionalAndRememberAmpersandLocation('\'');
1626 0 : returnState = state;
1627 0 : state =
1628 0 : P::transition(mViewSource,
1629 : nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE,
1630 : reconsume,
1631 : pos);
1632 0 : NS_HTML5_BREAK(attributevaluesinglequotedloop);
1633 : }
1634 : case '\r': {
1635 0 : appendStrBufCarriageReturn();
1636 0 : NS_HTML5_BREAK(stateloop);
1637 : }
1638 : case '\n': {
1639 0 : appendStrBufLineFeed();
1640 0 : continue;
1641 : }
1642 : case '\0': {
1643 0 : c = 0xfffd;
1644 : }
1645 : default: {
1646 0 : appendStrBuf(c);
1647 0 : continue;
1648 : }
1649 : }
1650 : }
1651 : attributevaluesinglequotedloop_end: ;
1652 : }
1653 : case CONSUME_CHARACTER_REFERENCE: {
1654 0 : if (++pos == endPos) {
1655 0 : NS_HTML5_BREAK(stateloop);
1656 : }
1657 0 : c = checkChar(buf, pos);
1658 0 : if (c == '\0') {
1659 0 : NS_HTML5_BREAK(stateloop);
1660 : }
1661 0 : switch(c) {
1662 : case ' ':
1663 : case '\t':
1664 : case '\n':
1665 : case '\r':
1666 : case '\f':
1667 : case '<':
1668 : case '&': {
1669 0 : emitOrAppendCharRefBuf(returnState);
1670 0 : if (!(returnState & DATA_AND_RCDATA_MASK)) {
1671 0 : cstart = pos;
1672 : }
1673 0 : reconsume = true;
1674 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
1675 0 : NS_HTML5_CONTINUE(stateloop);
1676 : }
1677 : case '#': {
1678 0 : appendCharRefBuf('#');
1679 0 : state = P::transition(
1680 : mViewSource, nsHtml5Tokenizer::CONSUME_NCR, reconsume, pos);
1681 0 : NS_HTML5_CONTINUE(stateloop);
1682 : }
1683 : default: {
1684 0 : if (c == additional) {
1685 0 : emitOrAppendCharRefBuf(returnState);
1686 0 : reconsume = true;
1687 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
1688 0 : NS_HTML5_CONTINUE(stateloop);
1689 : }
1690 0 : if (c >= 'a' && c <= 'z') {
1691 0 : firstCharKey = c - 'a' + 26;
1692 0 : } else if (c >= 'A' && c <= 'Z') {
1693 0 : firstCharKey = c - 'A';
1694 : } else {
1695 : if (P::reportErrors) {
1696 0 : errNoNamedCharacterMatch();
1697 : }
1698 0 : emitOrAppendCharRefBuf(returnState);
1699 0 : if (!(returnState & DATA_AND_RCDATA_MASK)) {
1700 0 : cstart = pos;
1701 : }
1702 0 : reconsume = true;
1703 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
1704 0 : NS_HTML5_CONTINUE(stateloop);
1705 : }
1706 0 : appendCharRefBuf(c);
1707 0 : state =
1708 0 : P::transition(mViewSource,
1709 : nsHtml5Tokenizer::CHARACTER_REFERENCE_HILO_LOOKUP,
1710 : reconsume,
1711 : pos);
1712 : }
1713 : }
1714 : }
1715 : case CHARACTER_REFERENCE_HILO_LOOKUP: {
1716 : {
1717 0 : if (++pos == endPos) {
1718 0 : NS_HTML5_BREAK(stateloop);
1719 : }
1720 0 : c = checkChar(buf, pos);
1721 0 : if (c == '\0') {
1722 0 : NS_HTML5_BREAK(stateloop);
1723 : }
1724 0 : int32_t hilo = 0;
1725 0 : if (c <= 'z') {
1726 0 : const int32_t* row = nsHtml5NamedCharactersAccel::HILO_ACCEL[c];
1727 0 : if (row) {
1728 0 : hilo = row[firstCharKey];
1729 : }
1730 : }
1731 0 : if (!hilo) {
1732 : if (P::reportErrors) {
1733 0 : errNoNamedCharacterMatch();
1734 : }
1735 0 : emitOrAppendCharRefBuf(returnState);
1736 0 : if (!(returnState & DATA_AND_RCDATA_MASK)) {
1737 0 : cstart = pos;
1738 : }
1739 0 : reconsume = true;
1740 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
1741 0 : NS_HTML5_CONTINUE(stateloop);
1742 : }
1743 0 : appendCharRefBuf(c);
1744 0 : lo = hilo & 0xFFFF;
1745 0 : hi = hilo >> 16;
1746 0 : entCol = -1;
1747 0 : candidate = -1;
1748 0 : charRefBufMark = 0;
1749 0 : state = P::transition(mViewSource,
1750 : nsHtml5Tokenizer::CHARACTER_REFERENCE_TAIL,
1751 : reconsume,
1752 : pos);
1753 : }
1754 : }
1755 : case CHARACTER_REFERENCE_TAIL: {
1756 : for (; ; ) {
1757 0 : if (++pos == endPos) {
1758 0 : NS_HTML5_BREAK(stateloop);
1759 : }
1760 0 : c = checkChar(buf, pos);
1761 0 : if (c == '\0') {
1762 0 : NS_HTML5_BREAK(stateloop);
1763 : }
1764 0 : entCol++;
1765 : for (; ; ) {
1766 0 : if (hi < lo) {
1767 0 : NS_HTML5_BREAK(outer);
1768 : }
1769 0 : if (entCol == nsHtml5NamedCharacters::NAMES[lo].length()) {
1770 0 : candidate = lo;
1771 0 : charRefBufMark = charRefBufLen;
1772 0 : lo++;
1773 0 : } else if (entCol > nsHtml5NamedCharacters::NAMES[lo].length()) {
1774 0 : NS_HTML5_BREAK(outer);
1775 0 : } else if (c > nsHtml5NamedCharacters::NAMES[lo].charAt(entCol)) {
1776 0 : lo++;
1777 : } else {
1778 0 : NS_HTML5_BREAK(loloop);
1779 : }
1780 : }
1781 : loloop_end: ;
1782 : for (; ; ) {
1783 0 : if (hi < lo) {
1784 0 : NS_HTML5_BREAK(outer);
1785 : }
1786 0 : if (entCol == nsHtml5NamedCharacters::NAMES[hi].length()) {
1787 0 : NS_HTML5_BREAK(hiloop);
1788 : }
1789 0 : if (entCol > nsHtml5NamedCharacters::NAMES[hi].length()) {
1790 0 : NS_HTML5_BREAK(outer);
1791 0 : } else if (c < nsHtml5NamedCharacters::NAMES[hi].charAt(entCol)) {
1792 0 : hi--;
1793 : } else {
1794 0 : NS_HTML5_BREAK(hiloop);
1795 : }
1796 : }
1797 : hiloop_end: ;
1798 0 : if (c == ';') {
1799 0 : if (entCol + 1 == nsHtml5NamedCharacters::NAMES[lo].length()) {
1800 0 : candidate = lo;
1801 0 : charRefBufMark = charRefBufLen;
1802 : }
1803 0 : NS_HTML5_BREAK(outer);
1804 : }
1805 0 : if (hi < lo) {
1806 0 : NS_HTML5_BREAK(outer);
1807 : }
1808 0 : appendCharRefBuf(c);
1809 0 : continue;
1810 : }
1811 : outer_end: ;
1812 0 : if (candidate == -1) {
1813 : if (P::reportErrors) {
1814 0 : errNoNamedCharacterMatch();
1815 : }
1816 0 : emitOrAppendCharRefBuf(returnState);
1817 0 : if (!(returnState & DATA_AND_RCDATA_MASK)) {
1818 0 : cstart = pos;
1819 : }
1820 0 : reconsume = true;
1821 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
1822 0 : NS_HTML5_CONTINUE(stateloop);
1823 : } else {
1824 0 : const nsHtml5CharacterName& candidateName = nsHtml5NamedCharacters::NAMES[candidate];
1825 0 : if (!candidateName.length() || candidateName.charAt(candidateName.length() - 1) != ';') {
1826 0 : if ((returnState & DATA_AND_RCDATA_MASK)) {
1827 : char16_t ch;
1828 0 : if (charRefBufMark == charRefBufLen) {
1829 0 : ch = c;
1830 : } else {
1831 0 : ch = charRefBuf[charRefBufMark];
1832 : }
1833 0 : if (ch == '=' || (ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
1834 : if (P::reportErrors) {
1835 0 : errNoNamedCharacterMatch();
1836 : }
1837 0 : appendCharRefBufToStrBuf();
1838 0 : reconsume = true;
1839 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
1840 0 : NS_HTML5_CONTINUE(stateloop);
1841 : }
1842 : }
1843 0 : if ((returnState & DATA_AND_RCDATA_MASK)) {
1844 : if (P::reportErrors) {
1845 0 : errUnescapedAmpersandInterpretedAsCharacterReference();
1846 : }
1847 : } else {
1848 : if (P::reportErrors) {
1849 0 : errNotSemicolonTerminated();
1850 : }
1851 : }
1852 : }
1853 0 : P::completedNamedCharacterReference(mViewSource);
1854 0 : const char16_t* val = nsHtml5NamedCharacters::VALUES[candidate];
1855 0 : if (!val[1]) {
1856 0 : emitOrAppendOne(val, returnState);
1857 : } else {
1858 0 : emitOrAppendTwo(val, returnState);
1859 : }
1860 0 : if (charRefBufMark < charRefBufLen) {
1861 0 : if ((returnState & DATA_AND_RCDATA_MASK)) {
1862 0 : appendStrBuf(charRefBuf, charRefBufMark, charRefBufLen - charRefBufMark);
1863 : } else {
1864 0 : tokenHandler->characters(charRefBuf, charRefBufMark, charRefBufLen - charRefBufMark);
1865 : }
1866 : }
1867 0 : bool earlyBreak = (c == ';' && charRefBufMark == charRefBufLen);
1868 0 : charRefBufLen = 0;
1869 0 : if (!(returnState & DATA_AND_RCDATA_MASK)) {
1870 0 : cstart = earlyBreak ? pos + 1 : pos;
1871 : }
1872 0 : reconsume = !earlyBreak;
1873 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
1874 0 : NS_HTML5_CONTINUE(stateloop);
1875 : }
1876 : }
1877 : case CONSUME_NCR: {
1878 0 : if (++pos == endPos) {
1879 0 : NS_HTML5_BREAK(stateloop);
1880 : }
1881 0 : c = checkChar(buf, pos);
1882 0 : value = 0;
1883 0 : seenDigits = false;
1884 0 : switch(c) {
1885 : case 'x':
1886 : case 'X': {
1887 0 : appendCharRefBuf(c);
1888 0 : state = P::transition(
1889 : mViewSource, nsHtml5Tokenizer::HEX_NCR_LOOP, reconsume, pos);
1890 0 : NS_HTML5_CONTINUE(stateloop);
1891 : }
1892 : default: {
1893 0 : reconsume = true;
1894 0 : state = P::transition(
1895 : mViewSource, nsHtml5Tokenizer::DECIMAL_NRC_LOOP, reconsume, pos);
1896 : }
1897 : }
1898 : }
1899 : case DECIMAL_NRC_LOOP: {
1900 : for (; ; ) {
1901 0 : if (reconsume) {
1902 0 : reconsume = false;
1903 : } else {
1904 0 : if (++pos == endPos) {
1905 0 : NS_HTML5_BREAK(stateloop);
1906 : }
1907 0 : c = checkChar(buf, pos);
1908 : }
1909 0 : MOZ_ASSERT(value >= 0, "value must not become negative.");
1910 0 : if (c >= '0' && c <= '9') {
1911 0 : seenDigits = true;
1912 0 : if (value <= 0x10FFFF) {
1913 0 : value *= 10;
1914 0 : value += c - '0';
1915 : }
1916 0 : continue;
1917 0 : } else if (c == ';') {
1918 0 : if (seenDigits) {
1919 0 : if (!(returnState & DATA_AND_RCDATA_MASK)) {
1920 0 : cstart = pos + 1;
1921 : }
1922 0 : state = P::transition(mViewSource,
1923 : nsHtml5Tokenizer::HANDLE_NCR_VALUE,
1924 : reconsume,
1925 : pos);
1926 0 : NS_HTML5_BREAK(decimalloop);
1927 : } else {
1928 : if (P::reportErrors) {
1929 0 : errNoDigitsInNCR();
1930 : }
1931 0 : appendCharRefBuf(';');
1932 0 : emitOrAppendCharRefBuf(returnState);
1933 0 : if (!(returnState & DATA_AND_RCDATA_MASK)) {
1934 0 : cstart = pos + 1;
1935 : }
1936 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
1937 0 : NS_HTML5_CONTINUE(stateloop);
1938 : }
1939 : } else {
1940 0 : if (!seenDigits) {
1941 : if (P::reportErrors) {
1942 0 : errNoDigitsInNCR();
1943 : }
1944 0 : emitOrAppendCharRefBuf(returnState);
1945 0 : if (!(returnState & DATA_AND_RCDATA_MASK)) {
1946 0 : cstart = pos;
1947 : }
1948 0 : reconsume = true;
1949 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
1950 0 : NS_HTML5_CONTINUE(stateloop);
1951 : } else {
1952 : if (P::reportErrors) {
1953 0 : errCharRefLacksSemicolon();
1954 : }
1955 0 : if (!(returnState & DATA_AND_RCDATA_MASK)) {
1956 0 : cstart = pos;
1957 : }
1958 0 : reconsume = true;
1959 0 : state = P::transition(mViewSource,
1960 : nsHtml5Tokenizer::HANDLE_NCR_VALUE,
1961 : reconsume,
1962 : pos);
1963 0 : NS_HTML5_BREAK(decimalloop);
1964 : }
1965 : }
1966 : }
1967 : decimalloop_end: ;
1968 : }
1969 : case HANDLE_NCR_VALUE: {
1970 0 : charRefBufLen = 0;
1971 0 : handleNcrValue(returnState);
1972 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
1973 0 : NS_HTML5_CONTINUE(stateloop);
1974 : }
1975 : case HEX_NCR_LOOP: {
1976 : for (; ; ) {
1977 0 : if (++pos == endPos) {
1978 0 : NS_HTML5_BREAK(stateloop);
1979 : }
1980 0 : c = checkChar(buf, pos);
1981 0 : MOZ_ASSERT(value >= 0, "value must not become negative.");
1982 0 : if (c >= '0' && c <= '9') {
1983 0 : seenDigits = true;
1984 0 : if (value <= 0x10FFFF) {
1985 0 : value *= 16;
1986 0 : value += c - '0';
1987 : }
1988 0 : continue;
1989 0 : } else if (c >= 'A' && c <= 'F') {
1990 0 : seenDigits = true;
1991 0 : if (value <= 0x10FFFF) {
1992 0 : value *= 16;
1993 0 : value += c - 'A' + 10;
1994 : }
1995 0 : continue;
1996 0 : } else if (c >= 'a' && c <= 'f') {
1997 0 : seenDigits = true;
1998 0 : if (value <= 0x10FFFF) {
1999 0 : value *= 16;
2000 0 : value += c - 'a' + 10;
2001 : }
2002 0 : continue;
2003 0 : } else if (c == ';') {
2004 0 : if (seenDigits) {
2005 0 : if (!(returnState & DATA_AND_RCDATA_MASK)) {
2006 0 : cstart = pos + 1;
2007 : }
2008 0 : state = P::transition(mViewSource,
2009 : nsHtml5Tokenizer::HANDLE_NCR_VALUE,
2010 : reconsume,
2011 : pos);
2012 0 : NS_HTML5_CONTINUE(stateloop);
2013 : } else {
2014 : if (P::reportErrors) {
2015 0 : errNoDigitsInNCR();
2016 : }
2017 0 : appendCharRefBuf(';');
2018 0 : emitOrAppendCharRefBuf(returnState);
2019 0 : if (!(returnState & DATA_AND_RCDATA_MASK)) {
2020 0 : cstart = pos + 1;
2021 : }
2022 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
2023 0 : NS_HTML5_CONTINUE(stateloop);
2024 : }
2025 : } else {
2026 0 : if (!seenDigits) {
2027 : if (P::reportErrors) {
2028 0 : errNoDigitsInNCR();
2029 : }
2030 0 : emitOrAppendCharRefBuf(returnState);
2031 0 : if (!(returnState & DATA_AND_RCDATA_MASK)) {
2032 0 : cstart = pos;
2033 : }
2034 0 : reconsume = true;
2035 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
2036 0 : NS_HTML5_CONTINUE(stateloop);
2037 : } else {
2038 : if (P::reportErrors) {
2039 0 : errCharRefLacksSemicolon();
2040 : }
2041 0 : if (!(returnState & DATA_AND_RCDATA_MASK)) {
2042 0 : cstart = pos;
2043 : }
2044 0 : reconsume = true;
2045 0 : state = P::transition(mViewSource,
2046 : nsHtml5Tokenizer::HANDLE_NCR_VALUE,
2047 : reconsume,
2048 : pos);
2049 0 : NS_HTML5_CONTINUE(stateloop);
2050 : }
2051 : }
2052 : }
2053 : }
2054 : case PLAINTEXT: {
2055 : for (; ; ) {
2056 0 : if (reconsume) {
2057 0 : reconsume = false;
2058 : } else {
2059 0 : if (++pos == endPos) {
2060 0 : NS_HTML5_BREAK(stateloop);
2061 : }
2062 0 : c = checkChar(buf, pos);
2063 : }
2064 0 : switch(c) {
2065 : case '\0': {
2066 0 : emitPlaintextReplacementCharacter(buf, pos);
2067 0 : continue;
2068 : }
2069 : case '\r': {
2070 0 : emitCarriageReturn(buf, pos);
2071 0 : NS_HTML5_BREAK(stateloop);
2072 : }
2073 : case '\n': {
2074 0 : silentLineFeed();
2075 : }
2076 : default: {
2077 0 : continue;
2078 : }
2079 : }
2080 : }
2081 :
2082 : }
2083 : case CLOSE_TAG_OPEN: {
2084 5 : if (++pos == endPos) {
2085 0 : NS_HTML5_BREAK(stateloop);
2086 : }
2087 5 : c = checkChar(buf, pos);
2088 5 : switch(c) {
2089 : case '>': {
2090 : if (P::reportErrors) {
2091 0 : errLtSlashGt();
2092 : }
2093 0 : cstart = pos + 1;
2094 0 : state = P::transition(
2095 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
2096 0 : NS_HTML5_CONTINUE(stateloop);
2097 : }
2098 : case '\r': {
2099 0 : silentCarriageReturn();
2100 : if (P::reportErrors) {
2101 0 : errGarbageAfterLtSlash();
2102 : }
2103 0 : clearStrBufBeforeUse();
2104 0 : appendStrBuf('\n');
2105 0 : state = P::transition(
2106 : mViewSource, nsHtml5Tokenizer::BOGUS_COMMENT, reconsume, pos);
2107 0 : NS_HTML5_BREAK(stateloop);
2108 : }
2109 : case '\n': {
2110 0 : silentLineFeed();
2111 : if (P::reportErrors) {
2112 0 : errGarbageAfterLtSlash();
2113 : }
2114 0 : clearStrBufBeforeUse();
2115 0 : appendStrBuf(c);
2116 0 : state = P::transition(
2117 : mViewSource, nsHtml5Tokenizer::BOGUS_COMMENT, reconsume, pos);
2118 0 : NS_HTML5_CONTINUE(stateloop);
2119 : }
2120 : case '\0': {
2121 0 : c = 0xfffd;
2122 : }
2123 : default: {
2124 5 : if (c >= 'A' && c <= 'Z') {
2125 0 : c += 0x20;
2126 : }
2127 5 : if (c >= 'a' && c <= 'z') {
2128 5 : endTag = true;
2129 5 : clearStrBufBeforeUse();
2130 5 : appendStrBuf(c);
2131 5 : containsHyphen = false;
2132 5 : state = P::transition(
2133 : mViewSource, nsHtml5Tokenizer::TAG_NAME, reconsume, pos);
2134 5 : NS_HTML5_CONTINUE(stateloop);
2135 : } else {
2136 : if (P::reportErrors) {
2137 0 : errGarbageAfterLtSlash();
2138 : }
2139 0 : clearStrBufBeforeUse();
2140 0 : appendStrBuf(c);
2141 0 : state = P::transition(
2142 : mViewSource, nsHtml5Tokenizer::BOGUS_COMMENT, reconsume, pos);
2143 0 : NS_HTML5_CONTINUE(stateloop);
2144 : }
2145 : }
2146 : }
2147 : }
2148 : case RCDATA: {
2149 : for (; ; ) {
2150 1 : if (reconsume) {
2151 0 : reconsume = false;
2152 : } else {
2153 1 : if (++pos == endPos) {
2154 0 : NS_HTML5_BREAK(stateloop);
2155 : }
2156 1 : c = checkChar(buf, pos);
2157 : }
2158 1 : switch(c) {
2159 : case '&': {
2160 0 : flushChars(buf, pos);
2161 0 : MOZ_ASSERT(!charRefBufLen, "charRefBufLen not reset after previous use!");
2162 0 : appendCharRefBuf(c);
2163 0 : setAdditionalAndRememberAmpersandLocation('\0');
2164 0 : returnState = state;
2165 0 : state =
2166 0 : P::transition(mViewSource,
2167 : nsHtml5Tokenizer::CONSUME_CHARACTER_REFERENCE,
2168 : reconsume,
2169 : pos);
2170 0 : NS_HTML5_CONTINUE(stateloop);
2171 : }
2172 : case '<': {
2173 1 : flushChars(buf, pos);
2174 1 : returnState = state;
2175 1 : state =
2176 1 : P::transition(mViewSource,
2177 : nsHtml5Tokenizer::RAWTEXT_RCDATA_LESS_THAN_SIGN,
2178 : reconsume,
2179 : pos);
2180 1 : NS_HTML5_CONTINUE(stateloop);
2181 : }
2182 : case '\0': {
2183 0 : emitReplacementCharacter(buf, pos);
2184 0 : continue;
2185 : }
2186 : case '\r': {
2187 0 : emitCarriageReturn(buf, pos);
2188 0 : NS_HTML5_BREAK(stateloop);
2189 : }
2190 : case '\n': {
2191 0 : silentLineFeed();
2192 : }
2193 : default: {
2194 0 : continue;
2195 : }
2196 : }
2197 : }
2198 :
2199 : }
2200 : case RAWTEXT: {
2201 : for (; ; ) {
2202 0 : if (reconsume) {
2203 0 : reconsume = false;
2204 : } else {
2205 0 : if (++pos == endPos) {
2206 0 : NS_HTML5_BREAK(stateloop);
2207 : }
2208 0 : c = checkChar(buf, pos);
2209 : }
2210 0 : switch(c) {
2211 : case '<': {
2212 0 : flushChars(buf, pos);
2213 0 : returnState = state;
2214 0 : state =
2215 0 : P::transition(mViewSource,
2216 : nsHtml5Tokenizer::RAWTEXT_RCDATA_LESS_THAN_SIGN,
2217 : reconsume,
2218 : pos);
2219 0 : NS_HTML5_BREAK(rawtextloop);
2220 : }
2221 : case '\0': {
2222 0 : emitReplacementCharacter(buf, pos);
2223 0 : continue;
2224 : }
2225 : case '\r': {
2226 0 : emitCarriageReturn(buf, pos);
2227 0 : NS_HTML5_BREAK(stateloop);
2228 : }
2229 : case '\n': {
2230 0 : silentLineFeed();
2231 : }
2232 : default: {
2233 0 : continue;
2234 : }
2235 : }
2236 : }
2237 : rawtextloop_end: ;
2238 : }
2239 : case RAWTEXT_RCDATA_LESS_THAN_SIGN: {
2240 : for (; ; ) {
2241 1 : if (++pos == endPos) {
2242 0 : NS_HTML5_BREAK(stateloop);
2243 : }
2244 1 : c = checkChar(buf, pos);
2245 1 : switch(c) {
2246 : case '/': {
2247 1 : index = 0;
2248 1 : clearStrBufBeforeUse();
2249 1 : state = P::transition(mViewSource,
2250 : nsHtml5Tokenizer::NON_DATA_END_TAG_NAME,
2251 : reconsume,
2252 : pos);
2253 1 : NS_HTML5_BREAK(rawtextrcdatalessthansignloop);
2254 : }
2255 : default: {
2256 0 : tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
2257 0 : cstart = pos;
2258 0 : reconsume = true;
2259 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
2260 0 : NS_HTML5_CONTINUE(stateloop);
2261 : }
2262 : }
2263 : }
2264 : rawtextrcdatalessthansignloop_end: ;
2265 : }
2266 : case NON_DATA_END_TAG_NAME: {
2267 35 : for (; ; ) {
2268 41 : if (++pos == endPos) {
2269 0 : NS_HTML5_BREAK(stateloop);
2270 : }
2271 41 : c = checkChar(buf, pos);
2272 41 : if (index < endTagExpectationAsArray.length) {
2273 35 : char16_t e = endTagExpectationAsArray[index];
2274 35 : char16_t folded = c;
2275 35 : if (c >= 'A' && c <= 'Z') {
2276 0 : folded += 0x20;
2277 : }
2278 35 : if (folded != e) {
2279 0 : tokenHandler->characters(nsHtml5Tokenizer::LT_SOLIDUS, 0, 2);
2280 0 : emitStrBuf();
2281 0 : cstart = pos;
2282 0 : reconsume = true;
2283 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
2284 0 : NS_HTML5_CONTINUE(stateloop);
2285 : }
2286 35 : appendStrBuf(c);
2287 35 : index++;
2288 35 : continue;
2289 : } else {
2290 6 : endTag = true;
2291 6 : tagName = endTagExpectation;
2292 6 : switch(c) {
2293 : case '\r': {
2294 0 : silentCarriageReturn();
2295 0 : clearStrBufAfterUse();
2296 0 : state = P::transition(mViewSource,
2297 : nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
2298 : reconsume,
2299 : pos);
2300 0 : NS_HTML5_BREAK(stateloop);
2301 : }
2302 : case '\n': {
2303 0 : silentLineFeed();
2304 : }
2305 : case ' ':
2306 : case '\t':
2307 : case '\f': {
2308 0 : clearStrBufAfterUse();
2309 0 : state = P::transition(mViewSource,
2310 : nsHtml5Tokenizer::BEFORE_ATTRIBUTE_NAME,
2311 : reconsume,
2312 : pos);
2313 0 : NS_HTML5_CONTINUE(stateloop);
2314 : }
2315 : case '/': {
2316 0 : clearStrBufAfterUse();
2317 0 : state = P::transition(mViewSource,
2318 : nsHtml5Tokenizer::SELF_CLOSING_START_TAG,
2319 : reconsume,
2320 : pos);
2321 0 : NS_HTML5_CONTINUE(stateloop);
2322 : }
2323 : case '>': {
2324 6 : clearStrBufAfterUse();
2325 6 : state = P::transition(mViewSource, emitCurrentTagToken(false, pos), reconsume, pos);
2326 6 : if (shouldSuspend) {
2327 5 : NS_HTML5_BREAK(stateloop);
2328 : }
2329 1 : NS_HTML5_CONTINUE(stateloop);
2330 : }
2331 : default: {
2332 0 : tokenHandler->characters(nsHtml5Tokenizer::LT_SOLIDUS, 0, 2);
2333 0 : emitStrBuf();
2334 0 : if (c == '\0') {
2335 0 : emitReplacementCharacter(buf, pos);
2336 : } else {
2337 0 : cstart = pos;
2338 : }
2339 0 : state = P::transition(mViewSource, returnState, reconsume, pos);
2340 0 : NS_HTML5_CONTINUE(stateloop);
2341 : }
2342 : }
2343 : }
2344 : }
2345 : }
2346 : case BOGUS_COMMENT: {
2347 : for (; ; ) {
2348 0 : if (reconsume) {
2349 0 : reconsume = false;
2350 : } else {
2351 0 : if (++pos == endPos) {
2352 0 : NS_HTML5_BREAK(stateloop);
2353 : }
2354 0 : c = checkChar(buf, pos);
2355 : }
2356 0 : switch(c) {
2357 : case '>': {
2358 0 : emitComment(0, pos);
2359 0 : state = P::transition(
2360 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
2361 0 : NS_HTML5_CONTINUE(stateloop);
2362 : }
2363 : case '-': {
2364 0 : appendStrBuf(c);
2365 0 : state = P::transition(mViewSource,
2366 : nsHtml5Tokenizer::BOGUS_COMMENT_HYPHEN,
2367 : reconsume,
2368 : pos);
2369 0 : NS_HTML5_BREAK(boguscommentloop);
2370 : }
2371 : case '\r': {
2372 0 : appendStrBufCarriageReturn();
2373 0 : NS_HTML5_BREAK(stateloop);
2374 : }
2375 : case '\n': {
2376 0 : appendStrBufLineFeed();
2377 0 : continue;
2378 : }
2379 : case '\0': {
2380 0 : c = 0xfffd;
2381 : }
2382 : default: {
2383 0 : appendStrBuf(c);
2384 0 : continue;
2385 : }
2386 : }
2387 : }
2388 : boguscommentloop_end: ;
2389 : }
2390 : case BOGUS_COMMENT_HYPHEN: {
2391 : boguscommenthyphenloop:
2392 : for (;;) {
2393 0 : if (++pos == endPos) {
2394 0 : NS_HTML5_BREAK(stateloop);
2395 : }
2396 0 : c = checkChar(buf, pos);
2397 0 : switch(c) {
2398 : case '>': {
2399 0 : emitComment(0, pos);
2400 0 : state = P::transition(
2401 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
2402 0 : NS_HTML5_CONTINUE(stateloop);
2403 : }
2404 : case '-': {
2405 0 : appendSecondHyphenToBogusComment();
2406 0 : NS_HTML5_CONTINUE(boguscommenthyphenloop);
2407 : }
2408 : case '\r': {
2409 0 : appendStrBufCarriageReturn();
2410 0 : state = P::transition(
2411 : mViewSource, nsHtml5Tokenizer::BOGUS_COMMENT, reconsume, pos);
2412 0 : NS_HTML5_BREAK(stateloop);
2413 : }
2414 : case '\n': {
2415 0 : appendStrBufLineFeed();
2416 0 : state = P::transition(
2417 : mViewSource, nsHtml5Tokenizer::BOGUS_COMMENT, reconsume, pos);
2418 0 : NS_HTML5_CONTINUE(stateloop);
2419 : }
2420 : case '\0': {
2421 0 : c = 0xfffd;
2422 : }
2423 : default: {
2424 0 : appendStrBuf(c);
2425 0 : state = P::transition(
2426 : mViewSource, nsHtml5Tokenizer::BOGUS_COMMENT, reconsume, pos);
2427 0 : NS_HTML5_CONTINUE(stateloop);
2428 : }
2429 : }
2430 : }
2431 :
2432 : }
2433 : case SCRIPT_DATA: {
2434 : for (; ; ) {
2435 3584 : if (reconsume) {
2436 3 : reconsume = false;
2437 : } else {
2438 1794 : if (++pos == endPos) {
2439 2 : NS_HTML5_BREAK(stateloop);
2440 : }
2441 1792 : c = checkChar(buf, pos);
2442 : }
2443 1795 : switch(c) {
2444 : case '<': {
2445 8 : flushChars(buf, pos);
2446 8 : returnState = state;
2447 8 : state =
2448 8 : P::transition(mViewSource,
2449 : nsHtml5Tokenizer::SCRIPT_DATA_LESS_THAN_SIGN,
2450 : reconsume,
2451 : pos);
2452 8 : NS_HTML5_BREAK(scriptdataloop);
2453 : }
2454 : case '\0': {
2455 0 : emitReplacementCharacter(buf, pos);
2456 0 : continue;
2457 : }
2458 : case '\r': {
2459 0 : emitCarriageReturn(buf, pos);
2460 0 : NS_HTML5_BREAK(stateloop);
2461 : }
2462 : case '\n': {
2463 62 : silentLineFeed();
2464 : }
2465 : default: {
2466 1787 : continue;
2467 : }
2468 : }
2469 : }
2470 : scriptdataloop_end: ;
2471 : }
2472 : case SCRIPT_DATA_LESS_THAN_SIGN: {
2473 : for (; ; ) {
2474 8 : if (++pos == endPos) {
2475 0 : NS_HTML5_BREAK(stateloop);
2476 : }
2477 8 : c = checkChar(buf, pos);
2478 8 : switch(c) {
2479 : case '/': {
2480 5 : index = 0;
2481 5 : clearStrBufBeforeUse();
2482 5 : state = P::transition(mViewSource,
2483 : nsHtml5Tokenizer::NON_DATA_END_TAG_NAME,
2484 : reconsume,
2485 : pos);
2486 5 : NS_HTML5_CONTINUE(stateloop);
2487 : }
2488 : case '!': {
2489 0 : tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
2490 0 : cstart = pos;
2491 0 : state = P::transition(mViewSource,
2492 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPE_START,
2493 : reconsume,
2494 : pos);
2495 0 : NS_HTML5_BREAK(scriptdatalessthansignloop);
2496 : }
2497 : default: {
2498 3 : tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
2499 3 : cstart = pos;
2500 3 : reconsume = true;
2501 3 : state = P::transition(
2502 : mViewSource, nsHtml5Tokenizer::SCRIPT_DATA, reconsume, pos);
2503 3 : NS_HTML5_CONTINUE(stateloop);
2504 : }
2505 : }
2506 : }
2507 : scriptdatalessthansignloop_end: ;
2508 : }
2509 : case SCRIPT_DATA_ESCAPE_START: {
2510 : for (; ; ) {
2511 0 : if (++pos == endPos) {
2512 0 : NS_HTML5_BREAK(stateloop);
2513 : }
2514 0 : c = checkChar(buf, pos);
2515 0 : switch(c) {
2516 : case '-': {
2517 0 : state =
2518 0 : P::transition(mViewSource,
2519 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPE_START_DASH,
2520 : reconsume,
2521 : pos);
2522 0 : NS_HTML5_BREAK(scriptdataescapestartloop);
2523 : }
2524 : default: {
2525 0 : reconsume = true;
2526 0 : state = P::transition(
2527 : mViewSource, nsHtml5Tokenizer::SCRIPT_DATA, reconsume, pos);
2528 0 : NS_HTML5_CONTINUE(stateloop);
2529 : }
2530 : }
2531 : }
2532 : scriptdataescapestartloop_end: ;
2533 : }
2534 : case SCRIPT_DATA_ESCAPE_START_DASH: {
2535 : for (; ; ) {
2536 0 : if (++pos == endPos) {
2537 0 : NS_HTML5_BREAK(stateloop);
2538 : }
2539 0 : c = checkChar(buf, pos);
2540 0 : switch(c) {
2541 : case '-': {
2542 0 : state =
2543 0 : P::transition(mViewSource,
2544 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_DASH_DASH,
2545 : reconsume,
2546 : pos);
2547 0 : NS_HTML5_BREAK(scriptdataescapestartdashloop);
2548 : }
2549 : default: {
2550 0 : reconsume = true;
2551 0 : state = P::transition(
2552 : mViewSource, nsHtml5Tokenizer::SCRIPT_DATA, reconsume, pos);
2553 0 : NS_HTML5_CONTINUE(stateloop);
2554 : }
2555 : }
2556 : }
2557 : scriptdataescapestartdashloop_end: ;
2558 : }
2559 : case SCRIPT_DATA_ESCAPED_DASH_DASH: {
2560 : for (; ; ) {
2561 0 : if (++pos == endPos) {
2562 0 : NS_HTML5_BREAK(stateloop);
2563 : }
2564 0 : c = checkChar(buf, pos);
2565 0 : switch(c) {
2566 : case '-': {
2567 0 : continue;
2568 : }
2569 : case '<': {
2570 0 : flushChars(buf, pos);
2571 0 : state = P::transition(
2572 : mViewSource,
2573 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN,
2574 : reconsume,
2575 : pos);
2576 0 : NS_HTML5_CONTINUE(stateloop);
2577 : }
2578 : case '>': {
2579 0 : state = P::transition(
2580 : mViewSource, nsHtml5Tokenizer::SCRIPT_DATA, reconsume, pos);
2581 0 : NS_HTML5_CONTINUE(stateloop);
2582 : }
2583 : case '\0': {
2584 0 : emitReplacementCharacter(buf, pos);
2585 0 : state = P::transition(mViewSource,
2586 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
2587 : reconsume,
2588 : pos);
2589 0 : NS_HTML5_BREAK(scriptdataescapeddashdashloop);
2590 : }
2591 : case '\r': {
2592 0 : emitCarriageReturn(buf, pos);
2593 0 : state = P::transition(mViewSource,
2594 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
2595 : reconsume,
2596 : pos);
2597 0 : NS_HTML5_BREAK(stateloop);
2598 : }
2599 : case '\n': {
2600 0 : silentLineFeed();
2601 : }
2602 : default: {
2603 0 : state = P::transition(mViewSource,
2604 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
2605 : reconsume,
2606 : pos);
2607 0 : NS_HTML5_BREAK(scriptdataescapeddashdashloop);
2608 : }
2609 : }
2610 : }
2611 : scriptdataescapeddashdashloop_end: ;
2612 : }
2613 : case SCRIPT_DATA_ESCAPED: {
2614 : for (; ; ) {
2615 0 : if (reconsume) {
2616 0 : reconsume = false;
2617 : } else {
2618 0 : if (++pos == endPos) {
2619 0 : NS_HTML5_BREAK(stateloop);
2620 : }
2621 0 : c = checkChar(buf, pos);
2622 : }
2623 0 : switch(c) {
2624 : case '-': {
2625 0 : state = P::transition(mViewSource,
2626 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_DASH,
2627 : reconsume,
2628 : pos);
2629 0 : NS_HTML5_BREAK(scriptdataescapedloop);
2630 : }
2631 : case '<': {
2632 0 : flushChars(buf, pos);
2633 0 : state = P::transition(
2634 : mViewSource,
2635 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN,
2636 : reconsume,
2637 : pos);
2638 0 : NS_HTML5_CONTINUE(stateloop);
2639 : }
2640 : case '\0': {
2641 0 : emitReplacementCharacter(buf, pos);
2642 0 : continue;
2643 : }
2644 : case '\r': {
2645 0 : emitCarriageReturn(buf, pos);
2646 0 : NS_HTML5_BREAK(stateloop);
2647 : }
2648 : case '\n': {
2649 0 : silentLineFeed();
2650 : }
2651 : default: {
2652 0 : continue;
2653 : }
2654 : }
2655 : }
2656 : scriptdataescapedloop_end: ;
2657 : }
2658 : case SCRIPT_DATA_ESCAPED_DASH: {
2659 : for (; ; ) {
2660 0 : if (++pos == endPos) {
2661 0 : NS_HTML5_BREAK(stateloop);
2662 : }
2663 0 : c = checkChar(buf, pos);
2664 0 : switch(c) {
2665 : case '-': {
2666 0 : state =
2667 0 : P::transition(mViewSource,
2668 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_DASH_DASH,
2669 : reconsume,
2670 : pos);
2671 0 : NS_HTML5_CONTINUE(stateloop);
2672 : }
2673 : case '<': {
2674 0 : flushChars(buf, pos);
2675 0 : state = P::transition(
2676 : mViewSource,
2677 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN,
2678 : reconsume,
2679 : pos);
2680 0 : NS_HTML5_BREAK(scriptdataescapeddashloop);
2681 : }
2682 : case '\0': {
2683 0 : emitReplacementCharacter(buf, pos);
2684 0 : state = P::transition(mViewSource,
2685 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
2686 : reconsume,
2687 : pos);
2688 0 : NS_HTML5_CONTINUE(stateloop);
2689 : }
2690 : case '\r': {
2691 0 : emitCarriageReturn(buf, pos);
2692 0 : state = P::transition(mViewSource,
2693 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
2694 : reconsume,
2695 : pos);
2696 0 : NS_HTML5_BREAK(stateloop);
2697 : }
2698 : case '\n': {
2699 0 : silentLineFeed();
2700 : }
2701 : default: {
2702 0 : state = P::transition(mViewSource,
2703 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
2704 : reconsume,
2705 : pos);
2706 0 : NS_HTML5_CONTINUE(stateloop);
2707 : }
2708 : }
2709 : }
2710 : scriptdataescapeddashloop_end: ;
2711 : }
2712 : case SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN: {
2713 : for (; ; ) {
2714 0 : if (++pos == endPos) {
2715 0 : NS_HTML5_BREAK(stateloop);
2716 : }
2717 0 : c = checkChar(buf, pos);
2718 0 : switch(c) {
2719 : case '/': {
2720 0 : index = 0;
2721 0 : clearStrBufBeforeUse();
2722 0 : returnState = nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED;
2723 0 : state = P::transition(mViewSource,
2724 : nsHtml5Tokenizer::NON_DATA_END_TAG_NAME,
2725 : reconsume,
2726 : pos);
2727 0 : NS_HTML5_CONTINUE(stateloop);
2728 : }
2729 : case 'S':
2730 : case 's': {
2731 0 : tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
2732 0 : cstart = pos;
2733 0 : index = 1;
2734 0 : state =
2735 0 : P::transition(mViewSource,
2736 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPE_START,
2737 : reconsume,
2738 : pos);
2739 0 : NS_HTML5_BREAK(scriptdataescapedlessthanloop);
2740 : }
2741 : default: {
2742 0 : tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
2743 0 : cstart = pos;
2744 0 : reconsume = true;
2745 0 : state = P::transition(mViewSource,
2746 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
2747 : reconsume,
2748 : pos);
2749 0 : NS_HTML5_CONTINUE(stateloop);
2750 : }
2751 : }
2752 : }
2753 : scriptdataescapedlessthanloop_end: ;
2754 : }
2755 : case SCRIPT_DATA_DOUBLE_ESCAPE_START: {
2756 0 : for (; ; ) {
2757 0 : if (++pos == endPos) {
2758 0 : NS_HTML5_BREAK(stateloop);
2759 : }
2760 0 : c = checkChar(buf, pos);
2761 0 : MOZ_ASSERT(index > 0);
2762 0 : if (index < 6) {
2763 0 : char16_t folded = c;
2764 0 : if (c >= 'A' && c <= 'Z') {
2765 0 : folded += 0x20;
2766 : }
2767 0 : if (folded != nsHtml5Tokenizer::SCRIPT_ARR[index]) {
2768 0 : reconsume = true;
2769 0 : state = P::transition(mViewSource,
2770 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
2771 : reconsume,
2772 : pos);
2773 0 : NS_HTML5_CONTINUE(stateloop);
2774 : }
2775 0 : index++;
2776 0 : continue;
2777 : }
2778 0 : switch(c) {
2779 : case '\r': {
2780 0 : emitCarriageReturn(buf, pos);
2781 0 : state =
2782 0 : P::transition(mViewSource,
2783 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED,
2784 : reconsume,
2785 : pos);
2786 0 : NS_HTML5_BREAK(stateloop);
2787 : }
2788 : case '\n': {
2789 0 : silentLineFeed();
2790 : }
2791 : case ' ':
2792 : case '\t':
2793 : case '\f':
2794 : case '/':
2795 : case '>': {
2796 0 : state =
2797 0 : P::transition(mViewSource,
2798 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED,
2799 : reconsume,
2800 : pos);
2801 0 : NS_HTML5_BREAK(scriptdatadoubleescapestartloop);
2802 : }
2803 : default: {
2804 0 : reconsume = true;
2805 0 : state = P::transition(mViewSource,
2806 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
2807 : reconsume,
2808 : pos);
2809 0 : NS_HTML5_CONTINUE(stateloop);
2810 : }
2811 : }
2812 : }
2813 : scriptdatadoubleescapestartloop_end: ;
2814 : }
2815 : case SCRIPT_DATA_DOUBLE_ESCAPED: {
2816 : for (; ; ) {
2817 0 : if (reconsume) {
2818 0 : reconsume = false;
2819 : } else {
2820 0 : if (++pos == endPos) {
2821 0 : NS_HTML5_BREAK(stateloop);
2822 : }
2823 0 : c = checkChar(buf, pos);
2824 : }
2825 0 : switch(c) {
2826 : case '-': {
2827 0 : state =
2828 0 : P::transition(mViewSource,
2829 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_DASH,
2830 : reconsume,
2831 : pos);
2832 0 : NS_HTML5_BREAK(scriptdatadoubleescapedloop);
2833 : }
2834 : case '<': {
2835 0 : state = P::transition(
2836 : mViewSource,
2837 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN,
2838 : reconsume,
2839 : pos);
2840 0 : NS_HTML5_CONTINUE(stateloop);
2841 : }
2842 : case '\0': {
2843 0 : emitReplacementCharacter(buf, pos);
2844 0 : continue;
2845 : }
2846 : case '\r': {
2847 0 : emitCarriageReturn(buf, pos);
2848 0 : NS_HTML5_BREAK(stateloop);
2849 : }
2850 : case '\n': {
2851 0 : silentLineFeed();
2852 : }
2853 : default: {
2854 0 : continue;
2855 : }
2856 : }
2857 : }
2858 : scriptdatadoubleescapedloop_end: ;
2859 : }
2860 : case SCRIPT_DATA_DOUBLE_ESCAPED_DASH: {
2861 : for (; ; ) {
2862 0 : if (++pos == endPos) {
2863 0 : NS_HTML5_BREAK(stateloop);
2864 : }
2865 0 : c = checkChar(buf, pos);
2866 0 : switch(c) {
2867 : case '-': {
2868 0 : state = P::transition(
2869 : mViewSource,
2870 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH,
2871 : reconsume,
2872 : pos);
2873 0 : NS_HTML5_BREAK(scriptdatadoubleescapeddashloop);
2874 : }
2875 : case '<': {
2876 0 : state = P::transition(
2877 : mViewSource,
2878 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN,
2879 : reconsume,
2880 : pos);
2881 0 : NS_HTML5_CONTINUE(stateloop);
2882 : }
2883 : case '\0': {
2884 0 : emitReplacementCharacter(buf, pos);
2885 0 : state =
2886 0 : P::transition(mViewSource,
2887 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED,
2888 : reconsume,
2889 : pos);
2890 0 : NS_HTML5_CONTINUE(stateloop);
2891 : }
2892 : case '\r': {
2893 0 : emitCarriageReturn(buf, pos);
2894 0 : state =
2895 0 : P::transition(mViewSource,
2896 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED,
2897 : reconsume,
2898 : pos);
2899 0 : NS_HTML5_BREAK(stateloop);
2900 : }
2901 : case '\n': {
2902 0 : silentLineFeed();
2903 : }
2904 : default: {
2905 0 : state =
2906 0 : P::transition(mViewSource,
2907 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED,
2908 : reconsume,
2909 : pos);
2910 0 : NS_HTML5_CONTINUE(stateloop);
2911 : }
2912 : }
2913 : }
2914 : scriptdatadoubleescapeddashloop_end: ;
2915 : }
2916 : case SCRIPT_DATA_DOUBLE_ESCAPED_DASH_DASH: {
2917 : for (; ; ) {
2918 0 : if (++pos == endPos) {
2919 0 : NS_HTML5_BREAK(stateloop);
2920 : }
2921 0 : c = checkChar(buf, pos);
2922 0 : switch(c) {
2923 : case '-': {
2924 0 : continue;
2925 : }
2926 : case '<': {
2927 0 : state = P::transition(
2928 : mViewSource,
2929 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN,
2930 : reconsume,
2931 : pos);
2932 0 : NS_HTML5_BREAK(scriptdatadoubleescapeddashdashloop);
2933 : }
2934 : case '>': {
2935 0 : state = P::transition(
2936 : mViewSource, nsHtml5Tokenizer::SCRIPT_DATA, reconsume, pos);
2937 0 : NS_HTML5_CONTINUE(stateloop);
2938 : }
2939 : case '\0': {
2940 0 : emitReplacementCharacter(buf, pos);
2941 0 : state =
2942 0 : P::transition(mViewSource,
2943 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED,
2944 : reconsume,
2945 : pos);
2946 0 : NS_HTML5_CONTINUE(stateloop);
2947 : }
2948 : case '\r': {
2949 0 : emitCarriageReturn(buf, pos);
2950 0 : state =
2951 0 : P::transition(mViewSource,
2952 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED,
2953 : reconsume,
2954 : pos);
2955 0 : NS_HTML5_BREAK(stateloop);
2956 : }
2957 : case '\n': {
2958 0 : silentLineFeed();
2959 : }
2960 : default: {
2961 0 : state =
2962 0 : P::transition(mViewSource,
2963 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED,
2964 : reconsume,
2965 : pos);
2966 0 : NS_HTML5_CONTINUE(stateloop);
2967 : }
2968 : }
2969 : }
2970 : scriptdatadoubleescapeddashdashloop_end: ;
2971 : }
2972 : case SCRIPT_DATA_DOUBLE_ESCAPED_LESS_THAN_SIGN: {
2973 : for (; ; ) {
2974 0 : if (++pos == endPos) {
2975 0 : NS_HTML5_BREAK(stateloop);
2976 : }
2977 0 : c = checkChar(buf, pos);
2978 0 : switch(c) {
2979 : case '/': {
2980 0 : index = 0;
2981 0 : state =
2982 0 : P::transition(mViewSource,
2983 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPE_END,
2984 : reconsume,
2985 : pos);
2986 0 : NS_HTML5_BREAK(scriptdatadoubleescapedlessthanloop);
2987 : }
2988 : default: {
2989 0 : reconsume = true;
2990 0 : state =
2991 0 : P::transition(mViewSource,
2992 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED,
2993 : reconsume,
2994 : pos);
2995 0 : NS_HTML5_CONTINUE(stateloop);
2996 : }
2997 : }
2998 : }
2999 : scriptdatadoubleescapedlessthanloop_end: ;
3000 : }
3001 : case SCRIPT_DATA_DOUBLE_ESCAPE_END: {
3002 0 : for (; ; ) {
3003 0 : if (++pos == endPos) {
3004 0 : NS_HTML5_BREAK(stateloop);
3005 : }
3006 0 : c = checkChar(buf, pos);
3007 0 : if (index < 6) {
3008 0 : char16_t folded = c;
3009 0 : if (c >= 'A' && c <= 'Z') {
3010 0 : folded += 0x20;
3011 : }
3012 0 : if (folded != nsHtml5Tokenizer::SCRIPT_ARR[index]) {
3013 0 : reconsume = true;
3014 0 : state =
3015 0 : P::transition(mViewSource,
3016 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED,
3017 : reconsume,
3018 : pos);
3019 0 : NS_HTML5_CONTINUE(stateloop);
3020 : }
3021 0 : index++;
3022 0 : continue;
3023 : }
3024 0 : switch(c) {
3025 : case '\r': {
3026 0 : emitCarriageReturn(buf, pos);
3027 0 : state = P::transition(mViewSource,
3028 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
3029 : reconsume,
3030 : pos);
3031 0 : NS_HTML5_BREAK(stateloop);
3032 : }
3033 : case '\n': {
3034 0 : silentLineFeed();
3035 : }
3036 : case ' ':
3037 : case '\t':
3038 : case '\f':
3039 : case '/':
3040 : case '>': {
3041 0 : state = P::transition(mViewSource,
3042 : nsHtml5Tokenizer::SCRIPT_DATA_ESCAPED,
3043 : reconsume,
3044 : pos);
3045 0 : NS_HTML5_CONTINUE(stateloop);
3046 : }
3047 : default: {
3048 0 : reconsume = true;
3049 0 : state =
3050 0 : P::transition(mViewSource,
3051 : nsHtml5Tokenizer::SCRIPT_DATA_DOUBLE_ESCAPED,
3052 : reconsume,
3053 : pos);
3054 0 : NS_HTML5_CONTINUE(stateloop);
3055 : }
3056 : }
3057 : }
3058 :
3059 : }
3060 : case MARKUP_DECLARATION_OCTYPE: {
3061 6 : for (; ; ) {
3062 7 : if (++pos == endPos) {
3063 0 : NS_HTML5_BREAK(stateloop);
3064 : }
3065 7 : c = checkChar(buf, pos);
3066 7 : if (index < 6) {
3067 6 : char16_t folded = c;
3068 6 : if (c >= 'A' && c <= 'Z') {
3069 6 : folded += 0x20;
3070 : }
3071 6 : if (folded == nsHtml5Tokenizer::OCTYPE[index]) {
3072 6 : appendStrBuf(c);
3073 : } else {
3074 : if (P::reportErrors) {
3075 0 : errBogusComment();
3076 : }
3077 0 : reconsume = true;
3078 0 : state = P::transition(
3079 : mViewSource, nsHtml5Tokenizer::BOGUS_COMMENT, reconsume, pos);
3080 0 : NS_HTML5_CONTINUE(stateloop);
3081 : }
3082 6 : index++;
3083 6 : continue;
3084 : } else {
3085 1 : reconsume = true;
3086 1 : state = P::transition(
3087 : mViewSource, nsHtml5Tokenizer::DOCTYPE, reconsume, pos);
3088 1 : NS_HTML5_BREAK(markupdeclarationdoctypeloop);
3089 : }
3090 : }
3091 : markupdeclarationdoctypeloop_end: ;
3092 : }
3093 : case DOCTYPE: {
3094 : for (; ; ) {
3095 1 : if (reconsume) {
3096 1 : reconsume = false;
3097 : } else {
3098 0 : if (++pos == endPos) {
3099 0 : NS_HTML5_BREAK(stateloop);
3100 : }
3101 0 : c = checkChar(buf, pos);
3102 : }
3103 1 : initDoctypeFields();
3104 1 : switch(c) {
3105 : case '\r': {
3106 0 : silentCarriageReturn();
3107 0 : state = P::transition(mViewSource,
3108 : nsHtml5Tokenizer::BEFORE_DOCTYPE_NAME,
3109 : reconsume,
3110 : pos);
3111 0 : NS_HTML5_BREAK(stateloop);
3112 : }
3113 : case '\n': {
3114 0 : silentLineFeed();
3115 : }
3116 : case ' ':
3117 : case '\t':
3118 : case '\f': {
3119 1 : state = P::transition(mViewSource,
3120 : nsHtml5Tokenizer::BEFORE_DOCTYPE_NAME,
3121 : reconsume,
3122 : pos);
3123 1 : NS_HTML5_BREAK(doctypeloop);
3124 : }
3125 : default: {
3126 : if (P::reportErrors) {
3127 0 : errMissingSpaceBeforeDoctypeName();
3128 : }
3129 0 : reconsume = true;
3130 0 : state = P::transition(mViewSource,
3131 : nsHtml5Tokenizer::BEFORE_DOCTYPE_NAME,
3132 : reconsume,
3133 : pos);
3134 0 : NS_HTML5_BREAK(doctypeloop);
3135 : }
3136 : }
3137 : }
3138 : doctypeloop_end: ;
3139 : }
3140 : case BEFORE_DOCTYPE_NAME: {
3141 : for (; ; ) {
3142 1 : if (reconsume) {
3143 0 : reconsume = false;
3144 : } else {
3145 1 : if (++pos == endPos) {
3146 0 : NS_HTML5_BREAK(stateloop);
3147 : }
3148 1 : c = checkChar(buf, pos);
3149 : }
3150 1 : switch(c) {
3151 : case '\r': {
3152 0 : silentCarriageReturn();
3153 0 : NS_HTML5_BREAK(stateloop);
3154 : }
3155 : case '\n': {
3156 0 : silentLineFeed();
3157 : }
3158 : case ' ':
3159 : case '\t':
3160 : case '\f': {
3161 0 : continue;
3162 : }
3163 : case '>': {
3164 : if (P::reportErrors) {
3165 0 : errNamelessDoctype();
3166 : }
3167 0 : forceQuirks = true;
3168 0 : emitDoctypeToken(pos);
3169 0 : state = P::transition(
3170 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3171 0 : NS_HTML5_CONTINUE(stateloop);
3172 : }
3173 : case '\0': {
3174 0 : c = 0xfffd;
3175 : }
3176 : default: {
3177 1 : if (c >= 'A' && c <= 'Z') {
3178 0 : c += 0x20;
3179 : }
3180 1 : clearStrBufBeforeUse();
3181 1 : appendStrBuf(c);
3182 1 : state = P::transition(
3183 : mViewSource, nsHtml5Tokenizer::DOCTYPE_NAME, reconsume, pos);
3184 1 : NS_HTML5_BREAK(beforedoctypenameloop);
3185 : }
3186 : }
3187 : }
3188 : beforedoctypenameloop_end: ;
3189 : }
3190 : case DOCTYPE_NAME: {
3191 : for (; ; ) {
3192 7 : if (++pos == endPos) {
3193 0 : NS_HTML5_BREAK(stateloop);
3194 : }
3195 4 : c = checkChar(buf, pos);
3196 4 : switch(c) {
3197 : case '\r': {
3198 0 : silentCarriageReturn();
3199 0 : strBufToDoctypeName();
3200 0 : state = P::transition(mViewSource,
3201 : nsHtml5Tokenizer::AFTER_DOCTYPE_NAME,
3202 : reconsume,
3203 : pos);
3204 0 : NS_HTML5_BREAK(stateloop);
3205 : }
3206 : case '\n': {
3207 0 : silentLineFeed();
3208 : }
3209 : case ' ':
3210 : case '\t':
3211 : case '\f': {
3212 1 : strBufToDoctypeName();
3213 1 : state = P::transition(mViewSource,
3214 : nsHtml5Tokenizer::AFTER_DOCTYPE_NAME,
3215 : reconsume,
3216 : pos);
3217 1 : NS_HTML5_BREAK(doctypenameloop);
3218 : }
3219 : case '>': {
3220 0 : strBufToDoctypeName();
3221 0 : emitDoctypeToken(pos);
3222 0 : state = P::transition(
3223 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3224 0 : NS_HTML5_CONTINUE(stateloop);
3225 : }
3226 : case '\0': {
3227 0 : c = 0xfffd;
3228 : }
3229 : default: {
3230 3 : if (c >= 'A' && c <= 'Z') {
3231 0 : c += 0x0020;
3232 : }
3233 3 : appendStrBuf(c);
3234 3 : continue;
3235 : }
3236 : }
3237 : }
3238 : doctypenameloop_end: ;
3239 : }
3240 : case AFTER_DOCTYPE_NAME: {
3241 : for (; ; ) {
3242 1 : if (++pos == endPos) {
3243 0 : NS_HTML5_BREAK(stateloop);
3244 : }
3245 1 : c = checkChar(buf, pos);
3246 1 : switch(c) {
3247 : case '\r': {
3248 0 : silentCarriageReturn();
3249 0 : NS_HTML5_BREAK(stateloop);
3250 : }
3251 : case '\n': {
3252 0 : silentLineFeed();
3253 : }
3254 : case ' ':
3255 : case '\t':
3256 : case '\f': {
3257 0 : continue;
3258 : }
3259 : case '>': {
3260 0 : emitDoctypeToken(pos);
3261 0 : state = P::transition(
3262 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3263 0 : NS_HTML5_CONTINUE(stateloop);
3264 : }
3265 : case 'p':
3266 : case 'P': {
3267 1 : index = 0;
3268 1 : state = P::transition(
3269 : mViewSource, nsHtml5Tokenizer::DOCTYPE_UBLIC, reconsume, pos);
3270 1 : NS_HTML5_BREAK(afterdoctypenameloop);
3271 : }
3272 : case 's':
3273 : case 'S': {
3274 0 : index = 0;
3275 0 : state = P::transition(
3276 : mViewSource, nsHtml5Tokenizer::DOCTYPE_YSTEM, reconsume, pos);
3277 0 : NS_HTML5_CONTINUE(stateloop);
3278 : }
3279 : default: {
3280 0 : bogusDoctype();
3281 0 : state = P::transition(
3282 : mViewSource, nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume, pos);
3283 0 : NS_HTML5_CONTINUE(stateloop);
3284 : }
3285 : }
3286 : }
3287 : afterdoctypenameloop_end: ;
3288 : }
3289 : case DOCTYPE_UBLIC: {
3290 5 : for (; ; ) {
3291 6 : if (++pos == endPos) {
3292 0 : NS_HTML5_BREAK(stateloop);
3293 : }
3294 6 : c = checkChar(buf, pos);
3295 6 : if (index < 5) {
3296 5 : char16_t folded = c;
3297 5 : if (c >= 'A' && c <= 'Z') {
3298 5 : folded += 0x20;
3299 : }
3300 5 : if (folded != nsHtml5Tokenizer::UBLIC[index]) {
3301 0 : bogusDoctype();
3302 0 : reconsume = true;
3303 0 : state = P::transition(
3304 : mViewSource, nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume, pos);
3305 0 : NS_HTML5_CONTINUE(stateloop);
3306 : }
3307 5 : index++;
3308 5 : continue;
3309 : } else {
3310 1 : reconsume = true;
3311 1 : state =
3312 1 : P::transition(mViewSource,
3313 : nsHtml5Tokenizer::AFTER_DOCTYPE_PUBLIC_KEYWORD,
3314 : reconsume,
3315 : pos);
3316 1 : NS_HTML5_BREAK(doctypeublicloop);
3317 : }
3318 : }
3319 : doctypeublicloop_end: ;
3320 : }
3321 : case AFTER_DOCTYPE_PUBLIC_KEYWORD: {
3322 : for (; ; ) {
3323 1 : if (reconsume) {
3324 1 : reconsume = false;
3325 : } else {
3326 0 : if (++pos == endPos) {
3327 0 : NS_HTML5_BREAK(stateloop);
3328 : }
3329 0 : c = checkChar(buf, pos);
3330 : }
3331 1 : switch(c) {
3332 : case '\r': {
3333 0 : silentCarriageReturn();
3334 0 : state = P::transition(
3335 : mViewSource,
3336 : nsHtml5Tokenizer::BEFORE_DOCTYPE_PUBLIC_IDENTIFIER,
3337 : reconsume,
3338 : pos);
3339 0 : NS_HTML5_BREAK(stateloop);
3340 : }
3341 : case '\n': {
3342 0 : silentLineFeed();
3343 : }
3344 : case ' ':
3345 : case '\t':
3346 : case '\f': {
3347 1 : state = P::transition(
3348 : mViewSource,
3349 : nsHtml5Tokenizer::BEFORE_DOCTYPE_PUBLIC_IDENTIFIER,
3350 : reconsume,
3351 : pos);
3352 1 : NS_HTML5_BREAK(afterdoctypepublickeywordloop);
3353 : }
3354 : case '\"': {
3355 : if (P::reportErrors) {
3356 0 : errNoSpaceBetweenDoctypePublicKeywordAndQuote();
3357 : }
3358 0 : clearStrBufBeforeUse();
3359 0 : state = P::transition(
3360 : mViewSource,
3361 : nsHtml5Tokenizer::DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED,
3362 : reconsume,
3363 : pos);
3364 0 : NS_HTML5_CONTINUE(stateloop);
3365 : }
3366 : case '\'': {
3367 : if (P::reportErrors) {
3368 0 : errNoSpaceBetweenDoctypePublicKeywordAndQuote();
3369 : }
3370 0 : clearStrBufBeforeUse();
3371 0 : state = P::transition(
3372 : mViewSource,
3373 : nsHtml5Tokenizer::DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED,
3374 : reconsume,
3375 : pos);
3376 0 : NS_HTML5_CONTINUE(stateloop);
3377 : }
3378 : case '>': {
3379 : if (P::reportErrors) {
3380 0 : errExpectedPublicId();
3381 : }
3382 0 : forceQuirks = true;
3383 0 : emitDoctypeToken(pos);
3384 0 : state = P::transition(
3385 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3386 0 : NS_HTML5_CONTINUE(stateloop);
3387 : }
3388 : default: {
3389 0 : bogusDoctype();
3390 0 : state = P::transition(
3391 : mViewSource, nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume, pos);
3392 0 : NS_HTML5_CONTINUE(stateloop);
3393 : }
3394 : }
3395 : }
3396 : afterdoctypepublickeywordloop_end: ;
3397 : }
3398 : case BEFORE_DOCTYPE_PUBLIC_IDENTIFIER: {
3399 : for (; ; ) {
3400 1 : if (++pos == endPos) {
3401 0 : NS_HTML5_BREAK(stateloop);
3402 : }
3403 1 : c = checkChar(buf, pos);
3404 1 : switch(c) {
3405 : case '\r': {
3406 0 : silentCarriageReturn();
3407 0 : NS_HTML5_BREAK(stateloop);
3408 : }
3409 : case '\n': {
3410 0 : silentLineFeed();
3411 : }
3412 : case ' ':
3413 : case '\t':
3414 : case '\f': {
3415 0 : continue;
3416 : }
3417 : case '\"': {
3418 1 : clearStrBufBeforeUse();
3419 1 : state = P::transition(
3420 : mViewSource,
3421 : nsHtml5Tokenizer::DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED,
3422 : reconsume,
3423 : pos);
3424 1 : NS_HTML5_BREAK(beforedoctypepublicidentifierloop);
3425 : }
3426 : case '\'': {
3427 0 : clearStrBufBeforeUse();
3428 0 : state = P::transition(
3429 : mViewSource,
3430 : nsHtml5Tokenizer::DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED,
3431 : reconsume,
3432 : pos);
3433 0 : NS_HTML5_CONTINUE(stateloop);
3434 : }
3435 : case '>': {
3436 : if (P::reportErrors) {
3437 0 : errExpectedPublicId();
3438 : }
3439 0 : forceQuirks = true;
3440 0 : emitDoctypeToken(pos);
3441 0 : state = P::transition(
3442 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3443 0 : NS_HTML5_CONTINUE(stateloop);
3444 : }
3445 : default: {
3446 0 : bogusDoctype();
3447 0 : state = P::transition(
3448 : mViewSource, nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume, pos);
3449 0 : NS_HTML5_CONTINUE(stateloop);
3450 : }
3451 : }
3452 : }
3453 : beforedoctypepublicidentifierloop_end: ;
3454 : }
3455 : case DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED: {
3456 : for (; ; ) {
3457 77 : if (++pos == endPos) {
3458 0 : NS_HTML5_BREAK(stateloop);
3459 : }
3460 39 : c = checkChar(buf, pos);
3461 39 : switch(c) {
3462 : case '\"': {
3463 1 : publicIdentifier = strBufToString();
3464 1 : state =
3465 1 : P::transition(mViewSource,
3466 : nsHtml5Tokenizer::AFTER_DOCTYPE_PUBLIC_IDENTIFIER,
3467 : reconsume,
3468 : pos);
3469 1 : NS_HTML5_BREAK(doctypepublicidentifierdoublequotedloop);
3470 : }
3471 : case '>': {
3472 : if (P::reportErrors) {
3473 0 : errGtInPublicId();
3474 : }
3475 0 : forceQuirks = true;
3476 0 : publicIdentifier = strBufToString();
3477 0 : emitDoctypeToken(pos);
3478 0 : state = P::transition(
3479 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3480 0 : NS_HTML5_CONTINUE(stateloop);
3481 : }
3482 : case '\r': {
3483 0 : appendStrBufCarriageReturn();
3484 0 : NS_HTML5_BREAK(stateloop);
3485 : }
3486 : case '\n': {
3487 0 : appendStrBufLineFeed();
3488 0 : continue;
3489 : }
3490 : case '\0': {
3491 0 : c = 0xfffd;
3492 : }
3493 : default: {
3494 38 : appendStrBuf(c);
3495 38 : continue;
3496 : }
3497 : }
3498 : }
3499 : doctypepublicidentifierdoublequotedloop_end: ;
3500 : }
3501 : case AFTER_DOCTYPE_PUBLIC_IDENTIFIER: {
3502 : for (; ; ) {
3503 1 : if (++pos == endPos) {
3504 0 : NS_HTML5_BREAK(stateloop);
3505 : }
3506 1 : c = checkChar(buf, pos);
3507 1 : switch(c) {
3508 : case '\r': {
3509 0 : silentCarriageReturn();
3510 0 : state = P::transition(
3511 : mViewSource,
3512 : nsHtml5Tokenizer::BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS,
3513 : reconsume,
3514 : pos);
3515 0 : NS_HTML5_BREAK(stateloop);
3516 : }
3517 : case '\n': {
3518 0 : silentLineFeed();
3519 : }
3520 : case ' ':
3521 : case '\t':
3522 : case '\f': {
3523 0 : state = P::transition(
3524 : mViewSource,
3525 : nsHtml5Tokenizer::BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS,
3526 : reconsume,
3527 : pos);
3528 0 : NS_HTML5_BREAK(afterdoctypepublicidentifierloop);
3529 : }
3530 : case '>': {
3531 1 : emitDoctypeToken(pos);
3532 1 : state = P::transition(
3533 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3534 1 : NS_HTML5_CONTINUE(stateloop);
3535 : }
3536 : case '\"': {
3537 : if (P::reportErrors) {
3538 0 : errNoSpaceBetweenPublicAndSystemIds();
3539 : }
3540 0 : clearStrBufBeforeUse();
3541 0 : state = P::transition(
3542 : mViewSource,
3543 : nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED,
3544 : reconsume,
3545 : pos);
3546 0 : NS_HTML5_CONTINUE(stateloop);
3547 : }
3548 : case '\'': {
3549 : if (P::reportErrors) {
3550 0 : errNoSpaceBetweenPublicAndSystemIds();
3551 : }
3552 0 : clearStrBufBeforeUse();
3553 0 : state = P::transition(
3554 : mViewSource,
3555 : nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED,
3556 : reconsume,
3557 : pos);
3558 0 : NS_HTML5_CONTINUE(stateloop);
3559 : }
3560 : default: {
3561 0 : bogusDoctype();
3562 0 : state = P::transition(
3563 : mViewSource, nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume, pos);
3564 0 : NS_HTML5_CONTINUE(stateloop);
3565 : }
3566 : }
3567 : }
3568 : afterdoctypepublicidentifierloop_end: ;
3569 : }
3570 : case BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS: {
3571 : for (; ; ) {
3572 0 : if (++pos == endPos) {
3573 0 : NS_HTML5_BREAK(stateloop);
3574 : }
3575 0 : c = checkChar(buf, pos);
3576 0 : switch(c) {
3577 : case '\r': {
3578 0 : silentCarriageReturn();
3579 0 : NS_HTML5_BREAK(stateloop);
3580 : }
3581 : case '\n': {
3582 0 : silentLineFeed();
3583 : }
3584 : case ' ':
3585 : case '\t':
3586 : case '\f': {
3587 0 : continue;
3588 : }
3589 : case '>': {
3590 0 : emitDoctypeToken(pos);
3591 0 : state = P::transition(
3592 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3593 0 : NS_HTML5_CONTINUE(stateloop);
3594 : }
3595 : case '\"': {
3596 0 : clearStrBufBeforeUse();
3597 0 : state = P::transition(
3598 : mViewSource,
3599 : nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED,
3600 : reconsume,
3601 : pos);
3602 0 : NS_HTML5_BREAK(betweendoctypepublicandsystemidentifiersloop);
3603 : }
3604 : case '\'': {
3605 0 : clearStrBufBeforeUse();
3606 0 : state = P::transition(
3607 : mViewSource,
3608 : nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED,
3609 : reconsume,
3610 : pos);
3611 0 : NS_HTML5_CONTINUE(stateloop);
3612 : }
3613 : default: {
3614 0 : bogusDoctype();
3615 0 : state = P::transition(
3616 : mViewSource, nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume, pos);
3617 0 : NS_HTML5_CONTINUE(stateloop);
3618 : }
3619 : }
3620 : }
3621 : betweendoctypepublicandsystemidentifiersloop_end: ;
3622 : }
3623 : case DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED: {
3624 : for (; ; ) {
3625 0 : if (++pos == endPos) {
3626 0 : NS_HTML5_BREAK(stateloop);
3627 : }
3628 0 : c = checkChar(buf, pos);
3629 0 : switch(c) {
3630 : case '\"': {
3631 0 : systemIdentifier = strBufToString();
3632 0 : state =
3633 0 : P::transition(mViewSource,
3634 : nsHtml5Tokenizer::AFTER_DOCTYPE_SYSTEM_IDENTIFIER,
3635 : reconsume,
3636 : pos);
3637 0 : NS_HTML5_CONTINUE(stateloop);
3638 : }
3639 : case '>': {
3640 : if (P::reportErrors) {
3641 0 : errGtInSystemId();
3642 : }
3643 0 : forceQuirks = true;
3644 0 : systemIdentifier = strBufToString();
3645 0 : emitDoctypeToken(pos);
3646 0 : state = P::transition(
3647 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3648 0 : NS_HTML5_CONTINUE(stateloop);
3649 : }
3650 : case '\r': {
3651 0 : appendStrBufCarriageReturn();
3652 0 : NS_HTML5_BREAK(stateloop);
3653 : }
3654 : case '\n': {
3655 0 : appendStrBufLineFeed();
3656 0 : continue;
3657 : }
3658 : case '\0': {
3659 0 : c = 0xfffd;
3660 : }
3661 : default: {
3662 0 : appendStrBuf(c);
3663 0 : continue;
3664 : }
3665 : }
3666 : }
3667 :
3668 : }
3669 : case AFTER_DOCTYPE_SYSTEM_IDENTIFIER: {
3670 : for (; ; ) {
3671 0 : if (++pos == endPos) {
3672 0 : NS_HTML5_BREAK(stateloop);
3673 : }
3674 0 : c = checkChar(buf, pos);
3675 0 : switch(c) {
3676 : case '\r': {
3677 0 : silentCarriageReturn();
3678 0 : NS_HTML5_BREAK(stateloop);
3679 : }
3680 : case '\n': {
3681 0 : silentLineFeed();
3682 : }
3683 : case ' ':
3684 : case '\t':
3685 : case '\f': {
3686 0 : continue;
3687 : }
3688 : case '>': {
3689 0 : emitDoctypeToken(pos);
3690 0 : state = P::transition(
3691 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3692 0 : NS_HTML5_CONTINUE(stateloop);
3693 : }
3694 : default: {
3695 0 : bogusDoctypeWithoutQuirks();
3696 0 : state = P::transition(
3697 : mViewSource, nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume, pos);
3698 0 : NS_HTML5_BREAK(afterdoctypesystemidentifierloop);
3699 : }
3700 : }
3701 : }
3702 : afterdoctypesystemidentifierloop_end: ;
3703 : }
3704 : case BOGUS_DOCTYPE: {
3705 : for (; ; ) {
3706 0 : if (reconsume) {
3707 0 : reconsume = false;
3708 : } else {
3709 0 : if (++pos == endPos) {
3710 0 : NS_HTML5_BREAK(stateloop);
3711 : }
3712 0 : c = checkChar(buf, pos);
3713 : }
3714 0 : switch(c) {
3715 : case '>': {
3716 0 : emitDoctypeToken(pos);
3717 0 : state = P::transition(
3718 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3719 0 : NS_HTML5_CONTINUE(stateloop);
3720 : }
3721 : case '\r': {
3722 0 : silentCarriageReturn();
3723 0 : NS_HTML5_BREAK(stateloop);
3724 : }
3725 : case '\n': {
3726 0 : silentLineFeed();
3727 : }
3728 : default: {
3729 0 : continue;
3730 : }
3731 : }
3732 : }
3733 : }
3734 : case DOCTYPE_YSTEM: {
3735 : for (; ; ) {
3736 0 : if (++pos == endPos) {
3737 0 : NS_HTML5_BREAK(stateloop);
3738 : }
3739 0 : c = checkChar(buf, pos);
3740 0 : if (index < 5) {
3741 0 : char16_t folded = c;
3742 0 : if (c >= 'A' && c <= 'Z') {
3743 0 : folded += 0x20;
3744 : }
3745 0 : if (folded != nsHtml5Tokenizer::YSTEM[index]) {
3746 0 : bogusDoctype();
3747 0 : reconsume = true;
3748 0 : state = P::transition(
3749 : mViewSource, nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume, pos);
3750 0 : NS_HTML5_CONTINUE(stateloop);
3751 : }
3752 0 : index++;
3753 0 : NS_HTML5_CONTINUE(stateloop);
3754 : } else {
3755 0 : reconsume = true;
3756 0 : state =
3757 0 : P::transition(mViewSource,
3758 : nsHtml5Tokenizer::AFTER_DOCTYPE_SYSTEM_KEYWORD,
3759 : reconsume,
3760 : pos);
3761 0 : NS_HTML5_BREAK(doctypeystemloop);
3762 : }
3763 : }
3764 : doctypeystemloop_end: ;
3765 : }
3766 : case AFTER_DOCTYPE_SYSTEM_KEYWORD: {
3767 : for (; ; ) {
3768 0 : if (reconsume) {
3769 0 : reconsume = false;
3770 : } else {
3771 0 : if (++pos == endPos) {
3772 0 : NS_HTML5_BREAK(stateloop);
3773 : }
3774 0 : c = checkChar(buf, pos);
3775 : }
3776 0 : switch(c) {
3777 : case '\r': {
3778 0 : silentCarriageReturn();
3779 0 : state = P::transition(
3780 : mViewSource,
3781 : nsHtml5Tokenizer::BEFORE_DOCTYPE_SYSTEM_IDENTIFIER,
3782 : reconsume,
3783 : pos);
3784 0 : NS_HTML5_BREAK(stateloop);
3785 : }
3786 : case '\n': {
3787 0 : silentLineFeed();
3788 : }
3789 : case ' ':
3790 : case '\t':
3791 : case '\f': {
3792 0 : state = P::transition(
3793 : mViewSource,
3794 : nsHtml5Tokenizer::BEFORE_DOCTYPE_SYSTEM_IDENTIFIER,
3795 : reconsume,
3796 : pos);
3797 0 : NS_HTML5_BREAK(afterdoctypesystemkeywordloop);
3798 : }
3799 : case '\"': {
3800 : if (P::reportErrors) {
3801 0 : errNoSpaceBetweenDoctypeSystemKeywordAndQuote();
3802 : }
3803 0 : clearStrBufBeforeUse();
3804 0 : state = P::transition(
3805 : mViewSource,
3806 : nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED,
3807 : reconsume,
3808 : pos);
3809 0 : NS_HTML5_CONTINUE(stateloop);
3810 : }
3811 : case '\'': {
3812 : if (P::reportErrors) {
3813 0 : errNoSpaceBetweenDoctypeSystemKeywordAndQuote();
3814 : }
3815 0 : clearStrBufBeforeUse();
3816 0 : state = P::transition(
3817 : mViewSource,
3818 : nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED,
3819 : reconsume,
3820 : pos);
3821 0 : NS_HTML5_CONTINUE(stateloop);
3822 : }
3823 : case '>': {
3824 : if (P::reportErrors) {
3825 0 : errExpectedPublicId();
3826 : }
3827 0 : forceQuirks = true;
3828 0 : emitDoctypeToken(pos);
3829 0 : state = P::transition(
3830 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3831 0 : NS_HTML5_CONTINUE(stateloop);
3832 : }
3833 : default: {
3834 0 : bogusDoctype();
3835 0 : state = P::transition(
3836 : mViewSource, nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume, pos);
3837 0 : NS_HTML5_CONTINUE(stateloop);
3838 : }
3839 : }
3840 : }
3841 : afterdoctypesystemkeywordloop_end: ;
3842 : }
3843 : case BEFORE_DOCTYPE_SYSTEM_IDENTIFIER: {
3844 : for (; ; ) {
3845 0 : if (++pos == endPos) {
3846 0 : NS_HTML5_BREAK(stateloop);
3847 : }
3848 0 : c = checkChar(buf, pos);
3849 0 : switch(c) {
3850 : case '\r': {
3851 0 : silentCarriageReturn();
3852 0 : NS_HTML5_BREAK(stateloop);
3853 : }
3854 : case '\n': {
3855 0 : silentLineFeed();
3856 : }
3857 : case ' ':
3858 : case '\t':
3859 : case '\f': {
3860 0 : continue;
3861 : }
3862 : case '\"': {
3863 0 : clearStrBufBeforeUse();
3864 0 : state = P::transition(
3865 : mViewSource,
3866 : nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED,
3867 : reconsume,
3868 : pos);
3869 0 : NS_HTML5_CONTINUE(stateloop);
3870 : }
3871 : case '\'': {
3872 0 : clearStrBufBeforeUse();
3873 0 : state = P::transition(
3874 : mViewSource,
3875 : nsHtml5Tokenizer::DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED,
3876 : reconsume,
3877 : pos);
3878 0 : NS_HTML5_BREAK(beforedoctypesystemidentifierloop);
3879 : }
3880 : case '>': {
3881 : if (P::reportErrors) {
3882 0 : errExpectedSystemId();
3883 : }
3884 0 : forceQuirks = true;
3885 0 : emitDoctypeToken(pos);
3886 0 : state = P::transition(
3887 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3888 0 : NS_HTML5_CONTINUE(stateloop);
3889 : }
3890 : default: {
3891 0 : bogusDoctype();
3892 0 : state = P::transition(
3893 : mViewSource, nsHtml5Tokenizer::BOGUS_DOCTYPE, reconsume, pos);
3894 0 : NS_HTML5_CONTINUE(stateloop);
3895 : }
3896 : }
3897 : }
3898 : beforedoctypesystemidentifierloop_end: ;
3899 : }
3900 : case DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED: {
3901 : for (; ; ) {
3902 0 : if (++pos == endPos) {
3903 0 : NS_HTML5_BREAK(stateloop);
3904 : }
3905 0 : c = checkChar(buf, pos);
3906 0 : switch(c) {
3907 : case '\'': {
3908 0 : systemIdentifier = strBufToString();
3909 0 : state =
3910 0 : P::transition(mViewSource,
3911 : nsHtml5Tokenizer::AFTER_DOCTYPE_SYSTEM_IDENTIFIER,
3912 : reconsume,
3913 : pos);
3914 0 : NS_HTML5_CONTINUE(stateloop);
3915 : }
3916 : case '>': {
3917 : if (P::reportErrors) {
3918 0 : errGtInSystemId();
3919 : }
3920 0 : forceQuirks = true;
3921 0 : systemIdentifier = strBufToString();
3922 0 : emitDoctypeToken(pos);
3923 0 : state = P::transition(
3924 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3925 0 : NS_HTML5_CONTINUE(stateloop);
3926 : }
3927 : case '\r': {
3928 0 : appendStrBufCarriageReturn();
3929 0 : NS_HTML5_BREAK(stateloop);
3930 : }
3931 : case '\n': {
3932 0 : appendStrBufLineFeed();
3933 0 : continue;
3934 : }
3935 : case '\0': {
3936 0 : c = 0xfffd;
3937 : }
3938 : default: {
3939 0 : appendStrBuf(c);
3940 0 : continue;
3941 : }
3942 : }
3943 : }
3944 : }
3945 : case DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED: {
3946 : for (; ; ) {
3947 0 : if (++pos == endPos) {
3948 0 : NS_HTML5_BREAK(stateloop);
3949 : }
3950 0 : c = checkChar(buf, pos);
3951 0 : switch(c) {
3952 : case '\'': {
3953 0 : publicIdentifier = strBufToString();
3954 0 : state =
3955 0 : P::transition(mViewSource,
3956 : nsHtml5Tokenizer::AFTER_DOCTYPE_PUBLIC_IDENTIFIER,
3957 : reconsume,
3958 : pos);
3959 0 : NS_HTML5_CONTINUE(stateloop);
3960 : }
3961 : case '>': {
3962 : if (P::reportErrors) {
3963 0 : errGtInPublicId();
3964 : }
3965 0 : forceQuirks = true;
3966 0 : publicIdentifier = strBufToString();
3967 0 : emitDoctypeToken(pos);
3968 0 : state = P::transition(
3969 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
3970 0 : NS_HTML5_CONTINUE(stateloop);
3971 : }
3972 : case '\r': {
3973 0 : appendStrBufCarriageReturn();
3974 0 : NS_HTML5_BREAK(stateloop);
3975 : }
3976 : case '\n': {
3977 0 : appendStrBufLineFeed();
3978 0 : continue;
3979 : }
3980 : case '\0': {
3981 0 : c = 0xfffd;
3982 : }
3983 : default: {
3984 0 : appendStrBuf(c);
3985 0 : continue;
3986 : }
3987 : }
3988 : }
3989 : }
3990 : case PROCESSING_INSTRUCTION: {
3991 : for (; ; ) {
3992 0 : if (++pos == endPos) {
3993 0 : NS_HTML5_BREAK(stateloop);
3994 : }
3995 0 : c = checkChar(buf, pos);
3996 0 : switch(c) {
3997 : case '\?': {
3998 0 : state = P::transition(
3999 : mViewSource,
4000 : nsHtml5Tokenizer::PROCESSING_INSTRUCTION_QUESTION_MARK,
4001 : reconsume,
4002 : pos);
4003 0 : NS_HTML5_BREAK(processinginstructionloop);
4004 : }
4005 : default: {
4006 0 : continue;
4007 : }
4008 : }
4009 : }
4010 : processinginstructionloop_end: ;
4011 : }
4012 : case PROCESSING_INSTRUCTION_QUESTION_MARK: {
4013 0 : if (++pos == endPos) {
4014 0 : NS_HTML5_BREAK(stateloop);
4015 : }
4016 0 : c = checkChar(buf, pos);
4017 0 : switch(c) {
4018 : case '>': {
4019 0 : state = P::transition(
4020 : mViewSource, nsHtml5Tokenizer::DATA, reconsume, pos);
4021 0 : NS_HTML5_CONTINUE(stateloop);
4022 : }
4023 : default: {
4024 0 : state = P::transition(mViewSource,
4025 : nsHtml5Tokenizer::PROCESSING_INSTRUCTION,
4026 : reconsume,
4027 : pos);
4028 0 : NS_HTML5_CONTINUE(stateloop);
4029 : }
4030 : }
4031 : }
4032 : }
4033 : }
4034 : stateloop_end: ;
4035 9 : flushChars(buf, pos);
4036 9 : stateSave = state;
4037 9 : returnStateSave = returnState;
4038 9 : return pos;
4039 : }
4040 :
4041 : void
4042 10 : nsHtml5Tokenizer::initDoctypeFields()
4043 : {
4044 10 : clearStrBufAfterUse();
4045 10 : doctypeName = nsGkAtoms::_empty;
4046 10 : if (systemIdentifier) {
4047 0 : systemIdentifier.Release();
4048 0 : systemIdentifier = nullptr;
4049 : }
4050 10 : if (publicIdentifier) {
4051 0 : publicIdentifier.Release();
4052 0 : publicIdentifier = nullptr;
4053 : }
4054 10 : forceQuirks = false;
4055 10 : }
4056 :
4057 : void
4058 0 : nsHtml5Tokenizer::emitCarriageReturn(char16_t* buf, int32_t pos)
4059 : {
4060 0 : silentCarriageReturn();
4061 0 : flushChars(buf, pos);
4062 0 : tokenHandler->characters(nsHtml5Tokenizer::LF, 0, 1);
4063 0 : cstart = INT32_MAX;
4064 0 : }
4065 :
4066 : void
4067 0 : nsHtml5Tokenizer::emitReplacementCharacter(char16_t* buf, int32_t pos)
4068 : {
4069 0 : flushChars(buf, pos);
4070 0 : tokenHandler->zeroOriginatingReplacementCharacter();
4071 0 : cstart = pos + 1;
4072 0 : }
4073 :
4074 : void
4075 0 : nsHtml5Tokenizer::emitPlaintextReplacementCharacter(char16_t* buf, int32_t pos)
4076 : {
4077 0 : flushChars(buf, pos);
4078 0 : tokenHandler->characters(REPLACEMENT_CHARACTER, 0, 1);
4079 0 : cstart = pos + 1;
4080 0 : }
4081 :
4082 : void
4083 0 : nsHtml5Tokenizer::setAdditionalAndRememberAmpersandLocation(char16_t add)
4084 : {
4085 0 : additional = add;
4086 0 : }
4087 :
4088 : void
4089 0 : nsHtml5Tokenizer::bogusDoctype()
4090 : {
4091 0 : errBogusDoctype();
4092 0 : forceQuirks = true;
4093 0 : }
4094 :
4095 : void
4096 0 : nsHtml5Tokenizer::bogusDoctypeWithoutQuirks()
4097 : {
4098 0 : errBogusDoctype();
4099 0 : forceQuirks = false;
4100 0 : }
4101 :
4102 : void
4103 0 : nsHtml5Tokenizer::handleNcrValue(int32_t returnState)
4104 : {
4105 0 : if (value <= 0xFFFF) {
4106 0 : if (value >= 0x80 && value <= 0x9f) {
4107 0 : errNcrInC1Range();
4108 0 : char16_t* val = nsHtml5NamedCharacters::WINDOWS_1252[value - 0x80];
4109 0 : emitOrAppendOne(val, returnState);
4110 0 : } else if (value == 0x0) {
4111 0 : errNcrZero();
4112 0 : emitOrAppendOne(nsHtml5Tokenizer::REPLACEMENT_CHARACTER, returnState);
4113 0 : } else if ((value & 0xF800) == 0xD800) {
4114 0 : errNcrSurrogate();
4115 0 : emitOrAppendOne(nsHtml5Tokenizer::REPLACEMENT_CHARACTER, returnState);
4116 : } else {
4117 0 : char16_t ch = (char16_t) value;
4118 0 : bmpChar[0] = ch;
4119 0 : emitOrAppendOne(bmpChar, returnState);
4120 : }
4121 0 : } else if (value <= 0x10FFFF) {
4122 0 : astralChar[0] = (char16_t)(nsHtml5Tokenizer::LEAD_OFFSET + (value >> 10));
4123 0 : astralChar[1] = (char16_t) (0xDC00 + (value & 0x3FF));
4124 0 : emitOrAppendTwo(astralChar, returnState);
4125 : } else {
4126 0 : errNcrOutOfRange();
4127 0 : emitOrAppendOne(nsHtml5Tokenizer::REPLACEMENT_CHARACTER, returnState);
4128 : }
4129 0 : }
4130 :
4131 : void
4132 2 : nsHtml5Tokenizer::eof()
4133 : {
4134 2 : int32_t state = stateSave;
4135 2 : int32_t returnState = returnStateSave;
4136 : eofloop: for (; ; ) {
4137 2 : switch(state) {
4138 : case SCRIPT_DATA_LESS_THAN_SIGN:
4139 : case SCRIPT_DATA_ESCAPED_LESS_THAN_SIGN: {
4140 0 : tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
4141 0 : NS_HTML5_BREAK(eofloop);
4142 : }
4143 : case TAG_OPEN: {
4144 0 : errEofAfterLt();
4145 0 : tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
4146 0 : NS_HTML5_BREAK(eofloop);
4147 : }
4148 : case RAWTEXT_RCDATA_LESS_THAN_SIGN: {
4149 0 : tokenHandler->characters(nsHtml5Tokenizer::LT_GT, 0, 1);
4150 0 : NS_HTML5_BREAK(eofloop);
4151 : }
4152 : case NON_DATA_END_TAG_NAME: {
4153 0 : tokenHandler->characters(nsHtml5Tokenizer::LT_SOLIDUS, 0, 2);
4154 0 : emitStrBuf();
4155 0 : NS_HTML5_BREAK(eofloop);
4156 : }
4157 : case CLOSE_TAG_OPEN: {
4158 0 : errEofAfterLt();
4159 0 : tokenHandler->characters(nsHtml5Tokenizer::LT_SOLIDUS, 0, 2);
4160 0 : NS_HTML5_BREAK(eofloop);
4161 : }
4162 : case TAG_NAME: {
4163 0 : errEofInTagName();
4164 0 : NS_HTML5_BREAK(eofloop);
4165 : }
4166 : case BEFORE_ATTRIBUTE_NAME:
4167 : case AFTER_ATTRIBUTE_VALUE_QUOTED:
4168 : case SELF_CLOSING_START_TAG: {
4169 0 : errEofWithoutGt();
4170 0 : NS_HTML5_BREAK(eofloop);
4171 : }
4172 : case ATTRIBUTE_NAME: {
4173 0 : errEofInAttributeName();
4174 0 : NS_HTML5_BREAK(eofloop);
4175 : }
4176 : case AFTER_ATTRIBUTE_NAME:
4177 : case BEFORE_ATTRIBUTE_VALUE: {
4178 0 : errEofWithoutGt();
4179 0 : NS_HTML5_BREAK(eofloop);
4180 : }
4181 : case ATTRIBUTE_VALUE_DOUBLE_QUOTED:
4182 : case ATTRIBUTE_VALUE_SINGLE_QUOTED:
4183 : case ATTRIBUTE_VALUE_UNQUOTED: {
4184 0 : errEofInAttributeValue();
4185 0 : NS_HTML5_BREAK(eofloop);
4186 : }
4187 : case BOGUS_COMMENT: {
4188 0 : emitComment(0, 0);
4189 0 : NS_HTML5_BREAK(eofloop);
4190 : }
4191 : case BOGUS_COMMENT_HYPHEN: {
4192 0 : emitComment(0, 0);
4193 0 : NS_HTML5_BREAK(eofloop);
4194 : }
4195 : case MARKUP_DECLARATION_OPEN: {
4196 0 : errBogusComment();
4197 0 : emitComment(0, 0);
4198 0 : NS_HTML5_BREAK(eofloop);
4199 : }
4200 : case MARKUP_DECLARATION_HYPHEN: {
4201 0 : errBogusComment();
4202 0 : emitComment(0, 0);
4203 0 : NS_HTML5_BREAK(eofloop);
4204 : }
4205 : case MARKUP_DECLARATION_OCTYPE: {
4206 0 : if (index < 6) {
4207 0 : errBogusComment();
4208 0 : emitComment(0, 0);
4209 : } else {
4210 0 : errEofInDoctype();
4211 0 : doctypeName = nsGkAtoms::_empty;
4212 0 : if (systemIdentifier) {
4213 0 : systemIdentifier.Release();
4214 0 : systemIdentifier = nullptr;
4215 : }
4216 0 : if (publicIdentifier) {
4217 0 : publicIdentifier.Release();
4218 0 : publicIdentifier = nullptr;
4219 : }
4220 0 : forceQuirks = true;
4221 0 : emitDoctypeToken(0);
4222 0 : NS_HTML5_BREAK(eofloop);
4223 : }
4224 0 : NS_HTML5_BREAK(eofloop);
4225 : }
4226 : case COMMENT_START:
4227 : case COMMENT: {
4228 0 : errEofInComment();
4229 0 : emitComment(0, 0);
4230 0 : NS_HTML5_BREAK(eofloop);
4231 : }
4232 : case COMMENT_END: {
4233 0 : errEofInComment();
4234 0 : emitComment(2, 0);
4235 0 : NS_HTML5_BREAK(eofloop);
4236 : }
4237 : case COMMENT_END_DASH:
4238 : case COMMENT_START_DASH: {
4239 0 : errEofInComment();
4240 0 : emitComment(1, 0);
4241 0 : NS_HTML5_BREAK(eofloop);
4242 : }
4243 : case COMMENT_END_BANG: {
4244 0 : errEofInComment();
4245 0 : emitComment(3, 0);
4246 0 : NS_HTML5_BREAK(eofloop);
4247 : }
4248 : case DOCTYPE:
4249 : case BEFORE_DOCTYPE_NAME: {
4250 0 : errEofInDoctype();
4251 0 : forceQuirks = true;
4252 0 : emitDoctypeToken(0);
4253 0 : NS_HTML5_BREAK(eofloop);
4254 : }
4255 : case DOCTYPE_NAME: {
4256 0 : errEofInDoctype();
4257 0 : strBufToDoctypeName();
4258 0 : forceQuirks = true;
4259 0 : emitDoctypeToken(0);
4260 0 : NS_HTML5_BREAK(eofloop);
4261 : }
4262 : case DOCTYPE_UBLIC:
4263 : case DOCTYPE_YSTEM:
4264 : case AFTER_DOCTYPE_NAME:
4265 : case AFTER_DOCTYPE_PUBLIC_KEYWORD:
4266 : case AFTER_DOCTYPE_SYSTEM_KEYWORD:
4267 : case BEFORE_DOCTYPE_PUBLIC_IDENTIFIER: {
4268 0 : errEofInDoctype();
4269 0 : forceQuirks = true;
4270 0 : emitDoctypeToken(0);
4271 0 : NS_HTML5_BREAK(eofloop);
4272 : }
4273 : case DOCTYPE_PUBLIC_IDENTIFIER_DOUBLE_QUOTED:
4274 : case DOCTYPE_PUBLIC_IDENTIFIER_SINGLE_QUOTED: {
4275 0 : errEofInPublicId();
4276 0 : forceQuirks = true;
4277 0 : publicIdentifier = strBufToString();
4278 0 : emitDoctypeToken(0);
4279 0 : NS_HTML5_BREAK(eofloop);
4280 : }
4281 : case AFTER_DOCTYPE_PUBLIC_IDENTIFIER:
4282 : case BEFORE_DOCTYPE_SYSTEM_IDENTIFIER:
4283 : case BETWEEN_DOCTYPE_PUBLIC_AND_SYSTEM_IDENTIFIERS: {
4284 0 : errEofInDoctype();
4285 0 : forceQuirks = true;
4286 0 : emitDoctypeToken(0);
4287 0 : NS_HTML5_BREAK(eofloop);
4288 : }
4289 : case DOCTYPE_SYSTEM_IDENTIFIER_DOUBLE_QUOTED:
4290 : case DOCTYPE_SYSTEM_IDENTIFIER_SINGLE_QUOTED: {
4291 0 : errEofInSystemId();
4292 0 : forceQuirks = true;
4293 0 : systemIdentifier = strBufToString();
4294 0 : emitDoctypeToken(0);
4295 0 : NS_HTML5_BREAK(eofloop);
4296 : }
4297 : case AFTER_DOCTYPE_SYSTEM_IDENTIFIER: {
4298 0 : errEofInDoctype();
4299 0 : forceQuirks = true;
4300 0 : emitDoctypeToken(0);
4301 0 : NS_HTML5_BREAK(eofloop);
4302 : }
4303 : case BOGUS_DOCTYPE: {
4304 0 : emitDoctypeToken(0);
4305 0 : NS_HTML5_BREAK(eofloop);
4306 : }
4307 : case CONSUME_CHARACTER_REFERENCE: {
4308 0 : emitOrAppendCharRefBuf(returnState);
4309 0 : state = returnState;
4310 0 : continue;
4311 : }
4312 : case CHARACTER_REFERENCE_HILO_LOOKUP: {
4313 0 : errNoNamedCharacterMatch();
4314 0 : emitOrAppendCharRefBuf(returnState);
4315 0 : state = returnState;
4316 0 : continue;
4317 : }
4318 : case CHARACTER_REFERENCE_TAIL: {
4319 : for (; ; ) {
4320 0 : char16_t c = '\0';
4321 0 : entCol++;
4322 : for (; ; ) {
4323 0 : if (hi == -1) {
4324 0 : NS_HTML5_BREAK(hiloop);
4325 : }
4326 0 : if (entCol == nsHtml5NamedCharacters::NAMES[hi].length()) {
4327 0 : NS_HTML5_BREAK(hiloop);
4328 : }
4329 0 : if (entCol > nsHtml5NamedCharacters::NAMES[hi].length()) {
4330 0 : NS_HTML5_BREAK(outer);
4331 0 : } else if (c < nsHtml5NamedCharacters::NAMES[hi].charAt(entCol)) {
4332 0 : hi--;
4333 : } else {
4334 0 : NS_HTML5_BREAK(hiloop);
4335 : }
4336 : }
4337 : hiloop_end: ;
4338 : for (; ; ) {
4339 0 : if (hi < lo) {
4340 0 : NS_HTML5_BREAK(outer);
4341 : }
4342 0 : if (entCol == nsHtml5NamedCharacters::NAMES[lo].length()) {
4343 0 : candidate = lo;
4344 0 : charRefBufMark = charRefBufLen;
4345 0 : lo++;
4346 0 : } else if (entCol > nsHtml5NamedCharacters::NAMES[lo].length()) {
4347 0 : NS_HTML5_BREAK(outer);
4348 0 : } else if (c > nsHtml5NamedCharacters::NAMES[lo].charAt(entCol)) {
4349 0 : lo++;
4350 : } else {
4351 0 : NS_HTML5_BREAK(loloop);
4352 : }
4353 : }
4354 : loloop_end: ;
4355 0 : if (hi < lo) {
4356 0 : NS_HTML5_BREAK(outer);
4357 : }
4358 0 : continue;
4359 0 : }
4360 : outer_end: ;
4361 0 : if (candidate == -1) {
4362 0 : errNoNamedCharacterMatch();
4363 0 : emitOrAppendCharRefBuf(returnState);
4364 0 : state = returnState;
4365 0 : NS_HTML5_CONTINUE(eofloop);
4366 : } else {
4367 0 : const nsHtml5CharacterName& candidateName = nsHtml5NamedCharacters::NAMES[candidate];
4368 0 : if (!candidateName.length() || candidateName.charAt(candidateName.length() - 1) != ';') {
4369 0 : if ((returnState & DATA_AND_RCDATA_MASK)) {
4370 : char16_t ch;
4371 0 : if (charRefBufMark == charRefBufLen) {
4372 0 : ch = '\0';
4373 : } else {
4374 0 : ch = charRefBuf[charRefBufMark];
4375 : }
4376 0 : if ((ch >= '0' && ch <= '9') || (ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')) {
4377 0 : errNoNamedCharacterMatch();
4378 0 : appendCharRefBufToStrBuf();
4379 0 : state = returnState;
4380 0 : NS_HTML5_CONTINUE(eofloop);
4381 : }
4382 : }
4383 0 : if ((returnState & DATA_AND_RCDATA_MASK)) {
4384 0 : errUnescapedAmpersandInterpretedAsCharacterReference();
4385 : } else {
4386 0 : errNotSemicolonTerminated();
4387 : }
4388 : }
4389 0 : const char16_t* val = nsHtml5NamedCharacters::VALUES[candidate];
4390 0 : if (!val[1]) {
4391 0 : emitOrAppendOne(val, returnState);
4392 : } else {
4393 0 : emitOrAppendTwo(val, returnState);
4394 : }
4395 0 : if (charRefBufMark < charRefBufLen) {
4396 0 : if ((returnState & DATA_AND_RCDATA_MASK)) {
4397 0 : appendStrBuf(charRefBuf, charRefBufMark, charRefBufLen - charRefBufMark);
4398 : } else {
4399 0 : tokenHandler->characters(charRefBuf, charRefBufMark, charRefBufLen - charRefBufMark);
4400 : }
4401 : }
4402 0 : charRefBufLen = 0;
4403 0 : state = returnState;
4404 0 : NS_HTML5_CONTINUE(eofloop);
4405 : }
4406 : }
4407 : case CONSUME_NCR:
4408 : case DECIMAL_NRC_LOOP:
4409 : case HEX_NCR_LOOP: {
4410 0 : if (!seenDigits) {
4411 0 : errNoDigitsInNCR();
4412 0 : emitOrAppendCharRefBuf(returnState);
4413 0 : state = returnState;
4414 0 : continue;
4415 : } else {
4416 0 : errCharRefLacksSemicolon();
4417 : }
4418 0 : handleNcrValue(returnState);
4419 0 : state = returnState;
4420 0 : continue;
4421 : }
4422 : case CDATA_RSQB: {
4423 0 : tokenHandler->characters(nsHtml5Tokenizer::RSQB_RSQB, 0, 1);
4424 0 : NS_HTML5_BREAK(eofloop);
4425 : }
4426 : case CDATA_RSQB_RSQB: {
4427 0 : tokenHandler->characters(nsHtml5Tokenizer::RSQB_RSQB, 0, 2);
4428 0 : NS_HTML5_BREAK(eofloop);
4429 : }
4430 : case DATA:
4431 : default: {
4432 2 : NS_HTML5_BREAK(eofloop);
4433 : }
4434 : }
4435 0 : }
4436 : eofloop_end: ;
4437 2 : tokenHandler->eof();
4438 2 : return;
4439 : }
4440 :
4441 : void
4442 1 : nsHtml5Tokenizer::emitDoctypeToken(int32_t pos)
4443 : {
4444 1 : cstart = pos + 1;
4445 1 : tokenHandler->doctype(doctypeName, publicIdentifier, systemIdentifier, forceQuirks);
4446 1 : doctypeName = nullptr;
4447 1 : publicIdentifier.Release();
4448 1 : publicIdentifier = nullptr;
4449 1 : systemIdentifier.Release();
4450 1 : systemIdentifier = nullptr;
4451 1 : }
4452 :
4453 : bool
4454 2 : nsHtml5Tokenizer::internalEncodingDeclaration(nsHtml5String internalCharset)
4455 : {
4456 2 : if (encodingDeclarationHandler) {
4457 2 : return encodingDeclarationHandler->internalEncodingDeclaration(internalCharset);
4458 : }
4459 0 : return false;
4460 : }
4461 :
4462 : void
4463 0 : nsHtml5Tokenizer::emitOrAppendTwo(const char16_t* val, int32_t returnState)
4464 : {
4465 0 : if ((returnState & DATA_AND_RCDATA_MASK)) {
4466 0 : appendStrBuf(val[0]);
4467 0 : appendStrBuf(val[1]);
4468 : } else {
4469 0 : tokenHandler->characters(val, 0, 2);
4470 : }
4471 0 : }
4472 :
4473 : void
4474 0 : nsHtml5Tokenizer::emitOrAppendOne(const char16_t* val, int32_t returnState)
4475 : {
4476 0 : if ((returnState & DATA_AND_RCDATA_MASK)) {
4477 0 : appendStrBuf(val[0]);
4478 : } else {
4479 0 : tokenHandler->characters(val, 0, 1);
4480 : }
4481 0 : }
4482 :
4483 : void
4484 1 : nsHtml5Tokenizer::end()
4485 : {
4486 1 : strBuf = nullptr;
4487 1 : doctypeName = nullptr;
4488 1 : if (systemIdentifier) {
4489 0 : systemIdentifier.Release();
4490 0 : systemIdentifier = nullptr;
4491 : }
4492 1 : if (publicIdentifier) {
4493 0 : publicIdentifier.Release();
4494 0 : publicIdentifier = nullptr;
4495 : }
4496 1 : tagName = nullptr;
4497 1 : nonInternedTagName->setNameForNonInterned(nullptr);
4498 1 : attributeName = nullptr;
4499 1 : nonInternedAttributeName->setNameForNonInterned(nullptr);
4500 1 : tokenHandler->endTokenization();
4501 1 : if (attributes) {
4502 0 : attributes->clear(0);
4503 : }
4504 1 : }
4505 :
4506 : void
4507 5 : nsHtml5Tokenizer::requestSuspension()
4508 : {
4509 5 : shouldSuspend = true;
4510 5 : }
4511 :
4512 : bool
4513 5 : nsHtml5Tokenizer::isInDataState()
4514 : {
4515 5 : return (stateSave == DATA);
4516 : }
4517 :
4518 : void
4519 9 : nsHtml5Tokenizer::resetToDataState()
4520 : {
4521 9 : clearStrBufAfterUse();
4522 9 : charRefBufLen = 0;
4523 9 : stateSave = nsHtml5Tokenizer::DATA;
4524 9 : lastCR = false;
4525 9 : index = 0;
4526 9 : forceQuirks = false;
4527 9 : additional = '\0';
4528 9 : entCol = -1;
4529 9 : firstCharKey = -1;
4530 9 : lo = 0;
4531 9 : hi = 0;
4532 9 : candidate = -1;
4533 9 : charRefBufMark = 0;
4534 9 : value = 0;
4535 9 : seenDigits = false;
4536 9 : endTag = false;
4537 9 : shouldSuspend = false;
4538 9 : initDoctypeFields();
4539 9 : containsHyphen = false;
4540 9 : tagName = nullptr;
4541 9 : attributeName = nullptr;
4542 9 : if (newAttributesEachTime) {
4543 9 : if (attributes) {
4544 0 : delete attributes;
4545 0 : attributes = nullptr;
4546 : }
4547 : }
4548 9 : }
4549 :
4550 : void
4551 0 : nsHtml5Tokenizer::loadState(nsHtml5Tokenizer* other)
4552 : {
4553 0 : strBufLen = other->strBufLen;
4554 0 : if (strBufLen > strBuf.length) {
4555 0 : strBuf = jArray<char16_t,int32_t>::newJArray(strBufLen);
4556 : }
4557 0 : nsHtml5ArrayCopy::arraycopy(other->strBuf, strBuf, strBufLen);
4558 0 : charRefBufLen = other->charRefBufLen;
4559 0 : nsHtml5ArrayCopy::arraycopy(other->charRefBuf, charRefBuf, charRefBufLen);
4560 0 : stateSave = other->stateSave;
4561 0 : returnStateSave = other->returnStateSave;
4562 0 : endTagExpectation = other->endTagExpectation;
4563 0 : endTagExpectationAsArray = other->endTagExpectationAsArray;
4564 0 : lastCR = other->lastCR;
4565 0 : index = other->index;
4566 0 : forceQuirks = other->forceQuirks;
4567 0 : additional = other->additional;
4568 0 : entCol = other->entCol;
4569 0 : firstCharKey = other->firstCharKey;
4570 0 : lo = other->lo;
4571 0 : hi = other->hi;
4572 0 : candidate = other->candidate;
4573 0 : charRefBufMark = other->charRefBufMark;
4574 0 : value = other->value;
4575 0 : seenDigits = other->seenDigits;
4576 0 : endTag = other->endTag;
4577 0 : shouldSuspend = false;
4578 0 : if (!other->doctypeName) {
4579 0 : doctypeName = nullptr;
4580 : } else {
4581 0 : doctypeName = nsHtml5Portability::newLocalFromLocal(other->doctypeName, interner);
4582 : }
4583 0 : systemIdentifier.Release();
4584 0 : if (!other->systemIdentifier) {
4585 0 : systemIdentifier = nullptr;
4586 : } else {
4587 0 : systemIdentifier = nsHtml5Portability::newStringFromString(other->systemIdentifier);
4588 : }
4589 0 : publicIdentifier.Release();
4590 0 : if (!other->publicIdentifier) {
4591 0 : publicIdentifier = nullptr;
4592 : } else {
4593 0 : publicIdentifier = nsHtml5Portability::newStringFromString(other->publicIdentifier);
4594 : }
4595 0 : containsHyphen = other->containsHyphen;
4596 0 : if (!other->tagName) {
4597 0 : tagName = nullptr;
4598 0 : } else if (other->tagName->isInterned()) {
4599 0 : tagName = other->tagName;
4600 : } else {
4601 0 : nonInternedTagName->setNameForNonInterned(
4602 0 : nsHtml5Portability::newLocalFromLocal(other->tagName->getName(),
4603 0 : interner));
4604 0 : tagName = nonInternedTagName;
4605 : }
4606 0 : if (!other->attributeName) {
4607 0 : attributeName = nullptr;
4608 0 : } else if (other->attributeName->isInterned()) {
4609 0 : attributeName = other->attributeName;
4610 : } else {
4611 0 : nonInternedAttributeName->setNameForNonInterned(
4612 : nsHtml5Portability::newLocalFromLocal(
4613 0 : other->attributeName->getLocal(nsHtml5AttributeName::HTML), interner));
4614 0 : attributeName = nonInternedAttributeName;
4615 : }
4616 0 : delete attributes;
4617 0 : if (!other->attributes) {
4618 0 : attributes = nullptr;
4619 : } else {
4620 0 : attributes = other->attributes->cloneAttributes(interner);
4621 : }
4622 0 : }
4623 :
4624 : void
4625 4 : nsHtml5Tokenizer::initializeWithoutStarting()
4626 : {
4627 4 : confident = false;
4628 4 : strBuf = nullptr;
4629 4 : line = 1;
4630 4 : attributeLine = 1;
4631 4 : resetToDataState();
4632 4 : }
4633 :
4634 : void
4635 2 : nsHtml5Tokenizer::setEncodingDeclarationHandler(nsHtml5StreamParser* encodingDeclarationHandler)
4636 : {
4637 2 : this->encodingDeclarationHandler = encodingDeclarationHandler;
4638 2 : }
4639 :
4640 :
4641 2 : nsHtml5Tokenizer::~nsHtml5Tokenizer()
4642 : {
4643 1 : MOZ_COUNT_DTOR(nsHtml5Tokenizer);
4644 1 : delete nonInternedTagName;
4645 1 : delete nonInternedAttributeName;
4646 1 : nonInternedTagName = nullptr;
4647 1 : delete attributes;
4648 1 : attributes = nullptr;
4649 1 : }
4650 :
4651 : void
4652 3 : nsHtml5Tokenizer::initializeStatics()
4653 : {
4654 3 : }
4655 :
4656 : void
4657 0 : nsHtml5Tokenizer::releaseStatics()
4658 : {
4659 0 : }
4660 :
4661 :
4662 : #include "nsHtml5TokenizerCppSupplement.h"
4663 :
|
