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-06-02 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