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