The Tor Browser / file comparison

comparison: parser/html/nsHtml5Tokenizer.cpp

parser/html/nsHtml5Tokenizer.cpp

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

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial