Changeset 60711 in webkit


Ignore:
Timestamp:
Jun 4, 2010 2:56: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

Make all the state transitions in the machine explicit. This allows us
to remove all the break statements, which won't work correctly after we
change the macro definitions.

Also, while I was looking at every line of code, I fixed a bunch of the
one-line-if style errors introduces in my previous patches.

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

Legend:

Unmodified
Added
Removed

  • trunk/WebCore/ChangeLog

    r60708 r60711  
     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        Make all the state transitions in the machine explicit.  This allows us
     9        to remove all the break statements, which won't work correctly after we
     10        change the macro definitions.
     11
     12        Also, while I was looking at every line of code, I fixed a bunch of the
     13        one-line-if style errors introduces in my previous patches.
     14
     15        * html/HTML5Lexer.cpp:
     16        (WebCore::HTML5Lexer::nextToken):
     17
    1182010-06-04  Gavin Barraclough  <barraclough@apple.com>
    219

  • trunk/WebCore/html/HTML5Lexer.cpp

    r60704 r60711  
    326326        emitCurrentToken();                                                 \
    327327        m_state = DataState;                                                \
     328        goto breakLabel;                                                    \
    328329    } while (false)
    329330
    330331#define ADVANCE_TO(stateName)                                               \
    331     m_state = stateName                                                     \
    332 
    333 // We'd like to use the standard do { } while (false) pattern here, but it
    334 // doesn't play nicely with continue.
     332    do {                                                                    \
     333        m_state = stateName;                                                \
     334        goto breakLabel;                                                    \
     335    } while (false)
     336
    335337#define RECONSUME_IN(stateName)                                             \
    336     {                                                                       \
     338    do {                                                                    \
    337339        m_state = stateName;                                                \
    338         continue;                                                           \
    339     }
     340        goto continueLabel;                                                 \
     341    } while (false)
    340342
    341343#define FLUSH_EMIT_AND_RESUME_IN(stateName)                                 \
    342     {                                                                       \
     344    do {                                                                    \
    343345        m_state = stateName;                                                \
    344346        maybeFlushBufferedEndTag();                                         \
    345         break;                                                              \
    346     }
     347        goto breakLabel;                                                    \
     348    } while (false)
    347349
    348350// When we move away from using a jump table, these macros will be different.
    … …  
    390392            }
    391393            ADVANCE_TO(TagOpenState);
    392         } else
    393             emitCharacter(cc);
    394         break;
     394        } else {
     395            emitCharacter(cc);
     396            ADVANCE_TO(DataState);
     397        }
    395398    }
    396399    END_STATE()
    … …  
    408411        else if (cc == '<')
    409412            ADVANCE_TO(RCDATALessThanSignState);
    410         else
    411             emitCharacter(cc);
    412         break;
     413        else {
     414            emitCharacter(cc);
     415            ADVANCE_TO(RCDATAState);
     416        }
    413417    }
    414418    END_STATE()
    … …  
    424428        if (cc == '<')
    425429            ADVANCE_TO(RAWTEXTLessThanSignState);
    426         else
    427             emitCharacter(cc);
    428         break;
     430        else {
     431            emitCharacter(cc);
     432            ADVANCE_TO(RAWTEXTState);
     433        }
    429434    }
    430435    END_STATE()
    … …  
    433438        if (cc == '<')
    434439            ADVANCE_TO(ScriptDataLessThanSignState);
    435         else
    436             emitCharacter(cc);
    437         break;
     440        else {
     441            emitCharacter(cc);
     442            ADVANCE_TO(ScriptDataState);
     443        }
    438444    }
    439445    END_STATE()
    … …  
    441447    BEGIN_STATE(PLAINTEXTState) {
    442448        emitCharacter(cc);
    443         break;
     449        ADVANCE_TO(PLAINTEXTState);
    444450    }
    445451    END_STATE()
    … …  
    467473            RECONSUME_IN(DataState);
    468474        }
    469         break;
    470475    }
    471476    END_STATE()
    … …  
    486491        }
    487492        // FIXME: Handle EOF properly.
    488         break;
    489493    }
    490494    END_STATE()
    … …  
    497501        else if (cc == '>') {
    498502            EMIT_AND_RESUME_IN(DataState);
    499         } else if (cc >= 'A' && cc <= 'Z')
     503        } else if (cc >= 'A' && cc <= 'Z') {
    500504            m_token->appendToName(toLowerCase(cc));
    501         else
     505            ADVANCE_TO(TagNameState);
     506        } else {
    502507            m_token->appendToName(cc);
    503         // FIXME: Handle EOF properly.
    504         break;
     508            ADVANCE_TO(TagNameState);
     509        }
     510        // FIXME: Handle EOF properly.
    505511    }
    506512    END_STATE()
    … …  
    515521            RECONSUME_IN(RCDATAState);
    516522        }
    517         break;
    518523    }
    519524    END_STATE()
    … …  
    533538            RECONSUME_IN(RCDATAState);
    534539        }
    535         break;
    536540    }
    537541    END_STATE()
    … …  
    541545            m_temporaryBuffer.append(cc);
    542546            addToPossibleEndTag(toLowerCase(cc));
     547            ADVANCE_TO(RCDATAEndTagNameState);
    543548        } else if (cc >= 'a' && cc <= 'z') {
    544549            m_temporaryBuffer.append(cc);
    545550            addToPossibleEndTag(cc);
     551            ADVANCE_TO(RCDATAEndTagNameState);
    546552        } else {
    547553            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ') {
    548                 if (isAppropriateEndTag()) {
     554                if (isAppropriateEndTag())
    549555                    FLUSH_AND_ADVANCE_TO(BeforeAttributeNameState);
    550                 }
    551556            } else if (cc == '/') {
    552                 if (isAppropriateEndTag()) {
     557                if (isAppropriateEndTag())
    553558                    FLUSH_AND_ADVANCE_TO(SelfClosingStartTagState);
    554                 }
    555559            } else if (cc == '>') {
    556                 if (isAppropriateEndTag()) {
     560                if (isAppropriateEndTag())
    557561                    FLUSH_EMIT_AND_RESUME_IN(DataState);
    558                 }
    559562            }
    560563            emitCharacter('<');
    … …  
    564567            RECONSUME_IN(RCDATAState);
    565568        }
    566         break;
    567569    }
    568570    END_STATE()
    … …  
    577579            RECONSUME_IN(RAWTEXTState);
    578580        }
    579         break;
    580581    }
    581582    END_STATE()
    … …  
    595596            RECONSUME_IN(RAWTEXTState);
    596597        }
    597         break;
    598598    }
    599599    END_STATE()
    … …  
    603603            m_temporaryBuffer.append(cc);
    604604            addToPossibleEndTag(toLowerCase(cc));
     605            ADVANCE_TO(RAWTEXTEndTagNameState);
    605606        } else if (cc >= 'a' && cc <= 'z') {
    606607            m_temporaryBuffer.append(cc);
    607608            addToPossibleEndTag(cc);
     609            ADVANCE_TO(RAWTEXTEndTagNameState);
    608610        } else {
    609611            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ') {
    610                 if (isAppropriateEndTag()) {
     612                if (isAppropriateEndTag())
    611613                    FLUSH_AND_ADVANCE_TO(BeforeAttributeNameState);
    612                 }
    613614            } else if (cc == '/') {
    614                 if (isAppropriateEndTag()) {
     615                if (isAppropriateEndTag())
    615616                    FLUSH_AND_ADVANCE_TO(SelfClosingStartTagState);
    616                 }
    617617            } else if (cc == '>') {
    618                 if (isAppropriateEndTag()) {
     618                if (isAppropriateEndTag())
    619619                    FLUSH_EMIT_AND_RESUME_IN(DataState);
    620                 }
    621620            }
    622621            emitCharacter('<');
    … …  
    626625            RECONSUME_IN(RAWTEXTState);
    627626        }
    628         break;
    629627    }
    630628    END_STATE()
    … …  
    643641            RECONSUME_IN(ScriptDataState);
    644642        }
    645         break;
    646643    }
    647644    END_STATE()
    … …  
    661658            RECONSUME_IN(ScriptDataState);
    662659        }
    663         break;
    664660    }
    665661    END_STATE()
    … …  
    669665            m_temporaryBuffer.append(cc);
    670666            addToPossibleEndTag(toLowerCase(cc));
     667            ADVANCE_TO(ScriptDataEndTagNameState);
    671668        } else if (cc >= 'a' && cc <= 'z') {
    672669            m_temporaryBuffer.append(cc);
    673670            addToPossibleEndTag(cc);
     671            ADVANCE_TO(ScriptDataEndTagNameState);
    674672        } else {
    675673            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ') {
    676                 if (isAppropriateEndTag()) {
     674                if (isAppropriateEndTag())
    677675                    FLUSH_AND_ADVANCE_TO(BeforeAttributeNameState);
    678                 }
    679676            } else if (cc == '/') {
    680                 if (isAppropriateEndTag()) {
     677                if (isAppropriateEndTag())
    681678                    FLUSH_AND_ADVANCE_TO(SelfClosingStartTagState);
    682                 }
    683679            } else if (cc == '>') {
    684                 if (isAppropriateEndTag()) {
     680                if (isAppropriateEndTag())
    685681                    FLUSH_EMIT_AND_RESUME_IN(DataState);
    686                 }
    687682            }
    688683            emitCharacter('<');
    … …  
    692687            RECONSUME_IN(ScriptDataState);
    693688        }
    694         break;
    695689    }
    696690    END_STATE()
    … …  
    700694            emitCharacter(cc);
    701695            ADVANCE_TO(ScriptDataEscapeStartDashState);
    702         } else {
     696        } else
    703697            RECONSUME_IN(ScriptDataState);
    704         }
    705         break;
    706698    }
    707699    END_STATE()
    … …  
    711703            emitCharacter(cc);
    712704            ADVANCE_TO(ScriptDataEscapedDashDashState);
    713         } else {
     705        } else
    714706            RECONSUME_IN(ScriptDataState);
    715         }
    716         break;
    717707    }
    718708    END_STATE()
    … …  
    742732        }
    743733        // FIXME: Handle EOF properly.
    744         break;
    745734    }
    746735    END_STATE()
    747736
    748737    BEGIN_STATE(ScriptDataEscapedDashDashState) {
    749         if (cc == '-')
    750             emitCharacter(cc);
    751         else if (cc == '<')
     738        if (cc == '-') {
     739            emitCharacter(cc);
     740            ADVANCE_TO(ScriptDataEscapedDashDashState);
     741        } else if (cc == '<')
    752742            ADVANCE_TO(ScriptDataEscapedLessThanSignState);
    753743        else if (cc == '>') {
    … …  
    759749        }
    760750        // FIXME: Handle EOF properly.
    761         break;
    762751    }
    763752    END_STATE()
    … …  
    784773            RECONSUME_IN(ScriptDataEscapedState);
    785774        }
    786         break;
    787775    }
    788776    END_STATE()
    … …  
    802790            RECONSUME_IN(ScriptDataEscapedState);
    803791        }
    804         break;
    805792    }
    806793    END_STATE()
    … …  
    810797            m_temporaryBuffer.append(cc);
    811798            addToPossibleEndTag(toLowerCase(cc));
     799            ADVANCE_TO(ScriptDataEscapedEndTagNameState);
    812800        } else if (cc >= 'a' && cc <= 'z') {
    813801            m_temporaryBuffer.append(cc);
    814802            addToPossibleEndTag(cc);
     803            ADVANCE_TO(ScriptDataEscapedEndTagNameState);
    815804        } else {
    816805            if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ') {
    817                 if (isAppropriateEndTag()) {
     806                if (isAppropriateEndTag())
    818807                    FLUSH_AND_ADVANCE_TO(BeforeAttributeNameState);
    819                 }
    820808            } else if (cc == '/') {
    821                 if (isAppropriateEndTag()) {
     809                if (isAppropriateEndTag())
    822810                    FLUSH_AND_ADVANCE_TO(SelfClosingStartTagState);
    823                 }
    824811            } else if (cc == '>') {
    825                 if (isAppropriateEndTag()) {
     812                if (isAppropriateEndTag())
    826813                    FLUSH_EMIT_AND_RESUME_IN(DataState);
    827                 }
    828814            }
    829815            emitCharacter('<');
    … …  
    833819            RECONSUME_IN(ScriptDataEscapedState);
    834820        }
    835         break;
    836821    }
    837822    END_STATE()
    … …  
    847832            emitCharacter(cc);
    848833            m_temporaryBuffer.append(toLowerCase(cc));
     834            ADVANCE_TO(ScriptDataDoubleEscapeStartState);
    849835        } else if (cc >= 'a' && cc <= 'z') {
    850836            emitCharacter(cc);
    851837            m_temporaryBuffer.append(cc);
     838            ADVANCE_TO(ScriptDataDoubleEscapeStartState);
    852839        } else {
    853840            RECONSUME_IN(ScriptDataEscapedState);
    854841        }
    855         break;
    856842    }
    857843    END_STATE()
    … …  
    864850            emitCharacter(cc);
    865851            ADVANCE_TO(ScriptDataDoubleEscapedLessThanSignState);
    866         } else
    867             emitCharacter(cc);
    868         // FIXME: Handle EOF properly.
    869         break;
     852        } else {
     853            emitCharacter(cc);
     854            ADVANCE_TO(ScriptDataDoubleEscapedState);
     855        }
     856        // FIXME: Handle EOF properly.
    870857    }
    871858    END_STATE()
    … …  
    883870        }
    884871        // FIXME: Handle EOF properly.
    885         break;
    886872    }
    887873    END_STATE()
    888874
    889875    BEGIN_STATE(ScriptDataDoubleEscapedDashDashState) {
    890         if (cc == '-')
    891             emitCharacter(cc);
    892         else if (cc == '<') {
     876        if (cc == '-') {
     877            emitCharacter(cc);
     878            ADVANCE_TO(ScriptDataDoubleEscapedDashDashState);
     879        } else if (cc == '<') {
    893880            emitCharacter(cc);
    894881            ADVANCE_TO(ScriptDataDoubleEscapedLessThanSignState);
    … …  
    901888        }
    902889        // FIXME: Handle EOF properly.
    903         break;
    904890    }
    905891    END_STATE()
    … …  
    910896            m_temporaryBuffer.clear();
    911897            ADVANCE_TO(ScriptDataDoubleEscapeEndState);
    912         } else {
     898        } else
    913899            RECONSUME_IN(ScriptDataDoubleEscapedState);
    914         }
    915         break;
    916900    }
    917901    END_STATE()
    … …  
    927911            emitCharacter(cc);
    928912            m_temporaryBuffer.append(toLowerCase(cc));
     913            ADVANCE_TO(ScriptDataDoubleEscapeEndState);
    929914        } else if (cc >= 'a' && cc <= 'z') {
    930915            emitCharacter(cc);
    931916            m_temporaryBuffer.append(cc);
    932         } else {
     917            ADVANCE_TO(ScriptDataDoubleEscapeEndState);
     918        } else
    933919            RECONSUME_IN(ScriptDataDoubleEscapedState);
    934         }
    935         break;
    936920    }
    937921    END_STATE()
    … …  
    939923    BEGIN_STATE(BeforeAttributeNameState) {
    940924        if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    941             break;
     925            ADVANCE_TO(BeforeAttributeNameState);
    942926        else if (cc == '/')
    943927            ADVANCE_TO(SelfClosingStartTagState);
    944         else if (cc == '>') {
    945             EMIT_AND_RESUME_IN(DataState);
    946         } else if (cc >= 'A' && cc <= 'Z') {
     928        else if (cc == '>')
     929            EMIT_AND_RESUME_IN(DataState);
     930        else if (cc >= 'A' && cc <= 'Z') {
    947931            m_token->addNewAttribute();
    948932            m_token->appendToAttributeName(toLowerCase(cc));
    … …  
    956940        }
    957941        // FIXME: Handle EOF properly.
    958         break;
    959942    }
    960943    END_STATE()
    … …  
    967950        else if (cc == '=')
    968951            ADVANCE_TO(BeforeAttributeValueState);
    969         else if (cc == '>') {
    970             EMIT_AND_RESUME_IN(DataState);
    971         } else if (cc >= 'A' && cc <= 'Z')
     952        else if (cc == '>')
     953            EMIT_AND_RESUME_IN(DataState);
     954        else if (cc >= 'A' && cc <= 'Z') {
    972955            m_token->appendToAttributeName(toLowerCase(cc));
    973         else {
     956            ADVANCE_TO(AttributeNameState);
     957        } else {
    974958            if (cc == '"' || cc == '\'' || cc == '<' || cc == '=')
    975959                emitParseError();
    … …  
    978962        }
    979963        // FIXME: Handle EOF properly.
    980         break;
    981964    }
    982965    END_STATE()
    … …  
    984967    BEGIN_STATE(AfterAttributeNameState) {
    985968        if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    986             break;
     969            ADVANCE_TO(AfterAttributeNameState);
    987970        else if (cc == '/')
    988971            ADVANCE_TO(SelfClosingStartTagState);
    … …  
    1003986        }
    1004987        // FIXME: Handle EOF properly.
    1005         break;
    1006988    }
    1007989    END_STATE()
    … …  
    1009991    BEGIN_STATE(BeforeAttributeValueState) {
    1010992        if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1011             break;
     993            ADVANCE_TO(BeforeAttributeValueState);
    1012994        else if (cc == '"')
    1013995            ADVANCE_TO(AttributeValueDoubleQuotedState);
    1014         else if (cc == '&') {
     996        else if (cc == '&')
    1015997            RECONSUME_IN(AttributeValueUnquotedState);
    1016         } else if (cc == '\'')
     998        else if (cc == '\'')
    1017999            ADVANCE_TO(AttributeValueSingleQuotedState);
    10181000        else if (cc == '>') {
    … …  
    10251007            ADVANCE_TO(AttributeValueUnquotedState);
    10261008        }
    1027         break;
    10281009    }
    10291010    END_STATE()
    … …  
    10351016            m_additionalAllowedCharacter = '"';
    10361017            ADVANCE_TO(CharacterReferenceInAttributeValueState);
    1037         } else
     1018        } else {
    10381019            m_token->appendToAttributeValue(cc);
    1039         // FIXME: Handle EOF properly.
    1040         break;
     1020            ADVANCE_TO(AttributeValueDoubleQuotedState);
     1021        }
     1022        // FIXME: Handle EOF properly.
    10411023    }
    10421024    END_STATE()
    … …  
    10481030            m_additionalAllowedCharacter = '\'';
    10491031            ADVANCE_TO(CharacterReferenceInAttributeValueState);
    1050         } else
     1032        } else {
    10511033            m_token->appendToAttributeValue(cc);
    1052         // FIXME: Handle EOF properly.
    1053         break;
     1034            ADVANCE_TO(AttributeValueSingleQuotedState);
     1035        }
     1036        // FIXME: Handle EOF properly.
    10541037    }
    10551038    END_STATE()
    … …  
    10611044            m_additionalAllowedCharacter = '>';
    10621045            ADVANCE_TO(CharacterReferenceInAttributeValueState);
    1063         } else if (cc == '>') {
    1064             EMIT_AND_RESUME_IN(DataState);
    1065         } else {
     1046        } else if (cc == '>')
     1047            EMIT_AND_RESUME_IN(DataState);
     1048        else {
    10661049            if (cc == '"' || cc == '\'' || cc == '<' || cc == '=' || cc == '`')
    10671050                emitParseError();
    10681051            m_token->appendToAttributeValue(cc);
    1069         }
    1070         // FIXME: Handle EOF properly.
    1071         break;
     1052            ADVANCE_TO(AttributeValueUnquotedState);
     1053        }
     1054        // FIXME: Handle EOF properly.
    10721055    }
    10731056    END_STATE()
    … …  
    10911074        // state can be determined by m_additionalAllowedCharacter.
    10921075        if (m_additionalAllowedCharacter == '"')
    1093             RECONSUME_IN(AttributeValueDoubleQuotedState)
     1076            RECONSUME_IN(AttributeValueDoubleQuotedState);
    10941077        else if (m_additionalAllowedCharacter == '\'')
    1095             RECONSUME_IN(AttributeValueSingleQuotedState)
     1078            RECONSUME_IN(AttributeValueSingleQuotedState);
    10961079        else if (m_additionalAllowedCharacter == '>')
    1097             RECONSUME_IN(AttributeValueUnquotedState)
     1080            RECONSUME_IN(AttributeValueUnquotedState);
    10981081        else
    10991082            ASSERT_NOT_REACHED();
    1100         break;
    11011083    }
    11021084    END_STATE()
    … …  
    11071089        else if (cc == '/')
    11081090            ADVANCE_TO(SelfClosingStartTagState);
    1109         else if (cc == '>') {
    1110             EMIT_AND_RESUME_IN(DataState);
    1111         } else {
     1091        else if (cc == '>')
     1092            EMIT_AND_RESUME_IN(DataState);
     1093        else {
    11121094            emitParseError();
    11131095            RECONSUME_IN(BeforeAttributeNameState);
    11141096        }
    11151097        // FIXME: Handle EOF properly.
    1116         break;
    11171098    }
    11181099    END_STATE()
    … …  
    11271108        }
    11281109        // FIXME: Handle EOF properly.
    1129         break;
    11301110    }
    11311111    END_STATE()
    … …  
    11871167        }
    11881168        // FIXME: Handle EOF properly.
    1189         break;
    11901169    }
    11911170    END_STATE()
    … …  
    12031182        }
    12041183        // FIXME: Handle EOF properly.
    1205         break;
    12061184    }
    12071185    END_STATE()
    … …  
    12101188        if (cc == '-')
    12111189            ADVANCE_TO(CommentEndDashState);
    1212         else
     1190        else {
    12131191            m_token->appendToComment(cc);
    1214         // FIXME: Handle EOF properly.
    1215         break;
     1192            ADVANCE_TO(CommentState);
     1193        }
     1194        // FIXME: Handle EOF properly.
    12161195    }
    12171196    END_STATE()
    … …  
    12261205        }
    12271206        // FIXME: Handle EOF properly.
    1228         break;
    12291207    }
    12301208    END_STATE()
    12311209
    12321210    BEGIN_STATE(CommentEndState) {
    1233         if (cc == '>') {
    1234             EMIT_AND_RESUME_IN(DataState);
    1235         } else if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ') {
     1211        if (cc == '>')
     1212            EMIT_AND_RESUME_IN(DataState);
     1213        else if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ') {
    12361214            emitParseError();
    12371215            m_token->appendToComment('-');
    … …  
    12461224            m_token->appendToComment('-');
    12471225            m_token->appendToComment(cc);
     1226            ADVANCE_TO(CommentEndState);
    12481227        } else {
    12491228            emitParseError();
    … …  
    12541233        }
    12551234        // FIXME: Handle EOF properly.
    1256         break;
    12571235    }
    12581236    END_STATE()
    … …  
    12741252        }
    12751253        // FIXME: Handle EOF properly.
    1276         break;
    12771254    }
    12781255    END_STATE()
    12791256
    12801257    BEGIN_STATE(CommentEndSpaceState) {
    1281         if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
     1258        if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ') {
    12821259            m_token->appendToComment(cc);
    1283         else if (cc == '-')
     1260            ADVANCE_TO(CommentEndSpaceState);
     1261        } else if (cc == '-')
    12841262            ADVANCE_TO(CommentEndDashState);
    1285         else if (cc == '>') {
    1286             EMIT_AND_RESUME_IN(DataState);
    1287         } else {
     1263        else if (cc == '>')
     1264            EMIT_AND_RESUME_IN(DataState);
     1265        else {
    12881266            m_token->appendToComment(cc);
    12891267            ADVANCE_TO(CommentState);
    12901268        }
    12911269        // FIXME: Handle EOF properly.
    1292         break;
    12931270    }
    12941271    END_STATE()
    … …  
    13021279        }
    13031280        // FIXME: Handle EOF properly.
    1304         break;
    13051281    }
    13061282    END_STATE()
    … …  
    13081284    BEGIN_STATE(BeforeDOCTYPENameState) {
    13091285        if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1310             break;
     1286            ADVANCE_TO(BeforeDOCTYPENameState);
    13111287        else if (cc >= 'A' && cc <= 'Z') {
    13121288            m_token->beginDOCTYPE(toLowerCase(cc));
    … …  
    13221298        }
    13231299        // FIXME: Handle EOF properly.
    1324         break;
    13251300    }
    13261301    END_STATE()
    … …  
    13291304        if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    13301305            ADVANCE_TO(AfterDOCTYPENameState);
    1331         else if (cc == '>') {
    1332             EMIT_AND_RESUME_IN(DataState);
    1333         } else if (cc >= 'A' && cc <= 'Z')
     1306        else if (cc == '>')
     1307            EMIT_AND_RESUME_IN(DataState);
     1308        else if (cc >= 'A' && cc <= 'Z') {
    13341309            m_token->appendToName(toLowerCase(cc));
    1335         else
     1310            ADVANCE_TO(DOCTYPENameState);
     1311        } else {
    13361312            m_token->appendToName(cc);
    1337         // FIXME: Handle EOF properly.
    1338         break;
     1313            ADVANCE_TO(DOCTYPENameState);
     1314        }
     1315        // FIXME: Handle EOF properly.
    13391316    }
    13401317    END_STATE()
    … …  
    13421319    BEGIN_STATE(AfterDOCTYPENameState) {
    13431320        if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1344             break;
    1345         if (cc == '>') {
    1346             EMIT_AND_RESUME_IN(DataState);
    1347         } else {
     1321            ADVANCE_TO(AfterDOCTYPENameState);
     1322        if (cc == '>')
     1323            EMIT_AND_RESUME_IN(DataState);
     1324        else {
    13481325            DEFINE_STATIC_LOCAL(String, publicString, ("public"));
    13491326            DEFINE_STATIC_LOCAL(String, systemString, ("system"));
    … …  
    13681345        }
    13691346        // FIXME: Handle EOF properly.
    1370         break;
    13711347    }
    13721348    END_STATE()
    … …  
    13931369        }
    13941370        // FIXME: Handle EOF properly.
    1395         break;
    13961371    }
    13971372    END_STATE()
    … …  
    13991374    BEGIN_STATE(BeforeDOCTYPEPublicIdentifierState) {
    14001375        if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1401             break;
     1376            ADVANCE_TO(BeforeDOCTYPEPublicIdentifierState);
    14021377        else if (cc == '"') {
    14031378            m_token->setPublicIdentifierToEmptyString();
    … …  
    14161391        }
    14171392        // FIXME: Handle EOF properly.
    1418         break;
    14191393    }
    14201394    END_STATE()
    … …  
    14271401            notImplemented();
    14281402            EMIT_AND_RESUME_IN(DataState);
    1429         } else
     1403        } else {
    14301404            m_token->appendToPublicIdentifier(cc);
    1431         // FIXME: Handle EOF properly.
    1432         break;
     1405            ADVANCE_TO(DOCTYPEPublicIdentifierDoubleQuotedState);
     1406        }
     1407        // FIXME: Handle EOF properly.
    14331408    }
    14341409    END_STATE()
    … …  
    14411416            notImplemented();
    14421417            EMIT_AND_RESUME_IN(DataState);
    1443         } else
     1418        } else {
    14441419            m_token->appendToPublicIdentifier(cc);
    1445         // FIXME: Handle EOF properly.
    1446         break;
     1420            ADVANCE_TO(DOCTYPEPublicIdentifierSingleQuotedState);
     1421        }
     1422        // FIXME: Handle EOF properly.
    14471423    }
    14481424    END_STATE()
    … …  
    14511427        if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    14521428            ADVANCE_TO(BetweenDOCTYPEPublicAndSystemIdentifiersState);
    1453         else if (cc == '>') {
    1454             EMIT_AND_RESUME_IN(DataState);
    1455         } else if (cc == '"') {
     1429        else if (cc == '>')
     1430            EMIT_AND_RESUME_IN(DataState);
     1431        else if (cc == '"') {
    14561432            emitParseError();
    14571433            m_token->setPublicIdentifierToEmptyString();
    … …  
    14671443        }
    14681444        // FIXME: Handle EOF properly.
    1469         break;
    14701445    }
    14711446    END_STATE()
    … …  
    14741449        if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    14751450            ADVANCE_TO(BetweenDOCTYPEPublicAndSystemIdentifiersState);
    1476         else if (cc == '>') {
    1477             EMIT_AND_RESUME_IN(DataState);
    1478         } else if (cc == '"') {
     1451        else if (cc == '>')
     1452            EMIT_AND_RESUME_IN(DataState);
     1453        else if (cc == '"') {
    14791454            m_token->setSystemIdentifierToEmptyString();
    14801455            ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState);
    … …  
    14881463        }
    14891464        // FIXME: Handle EOF properly.
    1490         break;
    14911465    }
    14921466    END_STATE()
    … …  
    15131487        }
    15141488        // FIXME: Handle EOF properly.
    1515         break;
    15161489    }
    15171490    END_STATE()
    … …  
    15191492    BEGIN_STATE(BeforeDOCTYPESystemIdentifierState) {
    15201493        if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1521             break;
     1494            ADVANCE_TO(BeforeDOCTYPESystemIdentifierState);
    15221495        if (cc == '"') {
    15231496            m_token->setSystemIdentifierToEmptyString();
    … …  
    15361509        }
    15371510        // FIXME: Handle EOF properly.
    1538         break;
    15391511    }
    15401512    END_STATE()
    … …  
    15471519            notImplemented();
    15481520            EMIT_AND_RESUME_IN(DataState);
    1549         } else
     1521        } else {
    15501522            m_token->appendToSystemIdentifier(cc);
    1551         // FIXME: Handle EOF properly.
    1552         break;
     1523            ADVANCE_TO(DOCTYPESystemIdentifierDoubleQuotedState);
     1524        }
     1525        // FIXME: Handle EOF properly.
    15531526    }
    15541527    END_STATE()
    … …  
    15611534            notImplemented();
    15621535            EMIT_AND_RESUME_IN(DataState);
    1563         } else
     1536        } else {
    15641537            m_token->appendToSystemIdentifier(cc);
    1565         // FIXME: Handle EOF properly.
    1566         break;
     1538            ADVANCE_TO(DOCTYPESystemIdentifierSingleQuotedState);
     1539        }
     1540        // FIXME: Handle EOF properly.
    15671541    }
    15681542    END_STATE()
    … …  
    15701544    BEGIN_STATE(AfterDOCTYPESystemIdentifierState) {
    15711545        if (cc == '\x09' || cc == '\x0A' || cc == '\x0C' || cc == ' ')
    1572             break;
     1546            ADVANCE_TO(AfterDOCTYPESystemIdentifierState);
    15731547        else if (cc == '>') {
    15741548            EMIT_AND_RESUME_IN(DataState);
    … …  
    15781552        }
    15791553        // FIXME: Handle EOF properly.
    1580         break;
    15811554    }
    15821555    END_STATE()
    15831556
    15841557    BEGIN_STATE(BogusDOCTYPEState) {
    1585         if (cc == '>') {
    1586             EMIT_AND_RESUME_IN(DataState);
    1587         }
    1588         // FIXME: Handle EOF properly.
    1589         break;
     1558        if (cc == '>')
     1559            EMIT_AND_RESUME_IN(DataState);
     1560        ADVANCE_TO(BogusDOCTYPEState);
     1561        // FIXME: Handle EOF properly.
    15901562    }
    15911563    END_STATE()
    … …  
    15931565    BEGIN_STATE(CDATASectionState) {
    15941566        notImplemented();
    1595         break;
    1596     }
    1597     END_STATE()
    1598 
    1599     }
     1567        ADVANCE_TO(CDATASectionState);
     1568    }
     1569    END_STATE()
     1570
     1571    }
     1572
     1573breakLabel:
    16001574    source.advance(m_lineNumber);
    16011575    if (m_emitPending) {
    … …  
    16041578    }
    16051579
     1580continueLabel:
     1581    ; // We need an empty statement here to make continueLabel happy.
    16061582    } // Matches the "while" above.
    16071583
Note: See TracChangeset for help on using the changeset viewer.