Changeset 63024 in webkit


Ignore:
Timestamp:
Jul 9, 2010 6:25:50 PM (14 years ago)
Author:
oliver@apple.com
Message:

Tidy up lexer token ids
https://bugs.webkit.org/show_bug.cgi?id=42014

Reviewed by Darin Adler

Stop using character literals to identify single character tokens
and instead use symbolic names for all tokens.

  • parser/ASTBuilder.h:

(JSC::ASTBuilder::makeBinaryNode):

  • parser/JSParser.cpp:

(JSC::JSParser::consume):
(JSC::JSParser::match):
(JSC::JSParser::autoSemiColon):
(JSC::JSParser::JSParser):
(JSC::JSParser::parseProgram):
(JSC::JSParser::allowAutomaticSemicolon):
(JSC::JSParser::parseDoWhileStatement):
(JSC::JSParser::parseWhileStatement):
(JSC::JSParser::parseVarDeclarationList):
(JSC::JSParser::parseConstDeclarationList):
(JSC::JSParser::parseForStatement):
(JSC::JSParser::parseReturnStatement):
(JSC::JSParser::parseWithStatement):
(JSC::JSParser::parseSwitchStatement):
(JSC::JSParser::parseSwitchClauses):
(JSC::JSParser::parseSwitchDefaultClause):
(JSC::JSParser::parseTryStatement):
(JSC::JSParser::parseDebuggerStatement):
(JSC::JSParser::parseStatement):
(JSC::JSParser::parseFormalParameters):
(JSC::JSParser::parseFunctionInfo):
(JSC::JSParser::parseExpressionOrLabelStatement):
(JSC::JSParser::parseIfStatement):
(JSC::JSParser::parseExpression):
(JSC::JSParser::parseAssignmentExpression):
(JSC::JSParser::parseConditionalExpression):
(JSC::isUnaryOp):
(JSC::JSParser::isBinaryOperator):
(JSC::JSParser::parseBinaryExpression):
(JSC::JSParser::parseProperty):
(JSC::JSParser::parseObjectLiteral):
(JSC::JSParser::parseStrictObjectLiteral):
(JSC::JSParser::parseArrayLiteral):
(JSC::JSParser::parsePrimaryExpression):
(JSC::JSParser::parseArguments):
(JSC::JSParser::parseMemberExpression):
(JSC::JSParser::parseUnaryExpression):

  • parser/JSParser.h:

(JSC::):

  • parser/Lexer.cpp:

(JSC::):
(JSC::Lexer::lex):

  • parser/Lexer.h:
Location:
trunk/JavaScriptCore
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • trunk/JavaScriptCore/ChangeLog

    r63023 r63024  
     12010-07-09  Oliver Hunt  <oliver@apple.com>
     2
     3        Reviewed by Darin Adler.
     4
     5        Tidy up lexer token ids
     6        https://bugs.webkit.org/show_bug.cgi?id=42014
     7
     8        Stop using character literals to identify single character tokens
     9        and instead use symbolic names for all tokens.
     10
     11        * parser/ASTBuilder.h:
     12        (JSC::ASTBuilder::makeBinaryNode):
     13        * parser/JSParser.cpp:
     14        (JSC::JSParser::consume):
     15        (JSC::JSParser::match):
     16        (JSC::JSParser::autoSemiColon):
     17        (JSC::JSParser::JSParser):
     18        (JSC::JSParser::parseProgram):
     19        (JSC::JSParser::allowAutomaticSemicolon):
     20        (JSC::JSParser::parseDoWhileStatement):
     21        (JSC::JSParser::parseWhileStatement):
     22        (JSC::JSParser::parseVarDeclarationList):
     23        (JSC::JSParser::parseConstDeclarationList):
     24        (JSC::JSParser::parseForStatement):
     25        (JSC::JSParser::parseReturnStatement):
     26        (JSC::JSParser::parseWithStatement):
     27        (JSC::JSParser::parseSwitchStatement):
     28        (JSC::JSParser::parseSwitchClauses):
     29        (JSC::JSParser::parseSwitchDefaultClause):
     30        (JSC::JSParser::parseTryStatement):
     31        (JSC::JSParser::parseDebuggerStatement):
     32        (JSC::JSParser::parseStatement):
     33        (JSC::JSParser::parseFormalParameters):
     34        (JSC::JSParser::parseFunctionInfo):
     35        (JSC::JSParser::parseExpressionOrLabelStatement):
     36        (JSC::JSParser::parseIfStatement):
     37        (JSC::JSParser::parseExpression):
     38        (JSC::JSParser::parseAssignmentExpression):
     39        (JSC::JSParser::parseConditionalExpression):
     40        (JSC::isUnaryOp):
     41        (JSC::JSParser::isBinaryOperator):
     42        (JSC::JSParser::parseBinaryExpression):
     43        (JSC::JSParser::parseProperty):
     44        (JSC::JSParser::parseObjectLiteral):
     45        (JSC::JSParser::parseStrictObjectLiteral):
     46        (JSC::JSParser::parseArrayLiteral):
     47        (JSC::JSParser::parsePrimaryExpression):
     48        (JSC::JSParser::parseArguments):
     49        (JSC::JSParser::parseMemberExpression):
     50        (JSC::JSParser::parseUnaryExpression):
     51        * parser/JSParser.h:
     52        (JSC::):
     53        * parser/Lexer.cpp:
     54        (JSC::):
     55        (JSC::Lexer::lex):
     56        * parser/Lexer.h:
     57
    1582010-07-09  Gavin Barraclough  <barraclough@apple.com>
    259
  • trunk/JavaScriptCore/parser/ASTBuilder.h

    r62848 r63024  
    763763        return new (m_globalData) LogicalOpNode(m_globalData, lhs.first, rhs.first, OpLogicalAnd);
    764764
    765     case '|':
     765    case BITOR:
    766766        return new (m_globalData) BitOrNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
    767767
    768     case '^':
     768    case BITXOR:
    769769        return new (m_globalData) BitXOrNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
    770770
    771     case '&':
     771    case BITAND:
    772772        return new (m_globalData) BitAndNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
    773773
     
    784784        return new (m_globalData) NotStrictEqualNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
    785785
    786     case '<':
     786    case LT:
    787787        return new (m_globalData) LessNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
    788788
    789     case '>':
     789    case GT:
    790790        return new (m_globalData) GreaterNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
    791791
     
    817817        return new (m_globalData) UnsignedRightShiftNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
    818818
    819     case '+':
     819    case PLUS:
    820820        return makeAddNode(lhs.first, rhs.first, rhs.second.hasAssignment);
    821821
    822     case '-':
     822    case MINUS:
    823823        return makeSubNode(lhs.first, rhs.first, rhs.second.hasAssignment);
    824824
    825     case '*':
     825    case TIMES:
    826826        return makeMultNode(lhs.first, rhs.first, rhs.second.hasAssignment);
    827827
    828     case '/':
     828    case DIVIDE:
    829829        return makeDivNode(lhs.first, rhs.first, rhs.second.hasAssignment);
    830830
    831     case '%':
     831    case MOD:
    832832        return new (m_globalData) ModNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment);
    833833    }
  • trunk/JavaScriptCore/parser/JSParser.cpp

    r62995 r63024  
    9393    }
    9494
    95     bool consume(int expected)
     95    bool consume(JSTokenType expected)
    9696    {
    9797        bool result = m_token.m_type == expected;
     
    101101    }
    102102
    103     bool match(int expected)
     103    bool match(JSTokenType expected)
    104104    {
    105105        return m_token.m_type == expected;
     
    161161    enum FunctionRequirements { FunctionNoRequirements, FunctionNeedsName };
    162162    template <FunctionRequirements, class TreeBuilder> bool parseFunctionInfo(TreeBuilder&, const Identifier*&, TreeFormalParameterList&, TreeFunctionBody&, int& openBrace, int& closeBrace, int& bodyStartLine);
    163     int isBinaryOperator(int token);
     163    int isBinaryOperator(JSTokenType token);
    164164    bool allowAutomaticSemicolon();
    165165
    166166    bool autoSemiColon()
    167167    {
    168         if (token().m_type == ';') {
     168        if (token().m_type == SEMICOLON) {
    169169            next();
    170170            return true;
     
    233233    ASTBuilder context(m_globalData, m_lexer);
    234234    SourceElements* sourceElements = parseSourceElements<ASTBuilder>(context);
    235     if (!sourceElements || !consume(0))
     235    if (!sourceElements || !consume(EOFTOK))
    236236        return true;
    237237    m_globalData->parser->didFinishParsing(sourceElements, context.varDeclarations(), context.funcDeclarations(), context.features(),
     
    242242bool JSParser::allowAutomaticSemicolon()
    243243{
    244     return match(CLOSEBRACE) || match(0) || m_lexer->prevTerminator();
     244    return match(CLOSEBRACE) || match(EOFTOK) || m_lexer->prevTerminator();
    245245}
    246246
     
    293293    int endLine = tokenLine();
    294294    consumeOrFail(WHILE);
    295     consumeOrFail('(');
     295    consumeOrFail(OPENPAREN);
    296296    TreeExpression expr = parseExpression(context);
    297297    failIfFalse(expr);
    298     consumeOrFail(')');
    299     if (match(';'))
     298    consumeOrFail(CLOSEPAREN);
     299    if (match(SEMICOLON))
    300300        next(); // Always performs automatic semicolon insertion.
    301301    return context.createDoWhileStatement(statement, expr, startLine, endLine);
     
    307307    int startLine = tokenLine();
    308308    next();
    309     consumeOrFail('(');
     309    consumeOrFail(OPENPAREN);
    310310    TreeExpression expr = parseExpression(context);
    311311    failIfFalse(expr);
    312312    int endLine = tokenLine();
    313     consumeOrFail(')');
     313    consumeOrFail(CLOSEPAREN);
    314314    TreeStatement statement = parseStatement(context);
    315315    failIfFalse(statement);
     
    330330        lastIdent = name;
    331331        next();
    332         bool hasInitializer = match('=');
     332        bool hasInitializer = match(EQUAL);
    333333        context.addVar(name, (hasInitializer || (!m_allowsIn && match(INTOKEN))) ? DeclarationStacks::HasInitializer : 0);
    334334        if (hasInitializer) {
     
    348348                varDecls = context.combineCommaNodes(varDecls, node);
    349349        }
    350     } while (match(','));
     350    } while (match(COMMA));
    351351    return varDecls;
    352352}
     
    361361        const Identifier* name = token().m_data.ident;
    362362        next();
    363         bool hasInitializer = match('=');
     363        bool hasInitializer = match(EQUAL);
    364364        context.addVar(name, DeclarationStacks::IsConstant | (hasInitializer ? DeclarationStacks::HasInitializer : 0));
    365365        TreeExpression initializer = 0;
     
    371371        if (!constDecls)
    372372            constDecls = tail;
    373     } while (match(','));
     373    } while (match(COMMA));
    374374    return constDecls;
    375375}
     
    380380    int startLine = tokenLine();
    381381    next();
    382     consumeOrFail('(');
     382    consumeOrFail(OPENPAREN);
    383383    int nonLHSCount = m_nonLHSCount;
    384384    int declarations = 0;
     
    405405
    406406        // Remainder of a standard for loop is handled identically
    407         if (declarations > 1 || match(';'))
     407        if (declarations > 1 || match(SEMICOLON))
    408408            goto standardForLoop;
    409409
     
    418418
    419419        int endLine = tokenLine();
    420         consumeOrFail(')');
     420        consumeOrFail(CLOSEPAREN);
    421421
    422422        TreeStatement statement = parseStatement(context);
     
    426426    }
    427427
    428     if (!match(';')) {
     428    if (!match(SEMICOLON)) {
    429429        m_allowsIn = false;
    430430        declsStart = tokenStart();
     
    435435    }
    436436
    437     if (match(';')) {
     437    if (match(SEMICOLON)) {
    438438    standardForLoop:
    439439        // Standard for loop
     
    441441        TreeExpression condition = 0;
    442442
    443         if (!match(';')) {
     443        if (!match(SEMICOLON)) {
    444444            condition = parseExpression(context);
    445445            failIfFalse(condition);
    446446        }
    447         consumeOrFail(';');
     447        consumeOrFail(SEMICOLON);
    448448
    449449        TreeExpression increment = 0;
    450         if (!match(')')) {
     450        if (!match(CLOSEPAREN)) {
    451451            increment = parseExpression(context);
    452452            failIfFalse(increment);
    453453        }
    454454        int endLine = tokenLine();
    455         consumeOrFail(')');
     455        consumeOrFail(CLOSEPAREN);
    456456        TreeStatement statement = parseStatement(context);
    457457        failIfFalse(statement);
     
    466466    int exprEnd = lastTokenEnd();
    467467    int endLine = tokenLine();
    468     consumeOrFail(')');
     468    consumeOrFail(CLOSEPAREN);
    469469    TreeStatement statement = parseStatement(context);
    470470    failIfFalse(statement);
     
    524524    // as we need to ensure the a line break after the return correctly terminates
    525525    // the statement
    526     if (match(';'))
     526    if (match(SEMICOLON))
    527527        endLine  = tokenLine();
    528528    if (autoSemiColon())
     
    531531    failIfFalse(expr);
    532532    end = lastTokenEnd();
    533     if (match(';'))
     533    if (match(SEMICOLON))
    534534        endLine  = tokenLine();
    535535    failIfFalse(autoSemiColon());
     
    558558    int startLine = tokenLine();
    559559    next();
    560     consumeOrFail('(');
     560    consumeOrFail(OPENPAREN);
    561561    int start = tokenStart();
    562562    TreeExpression expr = parseExpression(context);
     
    565565
    566566    int endLine = tokenLine();
    567     consumeOrFail(')');
     567    consumeOrFail(CLOSEPAREN);
    568568   
    569569    TreeStatement statement = parseStatement(context);
     
    578578    int startLine = tokenLine();
    579579    next();
    580     consumeOrFail('(');
     580    consumeOrFail(OPENPAREN);
    581581    TreeExpression expr = parseExpression(context);
    582582    failIfFalse(expr);
    583583    int endLine = tokenLine();
    584     consumeOrFail(')');
     584    consumeOrFail(CLOSEPAREN);
    585585    consumeOrFail(OPENBRACE);
    586586
     
    606606    TreeExpression condition = parseExpression(context);
    607607    failIfFalse(condition);
    608     consumeOrFail(':');
     608    consumeOrFail(COLON);
    609609    TreeSourceElements statements = parseSourceElements(context);
    610610    failIfFalse(statements);
     
    617617        TreeExpression condition = parseExpression(context);
    618618        failIfFalse(condition);
    619         consumeOrFail(':');
     619        consumeOrFail(COLON);
    620620        TreeSourceElements statements = parseSourceElements(context);
    621621        failIfFalse(statements);
     
    631631        return 0;
    632632    next();
    633     consumeOrFail(':');
     633    consumeOrFail(COLON);
    634634    TreeSourceElements statements = parseSourceElements(context);
    635635    failIfFalse(statements);
     
    655655    if (match(CATCH)) {
    656656        next();
    657         consumeOrFail('(');
     657        consumeOrFail(OPENPAREN);
    658658        matchOrFail(IDENT);
    659659        ident = token().m_data.ident;
    660660        next();
    661         consumeOrFail(')');
     661        consumeOrFail(CLOSEPAREN);
    662662        matchOrFail(OPENBRACE);
    663663        int initialEvalCount = context.evalCount();
     
    683683    int endLine = startLine;
    684684    next();
    685     if (match(';'))
     685    if (match(SEMICOLON))
    686686        startLine = tokenLine();
    687687    failIfFalse(autoSemiColon());
     
    717717    case FUNCTION:
    718718        return parseFunctionDeclaration(context);
    719     case ';':
     719    case SEMICOLON:
    720720        next();
    721721        return context.createEmptyStatement();
     
    744744    case DEBUGGER:
    745745        return parseDebuggerStatement(context);
    746     case 0:
     746    case EOFTOK:
    747747    case CASE:
    748748    case CLOSEBRACE:
     
    764764    TreeFormalParameterList tail = list;
    765765    next();
    766     while (match(',')) {
     766    while (match(COMMA)) {
    767767        next();
    768768        matchOrFail(IDENT);
     
    791791    } else if (requirements == FunctionNeedsName)
    792792        return false;
    793     consumeOrFail('(');
     793    consumeOrFail(OPENPAREN);
    794794    bool usesArguments = false;
    795     if (!match(')')) {
     795    if (!match(CLOSEPAREN)) {
    796796        parameters = parseFormalParameters(context, usesArguments);
    797797        failIfFalse(parameters);
    798798    }
    799     consumeOrFail(')');
     799    consumeOrFail(CLOSEPAREN);
    800800    matchOrFail(OPENBRACE);
    801801
     
    848848    failIfFalse(currentToken + 1 == m_tokenCount);
    849849    int end = tokenEnd();
    850     consumeOrFail(':');
     850    consumeOrFail(COLON);
    851851    TreeStatement statement = parseStatement(context);
    852852    failIfFalse(statement);
     
    870870    next();
    871871
    872     consumeOrFail('(');
     872    consumeOrFail(OPENPAREN);
    873873
    874874    TreeExpression condition = parseExpression(context);
    875875    failIfFalse(condition);
    876876    int end = tokenLine();
    877     consumeOrFail(')');
     877    consumeOrFail(CLOSEPAREN);
    878878
    879879    TreeStatement trueBlock = parseStatement(context);
     
    899899        next();
    900900       
    901         consumeOrFail('(');
     901        consumeOrFail(OPENPAREN);
    902902       
    903903        TreeExpression innerCondition = parseExpression(context);
    904904        failIfFalse(innerCondition);
    905905        int innerEnd = tokenLine();
    906         consumeOrFail(')');
     906        consumeOrFail(CLOSEPAREN);
    907907       
    908908        TreeStatement innerTrueBlock = parseStatement(context);
     
    943943    TreeExpression node = parseAssignmentExpression(context);
    944944    failIfFalse(node);
    945     if (!match(','))
     945    if (!match(COMMA))
    946946        return node;
    947947    next();
     
    950950    failIfFalse(right);
    951951    typename TreeBuilder::Comma commaNode = context.createCommaExpr(node, right);
    952     while (match(',')) {
     952    while (match(COMMA)) {
    953953        next();
    954954        right = parseAssignmentExpression(context);
     
    976976    while (true) {
    977977        switch (token().m_type) {
    978         case '=': op = OpEqual; break;
     978        case EQUAL: op = OpEqual; break;
    979979        case PLUSEQUAL: op = OpPlusEq; break;
    980980        case MINUSEQUAL: op = OpMinusEq; break;
     
    10181018    TreeExpression cond = parseBinaryExpression(context);
    10191019    failIfFalse(cond);
    1020     if (!match('?'))
     1020    if (!match(QUESTION))
    10211021        return cond;
    10221022    m_nonLHSCount++;
    10231023    next();
    10241024    TreeExpression lhs = parseAssignmentExpression(context);
    1025     consumeOrFail(':');
     1025    consumeOrFail(COLON);
    10261026
    10271027    TreeExpression rhs = parseAssignmentExpression(context);
     
    10301030}
    10311031
    1032 static bool isUnaryOp(int token)
     1032static bool isUnaryOp(JSTokenType token)
    10331033{
    10341034    switch (token) {
    1035     case '!':
    1036     case '~':
    1037     case '-':
    1038     case '+':
     1035    case EXCLAMATION:
     1036    case TILDE:
     1037    case MINUS:
     1038    case PLUS:
    10391039    case PLUSPLUS:
    10401040    case AUTOPLUSPLUS:
     
    10501050}
    10511051
    1052 int JSParser::isBinaryOperator(int token)
     1052int JSParser::isBinaryOperator(JSTokenType token)
    10531053{
    10541054    switch (token) {
     
    10591059        return 2;
    10601060
    1061     case '|':
     1061    case BITOR:
    10621062        return 3;
    10631063
    1064     case '^':
     1064    case BITXOR:
    10651065        return 4;
    10661066
    1067     case '&':
     1067    case BITAND:
    10681068        return 5;
    10691069
     
    10741074        return 6;
    10751075
    1076     case '<':
    1077     case '>':
     1076    case LT:
     1077    case GT:
    10781078    case LE:
    10791079    case GE:
     
    10921092        return 8;
    10931093
    1094     case '+':
    1095     case '-':
     1094    case PLUS:
     1095    case MINUS:
    10961096        return 9;
    10971097
    1098     case '*':
    1099     case '/':
    1100     case '%':
     1098    case TIMES:
     1099    case DIVIDE:
     1100    case MOD:
    11011101        return 10;
    11021102
     
    11591159        const Identifier* ident = token().m_data.ident;
    11601160        next();
    1161         if (match(':')) {
     1161        if (match(COLON)) {
    11621162            next();
    11631163            TreeExpression node = parseAssignmentExpression(context);
     
    11861186        double propertyName = token().m_data.doubleValue;
    11871187        next();
    1188         consumeOrFail(':');
     1188        consumeOrFail(COLON);
    11891189        TreeExpression node = parseAssignmentExpression(context);
    11901190        failIfFalse(node);
    11911191        return context.template createProperty<complete>(m_globalData, propertyName, node, PropertyNode::Constant);
    11921192    }
    1193     }
    1194     fail();
     1193    default:
     1194        fail();
     1195    }
    11951196}
    11961197
     
    12141215    TreePropertyList propertyList = context.createPropertyList(property);
    12151216    TreePropertyList tail = propertyList;
    1216     while (match(',')) {
     1217    while (match(COMMA)) {
    12171218        next();
    12181219        // allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939
     
    12541255    TreePropertyList propertyList = context.createPropertyList(property);
    12551256    TreePropertyList tail = propertyList;
    1256     while (match(',')) {
     1257    while (match(COMMA)) {
    12571258        next();
    12581259        // allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939
     
    12821283template <class TreeBuilder> TreeExpression JSParser::parseArrayLiteral(TreeBuilder& context)
    12831284{
    1284     consumeOrFail('[');
     1285    consumeOrFail(OPENBRACKET);
    12851286
    12861287    int elisions = 0;
    1287     while (match(',')) {
     1288    while (match(COMMA)) {
    12881289        next();
    12891290        elisions++;
    12901291    }
    1291     if (match(']')) {
     1292    if (match(CLOSEBRACKET)) {
    12921293        next();
    12931294        return context.createArray(elisions);
     
    12991300    typename TreeBuilder::ElementList tail = elementList;
    13001301    elisions = 0;
    1301     while (match(',')) {
     1302    while (match(COMMA)) {
    13021303        next();
    13031304        elisions = 0;
    13041305
    1305         while (match(',')) {
     1306        while (match(COMMA)) {
    13061307            next();
    13071308            elisions++;
    13081309        }
    13091310
    1310         if (match(']')) {
     1311        if (match(CLOSEBRACKET)) {
    13111312            next();
    13121313            return context.createArray(elisions, elementList);
     
    13171318    }
    13181319
    1319     consumeOrFail(']');
     1320    consumeOrFail(CLOSEBRACKET);
    13201321
    13211322    return context.createArray(elementList);
     
    13271328    case OPENBRACE:
    13281329        return parseObjectLiteral(context);
    1329     case '[':
     1330    case OPENBRACKET:
    13301331        return parseArrayLiteral(context);
    1331     case '(': {
     1332    case OPENPAREN: {
    13321333        next();
    13331334        int oldNonLHSCount = m_nonLHSCount;
    13341335        TreeExpression result = parseExpression(context);
    13351336        m_nonLHSCount = oldNonLHSCount;
    1336         consumeOrFail(')');
     1337        consumeOrFail(CLOSEPAREN);
    13371338
    13381339        return result;
     
    13711372    }
    13721373    case DIVEQUAL:
    1373     case '/': {
     1374    case DIVIDE: {
    13741375        /* regexp */
    13751376        const Identifier* pattern;
     
    13841385        return context.createRegex(*pattern, *flags, start);
    13851386    }
    1386     }
    1387     fail();
     1387    default:
     1388        fail();
     1389    }
    13881390}
    13891391
    13901392template <class TreeBuilder> TreeArguments JSParser::parseArguments(TreeBuilder& context)
    13911393{
    1392     consumeOrFail('(');
    1393     if (match(')')) {
     1394    consumeOrFail(OPENPAREN);
     1395    if (match(CLOSEPAREN)) {
    13941396        next();
    13951397        return context.createArguments();
     
    14001402    TreeArgumentsList argList = context.createArgumentsList(firstArg);
    14011403    TreeArgumentsList tail = argList;
    1402     while (match(',')) {
     1404    while (match(COMMA)) {
    14031405        next();
    14041406        TreeExpression arg = parseAssignmentExpression(context);
     
    14061408        tail = context.createArgumentsList(tail, arg);
    14071409    }
    1408     consumeOrFail(')');
     1410    consumeOrFail(CLOSEPAREN);
    14091411    return context.createArguments(argList);
    14101412}
     
    14361438    while (true) {
    14371439        switch (token().m_type) {
    1438         case '[': {
     1440        case OPENBRACKET: {
    14391441            int expressionEnd = lastTokenEnd();
    14401442            next();
     
    14441446            failIfFalse(property);
    14451447            base = context.createBracketAccess(base, property, initialAssignments != m_assignmentCount, expressionStart, expressionEnd, tokenEnd());
    1446             if (!consume(']'))
     1448            if (!consume(CLOSEBRACKET))
    14471449                fail();
    14481450            m_nonLHSCount = nonLHSCount;
    14491451            break;
    14501452        }
    1451         case '(': {
     1453        case OPENPAREN: {
    14521454            if (newCount) {
    14531455                newCount--;
    1454                 if (match('(')) {
     1456                if (match(OPENPAREN)) {
    14551457                    int exprEnd = lastTokenEnd();
    14561458                    TreeArguments arguments = parseArguments(context);
     
    14691471            break;
    14701472        }
    1471         case '.': {
     1473        case DOT: {
    14721474            int expressionEnd = lastTokenEnd();
    14731475            next();
     
    15121514        next();
    15131515        break;
     1516    default:
     1517        break;
    15141518    }
    15151519
     
    15211525    while (tokenStackDepth) {
    15221526        switch (context.unaryTokenStackLastType(tokenStackDepth)) {
    1523         case '!':
     1527        case EXCLAMATION:
    15241528            expr = context.createLogicalNot(expr);
    15251529            break;
    1526         case '~':
     1530        case TILDE:
    15271531            expr = context.makeBitwiseNotNode(expr);
    15281532            break;
    1529         case '-':
     1533        case MINUS:
    15301534            expr = context.makeNegateNode(expr);
    15311535            break;
    1532         case '+':
     1536        case PLUS:
    15331537            expr = context.createUnaryPlus(expr);
    15341538            break;
  • trunk/JavaScriptCore/parser/JSParser.h

    r62995 r63024  
    3434
    3535enum JSTokenType {
    36     NULLTOKEN = 258,
    37     TRUETOKEN = 259,
    38     FALSETOKEN = 260,
    39     BREAK = 261,
    40     CASE = 262,
    41     DEFAULT = 263,
    42     FOR = 264,
    43     NEW = 265,
    44     VAR = 266,
    45     CONSTTOKEN = 267,
    46     CONTINUE = 268,
    47     FUNCTION = 269,
    48     RETURN = 270,
    49     VOIDTOKEN = 271,
    50     DELETETOKEN = 272,
    51     IF = 273,
    52     THISTOKEN = 274,
    53     DO = 275,
    54     WHILE = 276,
    55     INTOKEN = 277,
    56     INSTANCEOF = 278,
    57     TYPEOF = 279,
    58     SWITCH = 280,
    59     WITH = 281,
    60     RESERVED = 282,
    61     THROW = 283,
    62     TRY = 284,
    63     CATCH = 285,
    64     FINALLY = 286,
    65     DEBUGGER = 287,
    66     IF_WITHOUT_ELSE = 288,
    67     ELSE = 289,
    68     EQEQ = 290,
    69     NE = 291,
    70     STREQ = 292,
    71     STRNEQ = 293,
    72     LE = 294,
    73     GE = 295,
    74     OR = 296,
    75     AND = 297,
    76     PLUSPLUS = 298,
    77     MINUSMINUS = 299,
    78     LSHIFT = 300,
    79     RSHIFT = 301,
    80     URSHIFT = 302,
    81     PLUSEQUAL = 303,
    82     MINUSEQUAL = 304,
    83     MULTEQUAL = 305,
    84     DIVEQUAL = 306,
    85     LSHIFTEQUAL = 307,
    86     RSHIFTEQUAL = 308,
    87     URSHIFTEQUAL = 309,
    88     ANDEQUAL = 310,
    89     MODEQUAL = 311,
    90     XOREQUAL = 312,
    91     OREQUAL = 313,
    92     OPENBRACE = 314,
    93     CLOSEBRACE = 315,
    94     NUMBER = 316,
    95     IDENT = 317,
    96     STRING = 318,
    97     AUTOPLUSPLUS = 319,
    98     AUTOMINUSMINUS = 320
     36    NULLTOKEN,
     37    TRUETOKEN,
     38    FALSETOKEN,
     39    BREAK,
     40    CASE,
     41    DEFAULT,
     42    FOR,
     43    NEW,
     44    VAR,
     45    CONSTTOKEN,
     46    CONTINUE,
     47    FUNCTION,
     48    RETURN,
     49    VOIDTOKEN,
     50    DELETETOKEN,
     51    IF,
     52    THISTOKEN,
     53    DO,
     54    WHILE,
     55    INTOKEN,
     56    INSTANCEOF,
     57    TYPEOF,
     58    SWITCH,
     59    WITH,
     60    RESERVED,
     61    THROW,
     62    TRY,
     63    CATCH,
     64    FINALLY,
     65    DEBUGGER,
     66    IF_WITHOUT_ELSE,
     67    ELSE,
     68    EQUAL,
     69    EQEQ,
     70    NE,
     71    STREQ,
     72    STRNEQ,
     73    LT,
     74    GT,
     75    LE,
     76    GE,
     77    OR,
     78    AND,
     79    PLUSPLUS,
     80    MINUSMINUS,
     81    LSHIFT,
     82    RSHIFT,
     83    URSHIFT,
     84    PLUSEQUAL,
     85    MINUSEQUAL,
     86    MULTEQUAL,
     87    DIVEQUAL,
     88    LSHIFTEQUAL,
     89    RSHIFTEQUAL,
     90    URSHIFTEQUAL,
     91    ANDEQUAL,
     92    MODEQUAL,
     93    XOREQUAL,
     94    OREQUAL,
     95    BITOR,
     96    BITAND,
     97    BITXOR,
     98    PLUS,
     99    MINUS,
     100    TIMES,
     101    DIVIDE,
     102    MOD,
     103    OPENBRACE,
     104    CLOSEBRACE,
     105    OPENPAREN,
     106    CLOSEPAREN,
     107    OPENBRACKET,
     108    CLOSEBRACKET,
     109    COMMA,
     110    QUESTION,
     111    TILDE,
     112    EXCLAMATION,
     113    NUMBER,
     114    IDENT,
     115    STRING,
     116    AUTOPLUSPLUS,
     117    AUTOMINUSMINUS,
     118    SEMICOLON,
     119    COLON,
     120    DOT,
     121    ERRORTOK,
     122    EOFTOK
    99123};
    100124
     
    113137
    114138struct JSToken {
    115     int m_type;
     139    JSTokenType m_type;
    116140    JSTokenData m_data;
    117141    JSTokenInfo m_info;
  • trunk/JavaScriptCore/parser/Lexer.cpp

    r62995 r63024  
    5757    CharacterLineTerminator,
    5858    CharacterExclamationMark,
    59     CharacterSimple,
     59    CharacterOpenParen,
     60    CharacterCloseParen,
     61    CharacterOpenBracket,
     62    CharacterCloseBracket,
     63    CharacterComma,
     64    CharacterColon,
     65    CharacterQuestion,
     66    CharacterTilde,
    6067    CharacterQuote,
    6168    CharacterDot,
     
    8289
    8390// 128 ascii codes
    84 static unsigned char AsciiCharacters[128] = {
     91static unsigned short AsciiCharacters[128] = {
    8592/*   0 - Null               */ CharacterInvalid,
    8693/*   1 - Start of Heading   */ CharacterInvalid,
     
    123130/*  38 - &                  */ CharacterAnd,
    124131/*  39 - '                  */ CharacterQuote,
    125 /*  40 - (                  */ CharacterSimple,
    126 /*  41 - )                  */ CharacterSimple,
     132/*  40 - (                  */ CharacterOpenParen,
     133/*  41 - )                  */ CharacterCloseParen,
    127134/*  42 - *                  */ CharacterMultiply,
    128135/*  43 - +                  */ CharacterAdd,
    129 /*  44 - ,                  */ CharacterSimple,
     136/*  44 - ,                  */ CharacterComma,
    130137/*  45 - -                  */ CharacterSub,
    131138/*  46 - .                  */ CharacterDot,
     
    141148/*  56 - 8                  */ CharacterNumber,
    142149/*  57 - 9                  */ CharacterNumber,
    143 /*  58 - :                  */ CharacterSimple,
     150/*  58 - :                  */ CharacterColon,
    144151/*  59 - ;                  */ CharacterSemicolon,
    145152/*  60 - <                  */ CharacterLess,
    146153/*  61 - =                  */ CharacterEqual,
    147154/*  62 - >                  */ CharacterGreater,
    148 /*  63 - ?                  */ CharacterSimple,
     155/*  63 - ?                  */ CharacterQuestion,
    149156/*  64 - @                  */ CharacterInvalid,
    150157/*  65 - A                  */ CharacterAlpha,
     
    174181/*  89 - Y                  */ CharacterAlpha,
    175182/*  90 - Z                  */ CharacterAlpha,
    176 /*  91 - [                  */ CharacterSimple,
     183/*  91 - [                  */ CharacterOpenBracket,
    177184/*  92 - \                  */ CharacterBackSlash,
    178 /*  93 - ]                  */ CharacterSimple,
     185/*  93 - ]                  */ CharacterCloseBracket,
    179186/*  94 - ^                  */ CharacterXor,
    180187/*  95 - _                  */ CharacterAlpha,
     
    209216/* 124 - |                  */ CharacterOr,
    210217/* 125 - }                  */ CharacterCloseBrace,
    211 /* 126 - ~                  */ CharacterSimple,
     218/* 126 - ~                  */ CharacterTilde,
    212219/* 127 - Delete             */ CharacterInvalid,
    213220};
     
    466473}
    467474
    468 int Lexer::lex(JSTokenData* lvalp, JSTokenInfo* llocp)
     475JSTokenType Lexer::lex(JSTokenData* lvalp, JSTokenInfo* llocp)
    469476{
    470477    ASSERT(!m_error);
     
    472479    ASSERT(m_buffer16.isEmpty());
    473480
    474     int token = 0;
     481    JSTokenType token = ERRORTOK;
     482    int identChar = 0;
    475483    m_terminator = false;
    476484
     
    482490
    483491    if (UNLIKELY(m_current == -1))
    484         return 0;
     492        return EOFTOK;
    485493
    486494    m_delimited = false;
     
    517525                break;
    518526            }
    519             token = '>';
     527            token = GT;
    520528            break;
    521529        case CharacterEqual:
     
    531539                break;
    532540            }
    533             token = '=';
     541            token = EQUAL;
    534542            break;
    535543        case CharacterLess:
     
    554562                break;
    555563            }
    556             token = '<';
     564            token = LT;
    557565            break;
    558566        case CharacterExclamationMark:
     
    568576                break;
    569577            }
    570             token = '!';
     578            token = EXCLAMATION;
    571579            break;
    572580        case CharacterAdd:
     
    582590                break;
    583591            }
    584             token = '+';
     592            token = PLUS;
    585593            break;
    586594        case CharacterSub:
     
    600608                break;
    601609            }
    602             token = '-';
     610            token = MINUS;
    603611            break;
    604612        case CharacterMultiply:
     
    609617                break;
    610618            }
    611             token = '*';
     619            token = TIMES;
    612620            break;
    613621        case CharacterSlash:
     
    626634                break;
    627635            }
    628             token = '/';
     636            token = DIVIDE;
    629637            break;
    630638        case CharacterAnd:
     
    640648                break;
    641649            }
    642             token = '&';
     650            token = BITAND;
    643651            break;
    644652        case CharacterXor:
     
    649657                break;
    650658            }
    651             token = '^';
     659            token = BITXOR;
    652660            break;
    653661        case CharacterModulo:
     
    658666                break;
    659667            }
    660             token = '%';
     668            token = MOD;
    661669            break;
    662670        case CharacterOr:
     
    672680                break;
    673681            }
    674             token = '|';
     682            token = BITOR;
    675683            break;
    676684        case CharacterDot:
     
    680688                goto inNumberAfterDecimalPoint;
    681689            }
    682             token = '.';
    683             break;
    684         case CharacterSimple:
    685             token = m_current;
     690            token = DOT;
     691            break;
     692        case CharacterOpenParen:
     693            token = OPENPAREN;
     694            shift();
     695            break;
     696        case CharacterCloseParen:
     697            token = CLOSEPAREN;
     698            shift();
     699            break;
     700        case CharacterOpenBracket:
     701            token = OPENBRACKET;
     702            shift();
     703            break;
     704        case CharacterCloseBracket:
     705            token = CLOSEBRACKET;
     706            shift();
     707            break;
     708        case CharacterComma:
     709            token = COMMA;
     710            shift();
     711            break;
     712        case CharacterColon:
     713            token = COLON;
     714            shift();
     715            break;
     716        case CharacterQuestion:
     717            token = QUESTION;
     718            shift();
     719            break;
     720        case CharacterTilde:
     721            token = TILDE;
    686722            shift();
    687723            break;
     
    689725            m_delimited = true;
    690726            shift();
    691             token = ';';
     727            token = SEMICOLON;
    692728            break;
    693729        case CharacterOpenBrace:
     
    724760            m_terminator = true;
    725761            if (lastTokenWasRestrKeyword()) {
    726                 token = ';';
     762                token = SEMICOLON;
    727763                goto doneSemicolon;
    728764            }
     
    759795    shift();
    760796
    761     token = getUnicodeCharacter();
    762     if (UNLIKELY(token == -1))
     797    identChar = getUnicodeCharacter();
     798    if (UNLIKELY(identChar == -1))
    763799        goto returnError;
    764     if (UNLIKELY(!isIdentStart(token)))
     800    if (UNLIKELY(!isIdentStart(identChar)))
    765801        goto returnError;
    766802    goto inIdentifierAfterCharacterCheck;
     
    785821            goto returnError;
    786822        shift();
    787         token = getUnicodeCharacter();
    788         if (UNLIKELY(token == -1))
     823        identChar = getUnicodeCharacter();
     824        if (UNLIKELY(identChar == -1))
    789825            goto returnError;
    790         if (UNLIKELY(!isIdentPart(token)))
     826        if (UNLIKELY(!isIdentPart(identChar)))
    791827            goto returnError;
    792828inIdentifierAfterCharacterCheck:
    793         record16(token);
     829        record16(identChar);
    794830
    795831        while (isIdentPart(m_current)) {
     
    803839    while (!isLineTerminator(m_current)) {
    804840        if (UNLIKELY(m_current == -1))
    805             return 0;
     841            return EOFTOK;
    806842        shift();
    807843    }
     
    9701006
    9711007doneSemicolon:
    972     token = ';';
     1008    token = SEMICOLON;
    9731009    m_delimited = true;
    9741010    goto returnToken;
     
    9871023    m_buffer16.resize(0);
    9881024    const HashEntry* entry = m_keywordTable.entry(m_globalData, *lvalp->ident);
    989     token = entry ? entry->lexerValue() : static_cast<int>(IDENT);
     1025    token = entry ? static_cast<JSTokenType>(entry->lexerValue()) : IDENT;
    9901026
    9911027    // Fall through into returnToken.
     
    10031039returnError:
    10041040    m_error = true;
    1005     return -1;
     1041    return ERRORTOK;
    10061042}
    10071043
  • trunk/JavaScriptCore/parser/Lexer.h

    r62849 r63024  
    2424#define Lexer_h
    2525
     26#include "JSParser.h"
    2627#include "Lookup.h"
    2728#include "ParserArena.h"
     
    3536namespace JSC {
    3637
    37     union JSTokenData;
    38     struct JSTokenInfo;
    3938    class RegExp;
    4039
     
    5251
    5352        // Functions for the parser itself.
    54         int lex(JSTokenData* lvalp, JSTokenInfo* llocp);
     53        JSTokenType lex(JSTokenData* lvalp, JSTokenInfo* llocp);
    5554        int lineNumber() const { return m_lineNumber; }
    5655        void setLastLineNumber(int lastLineNumber) { m_lastLineNumber = lastLineNumber; }
Note: See TracChangeset for help on using the changeset viewer.