Changeset 60703 in webkit


Ignore:
Timestamp:
Jun 4, 2010 1:00:40 PM (14 years ago)
Author:
abarth@webkit.org
Message:

2010-06-04 Adam Barth <abarth@webkit.org>

Reviewed by Eric Seidel.

Make HTML5Lexer go fast
https://bugs.webkit.org/show_bug.cgi?id=40048

Introduce ADVANCE_TO macro. This is the last macro we need to
introduce.

  • html/HTML5Lexer.cpp: (WebCore::HTML5Lexer::nextToken):
Location:
trunk/WebCore
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/WebCore/ChangeLog

    r60702 r60703  
     12010-06-04  Adam Barth  <abarth@webkit.org>
     2
     3        Reviewed by Eric Seidel.
     4
     5        Make HTML5Lexer go fast
     6        https://bugs.webkit.org/show_bug.cgi?id=40048
     7
     8        Introduce ADVANCE_TO macro.  This is the last macro we need to
     9        introduce.
     10
     11        * html/HTML5Lexer.cpp:
     12        (WebCore::HTML5Lexer::nextToken):
     13
    1142010-06-04  Adam Barth  <abarth@webkit.org>
    215
  • trunk/WebCore/html/HTML5Lexer.cpp

    r60702 r60703  
    328328    } while (false)
    329329
     330#define ADVANCE_TO(stateName)                                               \
     331    m_state = stateName                                                     \
     332
    330333// We'd like to use the standard do { } while (false) pattern here, but it
    331334// doesn't play nicely with continue.
     
    376379        BEGIN_STATE(DataState) {
    377380            if (cc == '&')
    378                 m_state = CharacterReferenceInDataState;
     381                ADVANCE_TO(CharacterReferenceInDataState);
    379382            else if (cc == '<') {
    380383                if (m_token->type() == HTML5Token::Character) {
     
    383386                    return true;
    384387                }
    385                 m_state = TagOpenState;
     388                ADVANCE_TO(TagOpenState);
    386389            } else
    387390                emitCharacter(cc);
     
    399402        BEGIN_STATE(RCDATAState) {
    400403            if (cc == '&')
    401                 m_state = CharacterReferenceInRCDATAState;
     404                ADVANCE_TO(CharacterReferenceInRCDATAState);
    402405            else if (cc == '<')
    403                 m_state = RCDATALessThanSignState;
     406                ADVANCE_TO(RCDATALessThanSignState);
    404407            else
    405408                emitCharacter(cc);
     
    417420        BEGIN_STATE(RAWTEXTState) {
    418421            if (cc == '<')
    419                 m_state = RAWTEXTLessThanSignState;
     422                ADVANCE_TO(RAWTEXTLessThanSignState);
    420423            else
    421424                emitCharacter(cc);
     
    426429        BEGIN_STATE(ScriptDataState) {
    427430            if (cc == '<')
    428                 m_state = ScriptDataLessThanSignState;
     431                ADVANCE_TO(ScriptDataLessThanSignState);
    429432            else
    430433                emitCharacter(cc);
     
    441444        BEGIN_STATE(TagOpenState) {
    442445            if (cc == '!')
    443                 m_state = MarkupDeclarationOpenState;
     446                ADVANCE_TO(MarkupDeclarationOpenState);
    444447            else if (cc == '/')
    445                 m_state = EndTagOpenState;
     448                ADVANCE_TO(EndTagOpenState);
    446449            else if (cc >= 'A' && cc <= 'Z') {
    447450                m_token->beginStartTag(toLowerCase(cc));
    448                 m_state = TagNameState;
     451                ADVANCE_TO(TagNameState);
    449452            } else if (cc >= 'a' && cc <= 'z') {
    450453                m_token->beginStartTag(cc);
    451                 m_state = TagNameState;
     454                ADVANCE_TO(TagNameState);
    452455            } else if (cc == '?') {
    453456                emitParseError();
     
    468471            if (cc >= 'A' && cc <= 'Z') {
    469472                m_token->beginEndTag(toLowerCase(cc));
    470                 m_state = TagNameState;
     473                ADVANCE_TO(TagNameState);
    471474            } else if (cc >= 'a' && cc <= 'z') {
    472475                m_token->beginEndTag(cc);
    473                 m_state = TagNameState;
     476                ADVANCE_TO(TagNameState);
    474477            } else if (cc == '>') {
    475478                emitParseError();
    476                 m_state = DataState;
     479                ADVANCE_TO(DataState);
    477480            } else {
    478481                emitParseError();
     
    486489        BEGIN_STATE(TagNameState) {
    487490            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    488                 m_state = BeforeAttributeNameState;
     491                ADVANCE_TO(BeforeAttributeNameState);
    489492            else if (cc == '/')
    490                 m_state = SelfClosingStartTagState;
     493                ADVANCE_TO(SelfClosingStartTagState);
    491494            else if (cc == '>') {
    492495                EMIT_AND_RESUME_IN(DataState);
     
    504507                m_temporaryBuffer.clear();
    505508                ASSERT(m_bufferedEndTagName.isEmpty());
    506                 m_state = RCDATAEndTagOpenState;
     509                ADVANCE_TO(RCDATAEndTagOpenState);
    507510            } else {
    508511                emitCharacter('<');
     
    517520                m_temporaryBuffer.append(cc);
    518521                addToPossibleEndTag(toLowerCase(cc));
    519                 m_state = RCDATAEndTagNameState;
     522                ADVANCE_TO(RCDATAEndTagNameState);
    520523            } else if (cc >= 'a' && cc <= 'z') {
    521524                m_temporaryBuffer.append(cc);
    522525                addToPossibleEndTag(cc);
    523                 m_state = RCDATAEndTagNameState;
     526                ADVANCE_TO(RCDATAEndTagNameState);
    524527            } else {
    525528                emitCharacter('<');
     
    566569                m_temporaryBuffer.clear();
    567570                ASSERT(m_bufferedEndTagName.isEmpty());
    568                 m_state = RAWTEXTEndTagOpenState;
     571                ADVANCE_TO(RAWTEXTEndTagOpenState);
    569572            } else {
    570573                emitCharacter('<');
     
    579582                m_temporaryBuffer.append(cc);
    580583                addToPossibleEndTag(toLowerCase(cc));
    581                 m_state = RAWTEXTEndTagNameState;
     584                ADVANCE_TO(RAWTEXTEndTagNameState);
    582585            } else if (cc >= 'a' && cc <= 'z') {
    583586                m_temporaryBuffer.append(cc);
    584587                addToPossibleEndTag(cc);
    585                 m_state = RAWTEXTEndTagNameState;
     588                ADVANCE_TO(RAWTEXTEndTagNameState);
    586589            } else {
    587590                emitCharacter('<');
     
    628631                m_temporaryBuffer.clear();
    629632                ASSERT(m_bufferedEndTagName.isEmpty());
    630                 m_state = ScriptDataEndTagOpenState;
     633                ADVANCE_TO(ScriptDataEndTagOpenState);
    631634            } else if (cc == '!') {
    632635                emitCharacter('<');
    633636                emitCharacter('!');
    634                 m_state = ScriptDataEscapeStartState;
     637                ADVANCE_TO(ScriptDataEscapeStartState);
    635638            } else {
    636639                emitCharacter('<');
     
    645648                m_temporaryBuffer.append(cc);
    646649                addToPossibleEndTag(toLowerCase(cc));
    647                 m_state = ScriptDataEndTagNameState;
     650                ADVANCE_TO(ScriptDataEndTagNameState);
    648651            } else if (cc >= 'a' && cc <= 'z') {
    649652                m_temporaryBuffer.append(cc);
    650653                addToPossibleEndTag(cc);
    651                 m_state = ScriptDataEndTagNameState;
     654                ADVANCE_TO(ScriptDataEndTagNameState);
    652655            } else {
    653656                emitCharacter('<');
     
    693696            if (cc == '-') {
    694697                emitCharacter(cc);
    695                 m_state = ScriptDataEscapeStartDashState;
     698                ADVANCE_TO(ScriptDataEscapeStartDashState);
    696699            } else {
    697700                RECONSUME_IN(ScriptDataState);
     
    704707            if (cc == '-') {
    705708                emitCharacter(cc);
    706                 m_state = ScriptDataEscapedDashDashState;
     709                ADVANCE_TO(ScriptDataEscapedDashDashState);
    707710            } else {
    708711                RECONSUME_IN(ScriptDataState);
     
    715718            if (cc == '-') {
    716719                emitCharacter(cc);
    717                 m_state = ScriptDataEscapedDashState;
     720                ADVANCE_TO(ScriptDataEscapedDashState);
    718721            } else if (cc == '<')
    719                 m_state = ScriptDataEscapedLessThanSignState;
     722                ADVANCE_TO(ScriptDataEscapedLessThanSignState);
    720723            else
    721724                emitCharacter(cc);
     
    728731            if (cc == '-') {
    729732                emitCharacter(cc);
    730                 m_state = ScriptDataEscapedDashDashState;
     733                ADVANCE_TO(ScriptDataEscapedDashDashState);
    731734            } else if (cc == '<')
    732                 m_state = ScriptDataEscapedLessThanSignState;
     735                ADVANCE_TO(ScriptDataEscapedLessThanSignState);
    733736            else {
    734737                emitCharacter(cc);
    735                 m_state = ScriptDataEscapedState;
     738                ADVANCE_TO(ScriptDataEscapedState);
    736739            }
    737740            // FIXME: Handle EOF properly.
     
    744747                emitCharacter(cc);
    745748            else if (cc == '<')
    746                 m_state = ScriptDataEscapedLessThanSignState;
     749                ADVANCE_TO(ScriptDataEscapedLessThanSignState);
    747750            else if (cc == '>') {
    748751                emitCharacter(cc);
    749                 m_state = ScriptDataState;
    750             } else {
    751                 emitCharacter(cc);
    752                 m_state = ScriptDataEscapedState;
     752                ADVANCE_TO(ScriptDataState);
     753            } else {
     754                emitCharacter(cc);
     755                ADVANCE_TO(ScriptDataEscapedState);
    753756            }
    754757            // FIXME: Handle EOF properly.
     
    761764                m_temporaryBuffer.clear();
    762765                ASSERT(m_bufferedEndTagName.isEmpty());
    763                 m_state = ScriptDataEscapedEndTagOpenState;
     766                ADVANCE_TO(ScriptDataEscapedEndTagOpenState);
    764767            } else if (cc >= 'A' && cc <= 'Z') {
    765768                emitCharacter('<');
     
    767770                m_temporaryBuffer.clear();
    768771                m_temporaryBuffer.append(toLowerCase(cc));
    769                 m_state = ScriptDataDoubleEscapeStartState;
     772                ADVANCE_TO(ScriptDataDoubleEscapeStartState);
    770773            } else if (cc >= 'a' && cc <= 'z') {
    771774                emitCharacter('<');
     
    773776                m_temporaryBuffer.clear();
    774777                m_temporaryBuffer.append(cc);
    775                 m_state = ScriptDataDoubleEscapeStartState;
     778                ADVANCE_TO(ScriptDataDoubleEscapeStartState);
    776779            } else {
    777780                emitCharacter('<');
     
    786789                m_temporaryBuffer.append(cc);
    787790                addToPossibleEndTag(toLowerCase(cc));
    788                 m_state = ScriptDataEscapedEndTagNameState;
     791                ADVANCE_TO(ScriptDataEscapedEndTagNameState);
    789792            } else if (cc >= 'a' && cc <= 'z') {
    790793                m_temporaryBuffer.append(cc);
    791794                addToPossibleEndTag(cc);
    792                 m_state = ScriptDataEscapedEndTagNameState;
     795                ADVANCE_TO(ScriptDataEscapedEndTagNameState);
    793796            } else {
    794797                emitCharacter('<');
     
    835838                emitCharacter(cc);
    836839                if (temporaryBufferIs(scriptTag.localName()))
    837                     m_state = ScriptDataDoubleEscapedState;
     840                    ADVANCE_TO(ScriptDataDoubleEscapedState);
    838841                else
    839                     m_state = ScriptDataEscapedState;
     842                    ADVANCE_TO(ScriptDataEscapedState);
    840843            } else if (cc >= 'A' && cc <= 'Z') {
    841844                emitCharacter(cc);
     
    854857            if (cc == '-') {
    855858                emitCharacter(cc);
    856                 m_state = ScriptDataDoubleEscapedDashState;
     859                ADVANCE_TO(ScriptDataDoubleEscapedDashState);
    857860            } else if (cc == '<') {
    858861                emitCharacter(cc);
    859                 m_state = ScriptDataDoubleEscapedLessThanSignState;
     862                ADVANCE_TO(ScriptDataDoubleEscapedLessThanSignState);
    860863            } else
    861864                emitCharacter(cc);
     
    868871            if (cc == '-') {
    869872                emitCharacter(cc);
    870                 m_state = ScriptDataDoubleEscapedDashDashState;
     873                ADVANCE_TO(ScriptDataDoubleEscapedDashDashState);
    871874            } else if (cc == '<') {
    872875                emitCharacter(cc);
    873                 m_state = ScriptDataDoubleEscapedLessThanSignState;
    874             } else {
    875                 emitCharacter(cc);
    876                 m_state = ScriptDataDoubleEscapedState;
     876                ADVANCE_TO(ScriptDataDoubleEscapedLessThanSignState);
     877            } else {
     878                emitCharacter(cc);
     879                ADVANCE_TO(ScriptDataDoubleEscapedState);
    877880            }
    878881            // FIXME: Handle EOF properly.
     
    886889            else if (cc == '<') {
    887890                emitCharacter(cc);
    888                 m_state = ScriptDataDoubleEscapedLessThanSignState;
     891                ADVANCE_TO(ScriptDataDoubleEscapedLessThanSignState);
    889892            } else if (cc == '>') {
    890893                emitCharacter(cc);
    891                 m_state = ScriptDataState;
    892             } else {
    893                 emitCharacter(cc);
    894                 m_state = ScriptDataDoubleEscapedState;
     894                ADVANCE_TO(ScriptDataState);
     895            } else {
     896                emitCharacter(cc);
     897                ADVANCE_TO(ScriptDataDoubleEscapedState);
    895898            }
    896899            // FIXME: Handle EOF properly.
     
    903906                emitCharacter(cc);
    904907                m_temporaryBuffer.clear();
    905                 m_state = ScriptDataDoubleEscapeEndState;
     908                ADVANCE_TO(ScriptDataDoubleEscapeEndState);
    906909            } else {
    907910                RECONSUME_IN(ScriptDataDoubleEscapedState);
     
    915918                emitCharacter(cc);
    916919                if (temporaryBufferIs(scriptTag.localName()))
    917                     m_state = ScriptDataEscapedState;
     920                    ADVANCE_TO(ScriptDataEscapedState);
    918921                else
    919                     m_state = ScriptDataDoubleEscapedState;
     922                    ADVANCE_TO(ScriptDataDoubleEscapedState);
    920923            } else if (cc >= 'A' && cc <= 'Z') {
    921924                emitCharacter(cc);
     
    935938                break;
    936939            else if (cc == '/')
    937                 m_state = SelfClosingStartTagState;
     940                ADVANCE_TO(SelfClosingStartTagState);
    938941            else if (cc == '>') {
    939942                EMIT_AND_RESUME_IN(DataState);
     
    941944                m_token->addNewAttribute();
    942945                m_token->appendToAttributeName(toLowerCase(cc));
    943                 m_state = AttributeNameState;
     946                ADVANCE_TO(AttributeNameState);
    944947            } else {
    945948                if (cc == '"' || cc == '\'' || cc == '<' || cc == '=')
     
    947950                m_token->addNewAttribute();
    948951                m_token->appendToAttributeName(cc);
    949                 m_state = AttributeNameState;
     952                ADVANCE_TO(AttributeNameState);
    950953            }
    951954            // FIXME: Handle EOF properly.
     
    956959        BEGIN_STATE(AttributeNameState) {
    957960            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    958                 m_state = AfterAttributeNameState;
     961                ADVANCE_TO(AfterAttributeNameState);
    959962            else if (cc == '/')
    960                 m_state = SelfClosingStartTagState;
     963                ADVANCE_TO(SelfClosingStartTagState);
    961964            else if (cc == '=')
    962                 m_state = BeforeAttributeValueState;
     965                ADVANCE_TO(BeforeAttributeValueState);
    963966            else if (cc == '>') {
    964967                EMIT_AND_RESUME_IN(DataState);
     
    969972                    emitParseError();
    970973                m_token->appendToAttributeName(cc);
    971                 m_state = AttributeNameState;
     974                ADVANCE_TO(AttributeNameState);
    972975            }
    973976            // FIXME: Handle EOF properly.
     
    980983                break;
    981984            else if (cc == '/')
    982                 m_state = SelfClosingStartTagState;
     985                ADVANCE_TO(SelfClosingStartTagState);
    983986            else if (cc == '=')
    984                 m_state = BeforeAttributeValueState;
     987                ADVANCE_TO(BeforeAttributeValueState);
    985988            else if (cc == '=') {
    986989                EMIT_AND_RESUME_IN(DataState);
     
    988991                m_token->addNewAttribute();
    989992                m_token->appendToAttributeName(toLowerCase(cc));
    990                 m_state = AttributeNameState;
     993                ADVANCE_TO(AttributeNameState);
    991994            } else {
    992995                if (cc == '"' || cc == '\'' || cc == '<')
     
    994997                m_token->addNewAttribute();
    995998                m_token->appendToAttributeName(cc);
    996                 m_state = AttributeNameState;
     999                ADVANCE_TO(AttributeNameState);
    9971000            }
    9981001            // FIXME: Handle EOF properly.
     
    10051008                break;
    10061009            else if (cc == '"')
    1007                 m_state = AttributeValueDoubleQuotedState;
     1010                ADVANCE_TO(AttributeValueDoubleQuotedState);
    10081011            else if (cc == '&') {
    10091012                RECONSUME_IN(AttributeValueUnquotedState);
    10101013            } else if (cc == '\'')
    1011                 m_state = AttributeValueSingleQuotedState;
     1014                ADVANCE_TO(AttributeValueSingleQuotedState);
    10121015            else if (cc == '>') {
    10131016                emitParseError();
     
    10171020                    emitParseError();
    10181021                m_token->appendToAttributeValue(cc);
    1019                 m_state = AttributeValueUnquotedState;
     1022                ADVANCE_TO(AttributeValueUnquotedState);
    10201023            }
    10211024            break;
     
    10251028        BEGIN_STATE(AttributeValueDoubleQuotedState) {
    10261029            if (cc == '"')
    1027                 m_state = AfterAttributeValueQuotedState;
     1030                ADVANCE_TO(AfterAttributeValueQuotedState);
    10281031            else if (cc == '&') {
    10291032                m_additionalAllowedCharacter = '"';
    1030                 m_state = CharacterReferenceInAttributeValueState;
     1033                ADVANCE_TO(CharacterReferenceInAttributeValueState);
    10311034            } else
    10321035                m_token->appendToAttributeValue(cc);
     
    10381041        BEGIN_STATE(AttributeValueSingleQuotedState) {
    10391042            if (cc == '\'')
    1040                 m_state = AfterAttributeValueQuotedState;
     1043                ADVANCE_TO(AfterAttributeValueQuotedState);
    10411044            else if (cc == '&') {
    10421045                m_additionalAllowedCharacter = '\'';
    1043                 m_state = CharacterReferenceInAttributeValueState;
     1046                ADVANCE_TO(CharacterReferenceInAttributeValueState);
    10441047            } else
    10451048                m_token->appendToAttributeValue(cc);
     
    10511054        BEGIN_STATE(AttributeValueUnquotedState) {
    10521055            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1053                 m_state = BeforeAttributeNameState;
     1056                ADVANCE_TO(BeforeAttributeNameState);
    10541057            else if (cc == '&') {
    10551058                m_additionalAllowedCharacter = '>';
    1056                 m_state = CharacterReferenceInAttributeValueState;
     1059                ADVANCE_TO(CharacterReferenceInAttributeValueState);
    10571060            } else if (cc == '>') {
    10581061                EMIT_AND_RESUME_IN(DataState);
     
    10981101        BEGIN_STATE(AfterAttributeValueQuotedState) {
    10991102            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1100                 m_state = BeforeAttributeNameState;
     1103                ADVANCE_TO(BeforeAttributeNameState);
    11011104            else if (cc == '/')
    1102                 m_state = SelfClosingStartTagState;
     1105                ADVANCE_TO(SelfClosingStartTagState);
    11031106            else if (cc == '>') {
    11041107                EMIT_AND_RESUME_IN(DataState);
     
    11721175        BEGIN_STATE(CommentStartState) {
    11731176            if (cc == '-')
    1174                 m_state = CommentStartDashState;
     1177                ADVANCE_TO(CommentStartDashState);
    11751178            else if (cc == '>') {
    11761179                emitParseError();
     
    11781181            } else {
    11791182                m_token->appendToComment(cc);
    1180                 m_state = CommentState;
     1183                ADVANCE_TO(CommentState);
    11811184            }
    11821185            // FIXME: Handle EOF properly.
     
    11871190        BEGIN_STATE(CommentStartDashState) {
    11881191            if (cc == '-')
    1189                 m_state = CommentEndState;
     1192                ADVANCE_TO(CommentEndState);
    11901193            else if (cc == '>') {
    11911194                emitParseError();
     
    11941197                m_token->appendToComment('-');
    11951198                m_token->appendToComment(cc);
    1196                 m_state = CommentState;
     1199                ADVANCE_TO(CommentState);
    11971200            }
    11981201            // FIXME: Handle EOF properly.
     
    12031206        BEGIN_STATE(CommentState) {
    12041207            if (cc == '-')
    1205                 m_state = CommentEndDashState;
     1208                ADVANCE_TO(CommentEndDashState);
    12061209            else
    12071210                m_token->appendToComment(cc);
     
    12131216        BEGIN_STATE(CommentEndDashState) {
    12141217            if (cc == '-')
    1215                 m_state = CommentEndState;
     1218                ADVANCE_TO(CommentEndState);
    12161219            else {
    12171220                m_token->appendToComment('-');
    12181221                m_token->appendToComment(cc);
    1219                 m_state = CommentState;
     1222                ADVANCE_TO(CommentState);
    12201223            }
    12211224            // FIXME: Handle EOF properly.
     
    12321235                m_token->appendToComment('-');
    12331236                m_token->appendToComment(cc);
    1234                 m_state = CommentEndSpaceState;
     1237                ADVANCE_TO(CommentEndSpaceState);
    12351238            } else if (cc == '!') {
    12361239                emitParseError();
    1237                 m_state = CommentEndBangState;
     1240                ADVANCE_TO(CommentEndBangState);
    12381241            } else if (cc == '-') {
    12391242                emitParseError();
     
    12451248                m_token->appendToComment('-');
    12461249                m_token->appendToComment(cc);
    1247                 m_state = CommentState;
     1250                ADVANCE_TO(CommentState);
    12481251            }
    12491252            // FIXME: Handle EOF properly.
     
    12571260                m_token->appendToComment('-');
    12581261                m_token->appendToComment('!');
    1259                 m_state = CommentEndDashState;
     1262                ADVANCE_TO(CommentEndDashState);
    12601263            } else if (cc == '>') {
    12611264                EMIT_AND_RESUME_IN(DataState);
     
    12651268                m_token->appendToComment('!');
    12661269                m_token->appendToComment(cc);
    1267                 m_state = CommentState;
     1270                ADVANCE_TO(CommentState);
    12681271            }
    12691272            // FIXME: Handle EOF properly.
     
    12761279                m_token->appendToComment(cc);
    12771280            else if (cc == '-')
    1278                 m_state = CommentEndDashState;
     1281                ADVANCE_TO(CommentEndDashState);
    12791282            else if (cc == '>') {
    12801283                EMIT_AND_RESUME_IN(DataState);
    12811284            } else {
    12821285                m_token->appendToComment(cc);
    1283                 m_state = CommentState;
     1286                ADVANCE_TO(CommentState);
    12841287            }
    12851288            // FIXME: Handle EOF properly.
     
    12901293        BEGIN_STATE(DOCTYPEState) {
    12911294            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1292                 m_state = BeforeDOCTYPENameState;
     1295                ADVANCE_TO(BeforeDOCTYPENameState);
    12931296            else {
    12941297                emitParseError();
     
    13051308            else if (cc >= 'A' && cc <= 'Z') {
    13061309                m_token->beginDOCTYPE(toLowerCase(cc));
    1307                 m_state = DOCTYPENameState;
     1310                ADVANCE_TO(DOCTYPENameState);
    13081311            } else if (cc == '>') {
    13091312                emitParseError();
     
    13131316            } else {
    13141317                m_token->beginDOCTYPE(cc);
    1315                 m_state = DOCTYPENameState;
     1318                ADVANCE_TO(DOCTYPENameState);
    13161319            }
    13171320            // FIXME: Handle EOF properly.
     
    13221325        BEGIN_STATE(DOCTYPENameState) {
    13231326            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1324                 m_state = AfterDOCTYPENameState;
     1327                ADVANCE_TO(AfterDOCTYPENameState);
    13251328            else if (cc == '>') {
    13261329                EMIT_AND_RESUME_IN(DataState);
     
    13591362                emitParseError();
    13601363                notImplemented();
    1361                 m_state = BogusDOCTYPEState;
     1364                ADVANCE_TO(BogusDOCTYPEState);
    13621365            }
    13631366            // FIXME: Handle EOF properly.
     
    13681371        BEGIN_STATE(AfterDOCTYPEPublicKeywordState) {
    13691372            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1370                 m_state = BeforeDOCTYPEPublicIdentifierState;
     1373                ADVANCE_TO(BeforeDOCTYPEPublicIdentifierState);
    13711374            else if (cc == '"') {
    13721375                emitParseError();
    13731376                m_token->setPublicIdentifierToEmptyString();
    1374                 m_state = DOCTYPEPublicIdentifierDoubleQuotedState;
     1377                ADVANCE_TO(DOCTYPEPublicIdentifierDoubleQuotedState);
    13751378            } else if (cc == '\'') {
    13761379                emitParseError();
    13771380                m_token->setPublicIdentifierToEmptyString();
    1378                 m_state = DOCTYPEPublicIdentifierSingleQuotedState;
     1381                ADVANCE_TO(DOCTYPEPublicIdentifierSingleQuotedState);
    13791382            } else if (cc == '>') {
    13801383                emitParseError();
     
    13841387                emitParseError();
    13851388                notImplemented();
    1386                 m_state = BogusDOCTYPEState;
     1389                ADVANCE_TO(BogusDOCTYPEState);
    13871390            }
    13881391            // FIXME: Handle EOF properly.
     
    13961399            else if (cc == '"') {
    13971400                m_token->setPublicIdentifierToEmptyString();
    1398                 m_state = DOCTYPEPublicIdentifierDoubleQuotedState;
     1401                ADVANCE_TO(DOCTYPEPublicIdentifierDoubleQuotedState);
    13991402            } else if (cc == '\'') {
    14001403                m_token->setPublicIdentifierToEmptyString();
    1401                 m_state = DOCTYPEPublicIdentifierSingleQuotedState;
     1404                ADVANCE_TO(DOCTYPEPublicIdentifierSingleQuotedState);
    14021405            } else if (cc == '>') {
    14031406                emitParseError();
     
    14071410                emitParseError();
    14081411                notImplemented();
    1409                 m_state = BogusDOCTYPEState;
     1412                ADVANCE_TO(BogusDOCTYPEState);
    14101413            }
    14111414            // FIXME: Handle EOF properly.
     
    14161419        BEGIN_STATE(DOCTYPEPublicIdentifierDoubleQuotedState) {
    14171420            if (cc == '"')
    1418                 m_state = AfterDOCTYPEPublicIdentifierState;
     1421                ADVANCE_TO(AfterDOCTYPEPublicIdentifierState);
    14191422            else if (cc == '>') {
    14201423                emitParseError();
     
    14301433        BEGIN_STATE(DOCTYPEPublicIdentifierSingleQuotedState) {
    14311434            if (cc == '\'')
    1432                 m_state = AfterDOCTYPEPublicIdentifierState;
     1435                ADVANCE_TO(AfterDOCTYPEPublicIdentifierState);
    14331436            else if (cc == '>') {
    14341437                emitParseError();
     
    14441447        BEGIN_STATE(AfterDOCTYPEPublicIdentifierState) {
    14451448            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1446                 m_state = BetweenDOCTYPEPublicAndSystemIdentifiersState;
     1449                ADVANCE_TO(BetweenDOCTYPEPublicAndSystemIdentifiersState);
    14471450            else if (cc == '>') {
    14481451                EMIT_AND_RESUME_IN(DataState);
     
    14501453                emitParseError();
    14511454                m_token->setPublicIdentifierToEmptyString();
    1452                 m_state = DOCTYPESystemIdentifierDoubleQuotedState;
     1455                ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState);
    14531456            } else if (cc == '\'') {
    14541457                emitParseError();
    14551458                m_token->setPublicIdentifierToEmptyString();
    1456                 m_state = DOCTYPESystemIdentifierSingleQuotedState;
     1459                ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState);
    14571460            } else {
    14581461                emitParseError();
    14591462                notImplemented();
    1460                 m_state = BogusDOCTYPEState;
     1463                ADVANCE_TO(BogusDOCTYPEState);
    14611464            }
    14621465            // FIXME: Handle EOF properly.
     
    14671470        BEGIN_STATE(BetweenDOCTYPEPublicAndSystemIdentifiersState) {
    14681471            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1469                 m_state = BetweenDOCTYPEPublicAndSystemIdentifiersState;
     1472                ADVANCE_TO(BetweenDOCTYPEPublicAndSystemIdentifiersState);
    14701473            else if (cc == '>') {
    14711474                EMIT_AND_RESUME_IN(DataState);
    14721475            } else if (cc == '"') {
    14731476                m_token->setSystemIdentifierToEmptyString();
    1474                 m_state = DOCTYPESystemIdentifierDoubleQuotedState;
     1477                ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState);
    14751478            } else if (cc == '\'') {
    14761479                m_token->setSystemIdentifierToEmptyString();
    1477                 m_state = DOCTYPESystemIdentifierSingleQuotedState;
     1480                ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState);
    14781481            } else {
    14791482                emitParseError();
    14801483                notImplemented();
    1481                 m_state = BogusDOCTYPEState;
     1484                ADVANCE_TO(BogusDOCTYPEState);
    14821485            }
    14831486            // FIXME: Handle EOF properly.
     
    14881491        BEGIN_STATE(AfterDOCTYPESystemKeywordState) {
    14891492            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1490                 m_state = BeforeDOCTYPESystemIdentifierState;
     1493                ADVANCE_TO(BeforeDOCTYPESystemIdentifierState);
    14911494            else if (cc == '"') {
    14921495                emitParseError();
    14931496                m_token->setSystemIdentifierToEmptyString();
    1494                 m_state = DOCTYPESystemIdentifierDoubleQuotedState;
     1497                ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState);
    14951498            } else if (cc == '\'') {
    14961499                emitParseError();
    14971500                m_token->setSystemIdentifierToEmptyString();
    1498                 m_state = DOCTYPESystemIdentifierSingleQuotedState;
     1501                ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState);
    14991502            } else if (cc == '>') {
    15001503                emitParseError();
     
    15041507                emitParseError();
    15051508                notImplemented();
    1506                 m_state = BogusDOCTYPEState;
     1509                ADVANCE_TO(BogusDOCTYPEState);
    15071510            }
    15081511            // FIXME: Handle EOF properly.
     
    15161519            if (cc == '"') {
    15171520                m_token->setSystemIdentifierToEmptyString();
    1518                 m_state = DOCTYPESystemIdentifierDoubleQuotedState;
     1521                ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState);
    15191522            } else if (cc == '\'') {
    15201523                m_token->setSystemIdentifierToEmptyString();
    1521                 m_state = DOCTYPESystemIdentifierSingleQuotedState;
     1524                ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState);
    15221525            } else if (cc == '>') {
    15231526                emitParseError();
     
    15271530                emitParseError();
    15281531                notImplemented();
    1529                 m_state = BogusDOCTYPEState;
     1532                ADVANCE_TO(BogusDOCTYPEState);
    15301533            }
    15311534            // FIXME: Handle EOF properly.
     
    15361539        BEGIN_STATE(DOCTYPESystemIdentifierDoubleQuotedState) {
    15371540            if (cc == '"')
    1538                 m_state = AfterDOCTYPESystemIdentifierState;
     1541                ADVANCE_TO(AfterDOCTYPESystemIdentifierState);
    15391542            else if (cc == '>') {
    15401543                emitParseError();
     
    15501553        BEGIN_STATE(DOCTYPESystemIdentifierSingleQuotedState) {
    15511554            if (cc == '\'')
    1552                 m_state = AfterDOCTYPESystemIdentifierState;
     1555                ADVANCE_TO(AfterDOCTYPESystemIdentifierState);
    15531556            else if (cc == '>') {
    15541557                emitParseError();
     
    15691572            } else {
    15701573                emitParseError();
    1571                 m_state = BogusDOCTYPEState;
     1574                ADVANCE_TO(BogusDOCTYPEState);
    15721575            }
    15731576            // FIXME: Handle EOF properly.
Note: See TracChangeset for help on using the changeset viewer.