PageRenderTime 69ms CodeModel.GetById 20ms RepoModel.GetById 0ms app.codeStats 1ms

/parser/html/nsHtml5Tokenizer.cpp

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