LCOV - app.info - parser/html/nsHtml5Tokenizer.cpp

LCOV - code coverage report
| Current view: | directory - parser/html - nsHtml5Tokenizer.cpp (source / functions) |  | Found | Hit | Coverage |
| Test: | app.info | Lines: | 2142 | 252 | 11.8 %
| Date: | 2012-07-07 | Functions: | 50 | 21 | 42.0 %

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

Generated by: LCOV version 1.7