Changeset 63024 in webkit
- Timestamp:
- Jul 9, 2010 6:25:50 PM (14 years ago)
- Location:
- trunk/JavaScriptCore
- Files:
-
- 6 edited
Legend:
- Unmodified
- Added
- Removed
-
trunk/JavaScriptCore/ChangeLog
r63023 r63024 1 2010-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 1 58 2010-07-09 Gavin Barraclough <barraclough@apple.com> 2 59 -
trunk/JavaScriptCore/parser/ASTBuilder.h
r62848 r63024 763 763 return new (m_globalData) LogicalOpNode(m_globalData, lhs.first, rhs.first, OpLogicalAnd); 764 764 765 case '|':765 case BITOR: 766 766 return new (m_globalData) BitOrNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment); 767 767 768 case '^':768 case BITXOR: 769 769 return new (m_globalData) BitXOrNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment); 770 770 771 case '&':771 case BITAND: 772 772 return new (m_globalData) BitAndNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment); 773 773 … … 784 784 return new (m_globalData) NotStrictEqualNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment); 785 785 786 case '<':786 case LT: 787 787 return new (m_globalData) LessNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment); 788 788 789 case '>':789 case GT: 790 790 return new (m_globalData) GreaterNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment); 791 791 … … 817 817 return new (m_globalData) UnsignedRightShiftNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment); 818 818 819 case '+':819 case PLUS: 820 820 return makeAddNode(lhs.first, rhs.first, rhs.second.hasAssignment); 821 821 822 case '-':822 case MINUS: 823 823 return makeSubNode(lhs.first, rhs.first, rhs.second.hasAssignment); 824 824 825 case '*':825 case TIMES: 826 826 return makeMultNode(lhs.first, rhs.first, rhs.second.hasAssignment); 827 827 828 case '/':828 case DIVIDE: 829 829 return makeDivNode(lhs.first, rhs.first, rhs.second.hasAssignment); 830 830 831 case '%':831 case MOD: 832 832 return new (m_globalData) ModNode(m_globalData, lhs.first, rhs.first, rhs.second.hasAssignment); 833 833 } -
trunk/JavaScriptCore/parser/JSParser.cpp
r62995 r63024 93 93 } 94 94 95 bool consume( intexpected)95 bool consume(JSTokenType expected) 96 96 { 97 97 bool result = m_token.m_type == expected; … … 101 101 } 102 102 103 bool match( intexpected)103 bool match(JSTokenType expected) 104 104 { 105 105 return m_token.m_type == expected; … … 161 161 enum FunctionRequirements { FunctionNoRequirements, FunctionNeedsName }; 162 162 template <FunctionRequirements, class TreeBuilder> bool parseFunctionInfo(TreeBuilder&, const Identifier*&, TreeFormalParameterList&, TreeFunctionBody&, int& openBrace, int& closeBrace, int& bodyStartLine); 163 int isBinaryOperator( inttoken);163 int isBinaryOperator(JSTokenType token); 164 164 bool allowAutomaticSemicolon(); 165 165 166 166 bool autoSemiColon() 167 167 { 168 if (token().m_type == ';') {168 if (token().m_type == SEMICOLON) { 169 169 next(); 170 170 return true; … … 233 233 ASTBuilder context(m_globalData, m_lexer); 234 234 SourceElements* sourceElements = parseSourceElements<ASTBuilder>(context); 235 if (!sourceElements || !consume( 0))235 if (!sourceElements || !consume(EOFTOK)) 236 236 return true; 237 237 m_globalData->parser->didFinishParsing(sourceElements, context.varDeclarations(), context.funcDeclarations(), context.features(), … … 242 242 bool JSParser::allowAutomaticSemicolon() 243 243 { 244 return match(CLOSEBRACE) || match( 0) || m_lexer->prevTerminator();244 return match(CLOSEBRACE) || match(EOFTOK) || m_lexer->prevTerminator(); 245 245 } 246 246 … … 293 293 int endLine = tokenLine(); 294 294 consumeOrFail(WHILE); 295 consumeOrFail( '(');295 consumeOrFail(OPENPAREN); 296 296 TreeExpression expr = parseExpression(context); 297 297 failIfFalse(expr); 298 consumeOrFail( ')');299 if (match( ';'))298 consumeOrFail(CLOSEPAREN); 299 if (match(SEMICOLON)) 300 300 next(); // Always performs automatic semicolon insertion. 301 301 return context.createDoWhileStatement(statement, expr, startLine, endLine); … … 307 307 int startLine = tokenLine(); 308 308 next(); 309 consumeOrFail( '(');309 consumeOrFail(OPENPAREN); 310 310 TreeExpression expr = parseExpression(context); 311 311 failIfFalse(expr); 312 312 int endLine = tokenLine(); 313 consumeOrFail( ')');313 consumeOrFail(CLOSEPAREN); 314 314 TreeStatement statement = parseStatement(context); 315 315 failIfFalse(statement); … … 330 330 lastIdent = name; 331 331 next(); 332 bool hasInitializer = match( '=');332 bool hasInitializer = match(EQUAL); 333 333 context.addVar(name, (hasInitializer || (!m_allowsIn && match(INTOKEN))) ? DeclarationStacks::HasInitializer : 0); 334 334 if (hasInitializer) { … … 348 348 varDecls = context.combineCommaNodes(varDecls, node); 349 349 } 350 } while (match( ','));350 } while (match(COMMA)); 351 351 return varDecls; 352 352 } … … 361 361 const Identifier* name = token().m_data.ident; 362 362 next(); 363 bool hasInitializer = match( '=');363 bool hasInitializer = match(EQUAL); 364 364 context.addVar(name, DeclarationStacks::IsConstant | (hasInitializer ? DeclarationStacks::HasInitializer : 0)); 365 365 TreeExpression initializer = 0; … … 371 371 if (!constDecls) 372 372 constDecls = tail; 373 } while (match( ','));373 } while (match(COMMA)); 374 374 return constDecls; 375 375 } … … 380 380 int startLine = tokenLine(); 381 381 next(); 382 consumeOrFail( '(');382 consumeOrFail(OPENPAREN); 383 383 int nonLHSCount = m_nonLHSCount; 384 384 int declarations = 0; … … 405 405 406 406 // Remainder of a standard for loop is handled identically 407 if (declarations > 1 || match( ';'))407 if (declarations > 1 || match(SEMICOLON)) 408 408 goto standardForLoop; 409 409 … … 418 418 419 419 int endLine = tokenLine(); 420 consumeOrFail( ')');420 consumeOrFail(CLOSEPAREN); 421 421 422 422 TreeStatement statement = parseStatement(context); … … 426 426 } 427 427 428 if (!match( ';')) {428 if (!match(SEMICOLON)) { 429 429 m_allowsIn = false; 430 430 declsStart = tokenStart(); … … 435 435 } 436 436 437 if (match( ';')) {437 if (match(SEMICOLON)) { 438 438 standardForLoop: 439 439 // Standard for loop … … 441 441 TreeExpression condition = 0; 442 442 443 if (!match( ';')) {443 if (!match(SEMICOLON)) { 444 444 condition = parseExpression(context); 445 445 failIfFalse(condition); 446 446 } 447 consumeOrFail( ';');447 consumeOrFail(SEMICOLON); 448 448 449 449 TreeExpression increment = 0; 450 if (!match( ')')) {450 if (!match(CLOSEPAREN)) { 451 451 increment = parseExpression(context); 452 452 failIfFalse(increment); 453 453 } 454 454 int endLine = tokenLine(); 455 consumeOrFail( ')');455 consumeOrFail(CLOSEPAREN); 456 456 TreeStatement statement = parseStatement(context); 457 457 failIfFalse(statement); … … 466 466 int exprEnd = lastTokenEnd(); 467 467 int endLine = tokenLine(); 468 consumeOrFail( ')');468 consumeOrFail(CLOSEPAREN); 469 469 TreeStatement statement = parseStatement(context); 470 470 failIfFalse(statement); … … 524 524 // as we need to ensure the a line break after the return correctly terminates 525 525 // the statement 526 if (match( ';'))526 if (match(SEMICOLON)) 527 527 endLine = tokenLine(); 528 528 if (autoSemiColon()) … … 531 531 failIfFalse(expr); 532 532 end = lastTokenEnd(); 533 if (match( ';'))533 if (match(SEMICOLON)) 534 534 endLine = tokenLine(); 535 535 failIfFalse(autoSemiColon()); … … 558 558 int startLine = tokenLine(); 559 559 next(); 560 consumeOrFail( '(');560 consumeOrFail(OPENPAREN); 561 561 int start = tokenStart(); 562 562 TreeExpression expr = parseExpression(context); … … 565 565 566 566 int endLine = tokenLine(); 567 consumeOrFail( ')');567 consumeOrFail(CLOSEPAREN); 568 568 569 569 TreeStatement statement = parseStatement(context); … … 578 578 int startLine = tokenLine(); 579 579 next(); 580 consumeOrFail( '(');580 consumeOrFail(OPENPAREN); 581 581 TreeExpression expr = parseExpression(context); 582 582 failIfFalse(expr); 583 583 int endLine = tokenLine(); 584 consumeOrFail( ')');584 consumeOrFail(CLOSEPAREN); 585 585 consumeOrFail(OPENBRACE); 586 586 … … 606 606 TreeExpression condition = parseExpression(context); 607 607 failIfFalse(condition); 608 consumeOrFail( ':');608 consumeOrFail(COLON); 609 609 TreeSourceElements statements = parseSourceElements(context); 610 610 failIfFalse(statements); … … 617 617 TreeExpression condition = parseExpression(context); 618 618 failIfFalse(condition); 619 consumeOrFail( ':');619 consumeOrFail(COLON); 620 620 TreeSourceElements statements = parseSourceElements(context); 621 621 failIfFalse(statements); … … 631 631 return 0; 632 632 next(); 633 consumeOrFail( ':');633 consumeOrFail(COLON); 634 634 TreeSourceElements statements = parseSourceElements(context); 635 635 failIfFalse(statements); … … 655 655 if (match(CATCH)) { 656 656 next(); 657 consumeOrFail( '(');657 consumeOrFail(OPENPAREN); 658 658 matchOrFail(IDENT); 659 659 ident = token().m_data.ident; 660 660 next(); 661 consumeOrFail( ')');661 consumeOrFail(CLOSEPAREN); 662 662 matchOrFail(OPENBRACE); 663 663 int initialEvalCount = context.evalCount(); … … 683 683 int endLine = startLine; 684 684 next(); 685 if (match( ';'))685 if (match(SEMICOLON)) 686 686 startLine = tokenLine(); 687 687 failIfFalse(autoSemiColon()); … … 717 717 case FUNCTION: 718 718 return parseFunctionDeclaration(context); 719 case ';':719 case SEMICOLON: 720 720 next(); 721 721 return context.createEmptyStatement(); … … 744 744 case DEBUGGER: 745 745 return parseDebuggerStatement(context); 746 case 0:746 case EOFTOK: 747 747 case CASE: 748 748 case CLOSEBRACE: … … 764 764 TreeFormalParameterList tail = list; 765 765 next(); 766 while (match( ',')) {766 while (match(COMMA)) { 767 767 next(); 768 768 matchOrFail(IDENT); … … 791 791 } else if (requirements == FunctionNeedsName) 792 792 return false; 793 consumeOrFail( '(');793 consumeOrFail(OPENPAREN); 794 794 bool usesArguments = false; 795 if (!match( ')')) {795 if (!match(CLOSEPAREN)) { 796 796 parameters = parseFormalParameters(context, usesArguments); 797 797 failIfFalse(parameters); 798 798 } 799 consumeOrFail( ')');799 consumeOrFail(CLOSEPAREN); 800 800 matchOrFail(OPENBRACE); 801 801 … … 848 848 failIfFalse(currentToken + 1 == m_tokenCount); 849 849 int end = tokenEnd(); 850 consumeOrFail( ':');850 consumeOrFail(COLON); 851 851 TreeStatement statement = parseStatement(context); 852 852 failIfFalse(statement); … … 870 870 next(); 871 871 872 consumeOrFail( '(');872 consumeOrFail(OPENPAREN); 873 873 874 874 TreeExpression condition = parseExpression(context); 875 875 failIfFalse(condition); 876 876 int end = tokenLine(); 877 consumeOrFail( ')');877 consumeOrFail(CLOSEPAREN); 878 878 879 879 TreeStatement trueBlock = parseStatement(context); … … 899 899 next(); 900 900 901 consumeOrFail( '(');901 consumeOrFail(OPENPAREN); 902 902 903 903 TreeExpression innerCondition = parseExpression(context); 904 904 failIfFalse(innerCondition); 905 905 int innerEnd = tokenLine(); 906 consumeOrFail( ')');906 consumeOrFail(CLOSEPAREN); 907 907 908 908 TreeStatement innerTrueBlock = parseStatement(context); … … 943 943 TreeExpression node = parseAssignmentExpression(context); 944 944 failIfFalse(node); 945 if (!match( ','))945 if (!match(COMMA)) 946 946 return node; 947 947 next(); … … 950 950 failIfFalse(right); 951 951 typename TreeBuilder::Comma commaNode = context.createCommaExpr(node, right); 952 while (match( ',')) {952 while (match(COMMA)) { 953 953 next(); 954 954 right = parseAssignmentExpression(context); … … 976 976 while (true) { 977 977 switch (token().m_type) { 978 case '=': op = OpEqual; break;978 case EQUAL: op = OpEqual; break; 979 979 case PLUSEQUAL: op = OpPlusEq; break; 980 980 case MINUSEQUAL: op = OpMinusEq; break; … … 1018 1018 TreeExpression cond = parseBinaryExpression(context); 1019 1019 failIfFalse(cond); 1020 if (!match( '?'))1020 if (!match(QUESTION)) 1021 1021 return cond; 1022 1022 m_nonLHSCount++; 1023 1023 next(); 1024 1024 TreeExpression lhs = parseAssignmentExpression(context); 1025 consumeOrFail( ':');1025 consumeOrFail(COLON); 1026 1026 1027 1027 TreeExpression rhs = parseAssignmentExpression(context); … … 1030 1030 } 1031 1031 1032 static bool isUnaryOp( inttoken)1032 static bool isUnaryOp(JSTokenType token) 1033 1033 { 1034 1034 switch (token) { 1035 case '!':1036 case '~':1037 case '-':1038 case '+':1035 case EXCLAMATION: 1036 case TILDE: 1037 case MINUS: 1038 case PLUS: 1039 1039 case PLUSPLUS: 1040 1040 case AUTOPLUSPLUS: … … 1050 1050 } 1051 1051 1052 int JSParser::isBinaryOperator( inttoken)1052 int JSParser::isBinaryOperator(JSTokenType token) 1053 1053 { 1054 1054 switch (token) { … … 1059 1059 return 2; 1060 1060 1061 case '|':1061 case BITOR: 1062 1062 return 3; 1063 1063 1064 case '^':1064 case BITXOR: 1065 1065 return 4; 1066 1066 1067 case '&':1067 case BITAND: 1068 1068 return 5; 1069 1069 … … 1074 1074 return 6; 1075 1075 1076 case '<':1077 case '>':1076 case LT: 1077 case GT: 1078 1078 case LE: 1079 1079 case GE: … … 1092 1092 return 8; 1093 1093 1094 case '+':1095 case '-':1094 case PLUS: 1095 case MINUS: 1096 1096 return 9; 1097 1097 1098 case '*':1099 case '/':1100 case '%':1098 case TIMES: 1099 case DIVIDE: 1100 case MOD: 1101 1101 return 10; 1102 1102 … … 1159 1159 const Identifier* ident = token().m_data.ident; 1160 1160 next(); 1161 if (match( ':')) {1161 if (match(COLON)) { 1162 1162 next(); 1163 1163 TreeExpression node = parseAssignmentExpression(context); … … 1186 1186 double propertyName = token().m_data.doubleValue; 1187 1187 next(); 1188 consumeOrFail( ':');1188 consumeOrFail(COLON); 1189 1189 TreeExpression node = parseAssignmentExpression(context); 1190 1190 failIfFalse(node); 1191 1191 return context.template createProperty<complete>(m_globalData, propertyName, node, PropertyNode::Constant); 1192 1192 } 1193 } 1194 fail(); 1193 default: 1194 fail(); 1195 } 1195 1196 } 1196 1197 … … 1214 1215 TreePropertyList propertyList = context.createPropertyList(property); 1215 1216 TreePropertyList tail = propertyList; 1216 while (match( ',')) {1217 while (match(COMMA)) { 1217 1218 next(); 1218 1219 // allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939 … … 1254 1255 TreePropertyList propertyList = context.createPropertyList(property); 1255 1256 TreePropertyList tail = propertyList; 1256 while (match( ',')) {1257 while (match(COMMA)) { 1257 1258 next(); 1258 1259 // allow extra comma, see http://bugs.webkit.org/show_bug.cgi?id=5939 … … 1282 1283 template <class TreeBuilder> TreeExpression JSParser::parseArrayLiteral(TreeBuilder& context) 1283 1284 { 1284 consumeOrFail( '[');1285 consumeOrFail(OPENBRACKET); 1285 1286 1286 1287 int elisions = 0; 1287 while (match( ',')) {1288 while (match(COMMA)) { 1288 1289 next(); 1289 1290 elisions++; 1290 1291 } 1291 if (match( ']')) {1292 if (match(CLOSEBRACKET)) { 1292 1293 next(); 1293 1294 return context.createArray(elisions); … … 1299 1300 typename TreeBuilder::ElementList tail = elementList; 1300 1301 elisions = 0; 1301 while (match( ',')) {1302 while (match(COMMA)) { 1302 1303 next(); 1303 1304 elisions = 0; 1304 1305 1305 while (match( ',')) {1306 while (match(COMMA)) { 1306 1307 next(); 1307 1308 elisions++; 1308 1309 } 1309 1310 1310 if (match( ']')) {1311 if (match(CLOSEBRACKET)) { 1311 1312 next(); 1312 1313 return context.createArray(elisions, elementList); … … 1317 1318 } 1318 1319 1319 consumeOrFail( ']');1320 consumeOrFail(CLOSEBRACKET); 1320 1321 1321 1322 return context.createArray(elementList); … … 1327 1328 case OPENBRACE: 1328 1329 return parseObjectLiteral(context); 1329 case '[':1330 case OPENBRACKET: 1330 1331 return parseArrayLiteral(context); 1331 case '(': {1332 case OPENPAREN: { 1332 1333 next(); 1333 1334 int oldNonLHSCount = m_nonLHSCount; 1334 1335 TreeExpression result = parseExpression(context); 1335 1336 m_nonLHSCount = oldNonLHSCount; 1336 consumeOrFail( ')');1337 consumeOrFail(CLOSEPAREN); 1337 1338 1338 1339 return result; … … 1371 1372 } 1372 1373 case DIVEQUAL: 1373 case '/': {1374 case DIVIDE: { 1374 1375 /* regexp */ 1375 1376 const Identifier* pattern; … … 1384 1385 return context.createRegex(*pattern, *flags, start); 1385 1386 } 1386 } 1387 fail(); 1387 default: 1388 fail(); 1389 } 1388 1390 } 1389 1391 1390 1392 template <class TreeBuilder> TreeArguments JSParser::parseArguments(TreeBuilder& context) 1391 1393 { 1392 consumeOrFail( '(');1393 if (match( ')')) {1394 consumeOrFail(OPENPAREN); 1395 if (match(CLOSEPAREN)) { 1394 1396 next(); 1395 1397 return context.createArguments(); … … 1400 1402 TreeArgumentsList argList = context.createArgumentsList(firstArg); 1401 1403 TreeArgumentsList tail = argList; 1402 while (match( ',')) {1404 while (match(COMMA)) { 1403 1405 next(); 1404 1406 TreeExpression arg = parseAssignmentExpression(context); … … 1406 1408 tail = context.createArgumentsList(tail, arg); 1407 1409 } 1408 consumeOrFail( ')');1410 consumeOrFail(CLOSEPAREN); 1409 1411 return context.createArguments(argList); 1410 1412 } … … 1436 1438 while (true) { 1437 1439 switch (token().m_type) { 1438 case '[': {1440 case OPENBRACKET: { 1439 1441 int expressionEnd = lastTokenEnd(); 1440 1442 next(); … … 1444 1446 failIfFalse(property); 1445 1447 base = context.createBracketAccess(base, property, initialAssignments != m_assignmentCount, expressionStart, expressionEnd, tokenEnd()); 1446 if (!consume( ']'))1448 if (!consume(CLOSEBRACKET)) 1447 1449 fail(); 1448 1450 m_nonLHSCount = nonLHSCount; 1449 1451 break; 1450 1452 } 1451 case '(': {1453 case OPENPAREN: { 1452 1454 if (newCount) { 1453 1455 newCount--; 1454 if (match( '(')) {1456 if (match(OPENPAREN)) { 1455 1457 int exprEnd = lastTokenEnd(); 1456 1458 TreeArguments arguments = parseArguments(context); … … 1469 1471 break; 1470 1472 } 1471 case '.': {1473 case DOT: { 1472 1474 int expressionEnd = lastTokenEnd(); 1473 1475 next(); … … 1512 1514 next(); 1513 1515 break; 1516 default: 1517 break; 1514 1518 } 1515 1519 … … 1521 1525 while (tokenStackDepth) { 1522 1526 switch (context.unaryTokenStackLastType(tokenStackDepth)) { 1523 case '!':1527 case EXCLAMATION: 1524 1528 expr = context.createLogicalNot(expr); 1525 1529 break; 1526 case '~':1530 case TILDE: 1527 1531 expr = context.makeBitwiseNotNode(expr); 1528 1532 break; 1529 case '-':1533 case MINUS: 1530 1534 expr = context.makeNegateNode(expr); 1531 1535 break; 1532 case '+':1536 case PLUS: 1533 1537 expr = context.createUnaryPlus(expr); 1534 1538 break; -
trunk/JavaScriptCore/parser/JSParser.h
r62995 r63024 34 34 35 35 enum 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 99 123 }; 100 124 … … 113 137 114 138 struct JSToken { 115 intm_type;139 JSTokenType m_type; 116 140 JSTokenData m_data; 117 141 JSTokenInfo m_info; -
trunk/JavaScriptCore/parser/Lexer.cpp
r62995 r63024 57 57 CharacterLineTerminator, 58 58 CharacterExclamationMark, 59 CharacterSimple, 59 CharacterOpenParen, 60 CharacterCloseParen, 61 CharacterOpenBracket, 62 CharacterCloseBracket, 63 CharacterComma, 64 CharacterColon, 65 CharacterQuestion, 66 CharacterTilde, 60 67 CharacterQuote, 61 68 CharacterDot, … … 82 89 83 90 // 128 ascii codes 84 static unsigned charAsciiCharacters[128] = {91 static unsigned short AsciiCharacters[128] = { 85 92 /* 0 - Null */ CharacterInvalid, 86 93 /* 1 - Start of Heading */ CharacterInvalid, … … 123 130 /* 38 - & */ CharacterAnd, 124 131 /* 39 - ' */ CharacterQuote, 125 /* 40 - ( */ Character Simple,126 /* 41 - ) */ Character Simple,132 /* 40 - ( */ CharacterOpenParen, 133 /* 41 - ) */ CharacterCloseParen, 127 134 /* 42 - * */ CharacterMultiply, 128 135 /* 43 - + */ CharacterAdd, 129 /* 44 - , */ Character Simple,136 /* 44 - , */ CharacterComma, 130 137 /* 45 - - */ CharacterSub, 131 138 /* 46 - . */ CharacterDot, … … 141 148 /* 56 - 8 */ CharacterNumber, 142 149 /* 57 - 9 */ CharacterNumber, 143 /* 58 - : */ Character Simple,150 /* 58 - : */ CharacterColon, 144 151 /* 59 - ; */ CharacterSemicolon, 145 152 /* 60 - < */ CharacterLess, 146 153 /* 61 - = */ CharacterEqual, 147 154 /* 62 - > */ CharacterGreater, 148 /* 63 - ? */ Character Simple,155 /* 63 - ? */ CharacterQuestion, 149 156 /* 64 - @ */ CharacterInvalid, 150 157 /* 65 - A */ CharacterAlpha, … … 174 181 /* 89 - Y */ CharacterAlpha, 175 182 /* 90 - Z */ CharacterAlpha, 176 /* 91 - [ */ Character Simple,183 /* 91 - [ */ CharacterOpenBracket, 177 184 /* 92 - \ */ CharacterBackSlash, 178 /* 93 - ] */ Character Simple,185 /* 93 - ] */ CharacterCloseBracket, 179 186 /* 94 - ^ */ CharacterXor, 180 187 /* 95 - _ */ CharacterAlpha, … … 209 216 /* 124 - | */ CharacterOr, 210 217 /* 125 - } */ CharacterCloseBrace, 211 /* 126 - ~ */ Character Simple,218 /* 126 - ~ */ CharacterTilde, 212 219 /* 127 - Delete */ CharacterInvalid, 213 220 }; … … 466 473 } 467 474 468 intLexer::lex(JSTokenData* lvalp, JSTokenInfo* llocp)475 JSTokenType Lexer::lex(JSTokenData* lvalp, JSTokenInfo* llocp) 469 476 { 470 477 ASSERT(!m_error); … … 472 479 ASSERT(m_buffer16.isEmpty()); 473 480 474 int token = 0; 481 JSTokenType token = ERRORTOK; 482 int identChar = 0; 475 483 m_terminator = false; 476 484 … … 482 490 483 491 if (UNLIKELY(m_current == -1)) 484 return 0;492 return EOFTOK; 485 493 486 494 m_delimited = false; … … 517 525 break; 518 526 } 519 token = '>';527 token = GT; 520 528 break; 521 529 case CharacterEqual: … … 531 539 break; 532 540 } 533 token = '=';541 token = EQUAL; 534 542 break; 535 543 case CharacterLess: … … 554 562 break; 555 563 } 556 token = '<';564 token = LT; 557 565 break; 558 566 case CharacterExclamationMark: … … 568 576 break; 569 577 } 570 token = '!';578 token = EXCLAMATION; 571 579 break; 572 580 case CharacterAdd: … … 582 590 break; 583 591 } 584 token = '+';592 token = PLUS; 585 593 break; 586 594 case CharacterSub: … … 600 608 break; 601 609 } 602 token = '-';610 token = MINUS; 603 611 break; 604 612 case CharacterMultiply: … … 609 617 break; 610 618 } 611 token = '*';619 token = TIMES; 612 620 break; 613 621 case CharacterSlash: … … 626 634 break; 627 635 } 628 token = '/';636 token = DIVIDE; 629 637 break; 630 638 case CharacterAnd: … … 640 648 break; 641 649 } 642 token = '&';650 token = BITAND; 643 651 break; 644 652 case CharacterXor: … … 649 657 break; 650 658 } 651 token = '^';659 token = BITXOR; 652 660 break; 653 661 case CharacterModulo: … … 658 666 break; 659 667 } 660 token = '%';668 token = MOD; 661 669 break; 662 670 case CharacterOr: … … 672 680 break; 673 681 } 674 token = '|';682 token = BITOR; 675 683 break; 676 684 case CharacterDot: … … 680 688 goto inNumberAfterDecimalPoint; 681 689 } 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; 686 722 shift(); 687 723 break; … … 689 725 m_delimited = true; 690 726 shift(); 691 token = ';';727 token = SEMICOLON; 692 728 break; 693 729 case CharacterOpenBrace: … … 724 760 m_terminator = true; 725 761 if (lastTokenWasRestrKeyword()) { 726 token = ';';762 token = SEMICOLON; 727 763 goto doneSemicolon; 728 764 } … … 759 795 shift(); 760 796 761 token= getUnicodeCharacter();762 if (UNLIKELY( token== -1))797 identChar = getUnicodeCharacter(); 798 if (UNLIKELY(identChar == -1)) 763 799 goto returnError; 764 if (UNLIKELY(!isIdentStart( token)))800 if (UNLIKELY(!isIdentStart(identChar))) 765 801 goto returnError; 766 802 goto inIdentifierAfterCharacterCheck; … … 785 821 goto returnError; 786 822 shift(); 787 token= getUnicodeCharacter();788 if (UNLIKELY( token== -1))823 identChar = getUnicodeCharacter(); 824 if (UNLIKELY(identChar == -1)) 789 825 goto returnError; 790 if (UNLIKELY(!isIdentPart( token)))826 if (UNLIKELY(!isIdentPart(identChar))) 791 827 goto returnError; 792 828 inIdentifierAfterCharacterCheck: 793 record16( token);829 record16(identChar); 794 830 795 831 while (isIdentPart(m_current)) { … … 803 839 while (!isLineTerminator(m_current)) { 804 840 if (UNLIKELY(m_current == -1)) 805 return 0;841 return EOFTOK; 806 842 shift(); 807 843 } … … 970 1006 971 1007 doneSemicolon: 972 token = ';';1008 token = SEMICOLON; 973 1009 m_delimited = true; 974 1010 goto returnToken; … … 987 1023 m_buffer16.resize(0); 988 1024 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; 990 1026 991 1027 // Fall through into returnToken. … … 1003 1039 returnError: 1004 1040 m_error = true; 1005 return -1;1041 return ERRORTOK; 1006 1042 } 1007 1043 -
trunk/JavaScriptCore/parser/Lexer.h
r62849 r63024 24 24 #define Lexer_h 25 25 26 #include "JSParser.h" 26 27 #include "Lookup.h" 27 28 #include "ParserArena.h" … … 35 36 namespace JSC { 36 37 37 union JSTokenData;38 struct JSTokenInfo;39 38 class RegExp; 40 39 … … 52 51 53 52 // Functions for the parser itself. 54 intlex(JSTokenData* lvalp, JSTokenInfo* llocp);53 JSTokenType lex(JSTokenData* lvalp, JSTokenInfo* llocp); 55 54 int lineNumber() const { return m_lineNumber; } 56 55 void setLastLineNumber(int lastLineNumber) { m_lastLineNumber = lastLineNumber; }
Note: See TracChangeset
for help on using the changeset viewer.