Lines Matching full:token
51 // PositionStack is used for on-stack allocation of token positions for
131 void ReportUnexpectedToken(Token::Value token);
246 INLINE(Token::Value peek()) { return scanner_.peek(); }
247 INLINE(Token::Value Next()) { return scanner_.Next(); }
248 INLINE(void Consume(Token::Value token));
249 void Expect(Token::Value token, bool* ok);
250 bool Check(Token::Value token);
1223 ParseSourceElements(&processor, Token::EOS, &ok);
1257 ParseSourceElements(&body, Token::EOS, &ok);
1445 (assignment->op() == Token::ASSIGN)) {
1486 if (assignment->op() != Token::ASSIGN) return false;
1578 return assignment->op() == Token::ASSIGN
1734 case Token::LBRACE:
1737 case Token::CONST: // fall through
1738 case Token::VAR:
1742 case Token::SEMICOLON:
1746 case Token::IF:
1750 case Token::DO:
1754 case Token::WHILE:
1758 case Token::FOR:
1762 case Token::CONTINUE:
1766 case Token::BREAK:
1770 case Token::RETURN:
1774 case Token::WITH:
1778 case Token::SWITCH:
1782 case Token::THROW:
1786 case Token::TRY: {
1802 case Token::FUNCTION:
1805 case Token::NATIVE:
1808 case Token::DEBUGGER:
1926 ReportUnexpectedToken(Token::NATIVE);
1931 Expect(Token::NATIVE, CHECK_OK);
1932 Expect(Token::FUNCTION, CHECK_OK);
1934 Expect(Token::LPAREN, CHECK_OK);
1935 bool done = (peek() == Token::RPAREN);
1938 done = (peek() == Token::RPAREN);
1939 if (!done) Expect(Token::COMMA, CHECK_OK);
1941 Expect(Token::RPAREN, CHECK_OK);
1942 Expect(Token::SEMICOLON, CHECK_OK);
1980 new Assignment(Token::INIT_VAR, var, lit, RelocInfo::kNoPosition)));
1987 Expect(Token::FUNCTION, CHECK_OK);
2012 Expect(Token::LBRACE, CHECK_OK);
2013 while (peek() != Token::RBRACE) {
2017 Expect(Token::RBRACE, CHECK_OK);
2046 if (peek() == Token::VAR) {
2047 Consume(Token::VAR);
2048 } else if (peek() == Token::CONST) {
2049 Consume(Token::CONST);
2074 if (nvars > 0) Consume(Token::COMMA);
2123 if (peek() == Token::ASSIGN) {
2124 Expect(Token::ASSIGN, CHECK_OK);
2199 Token::Value op = (is_const ? Token::INIT_CONST : Token::INIT_VAR);
2203 } while (peek() == Token::COMMA);
2239 if (peek() == Token::COLON && expr &&
2265 Expect(Token::COLON, CHECK_OK);
2279 Expect(Token::IF, CHECK_OK);
2280 Expect(Token::LPAREN, CHECK_OK);
2282 Expect(Token::RPAREN, CHECK_OK);
2285 if (peek() == Token::ELSE) {
2299 Expect(Token::CONTINUE, CHECK_OK);
2301 Token::Value tok = peek();
2303 tok != Token::SEMICOLON && tok != Token::RBRACE && tok != Token::EOS) {
2327 Expect(Token::BREAK, CHECK_OK);
2329 Token::Value tok = peek();
2331 tok != Token::SEMICOLON && tok != Token::RBRACE && tok != Token::EOS) {
2360 // Consume the return token. It is necessary to do the before
2363 Expect(Token::RETURN, CHECK_OK);
2376 Token::Value tok = peek();
2378 tok == Token::SEMICOLON ||
2379 tok == Token::RBRACE ||
2380 tok == Token::EOS) {
2434 Expect(Token::WITH, CHECK_OK);
2435 Expect(Token::LPAREN, CHECK_OK);
2437 Expect(Token::RPAREN, CHECK_OK);
2449 if (peek() == Token::CASE) {
2450 Expect(Token::CASE, CHECK_OK);
2453 Expect(Token::DEFAULT, CHECK_OK);
2462 Expect(Token::COLON, CHECK_OK);
2465 while (peek() != Token::CASE &&
2466 peek() != Token::DEFAULT &&
2467 peek() != Token::RBRACE) {
2484 Expect(Token::SWITCH, CHECK_OK);
2485 Expect(Token::LPAREN, CHECK_OK);
2487 Expect(Token::RPAREN, CHECK_OK);
2491 Expect(Token::LBRACE, CHECK_OK);
2492 while (peek() != Token::RBRACE) {
2496 Expect(Token::RBRACE, CHECK_OK);
2507 Expect(Token::THROW, CHECK_OK);
2533 Expect(Token::TRY, CHECK_OK);
2547 Token::Value tok = peek();
2548 if (tok != Token::CATCH && tok != Token::FINALLY) {
2561 if (tok == Token::CATCH) {
2563 Consume(Token::CATCH);
2565 Expect(Token::LPAREN, CHECK_OK);
2567 Expect(Token::RPAREN, CHECK_OK);
2569 if (peek() == Token::LBRACE) {
2579 Expect(Token::LBRACE, CHECK_OK);
2585 if (tok == Token::FINALLY || !has_catch) {
2586 Consume(Token::FINALLY);
2635 Expect(Token::DO, CHECK_OK);
2637 Expect(Token::WHILE, CHECK_OK);
2638 Expect(Token::LPAREN, CHECK_OK);
2646 Expect(Token::RPAREN, CHECK_OK);
2652 if (peek() == Token::SEMICOLON) Consume(Token::SEMICOLON);
2666 Expect(Token::WHILE, CHECK_OK);
2667 Expect(Token::LPAREN, CHECK_OK);
2669 Expect(Token::RPAREN, CHECK_OK);
2683 Expect(Token::FOR, CHECK_OK);
2684 Expect(Token::LPAREN, CHECK_OK);
2685 if (peek() != Token::SEMICOLON) {
2686 if (peek() == Token::VAR || peek() == Token::CONST) {
2690 if (peek() == Token::IN && each != NULL) {
2694 Expect(Token::IN, CHECK_OK);
2696 Expect(Token::RPAREN, CHECK_OK);
2716 if (peek() == Token::IN) {
2728 Expect(Token::IN, CHECK_OK);
2730 Expect(Token::RPAREN, CHECK_OK);
2749 Expect(Token::SEMICOLON, CHECK_OK);
2752 if (peek() != Token::SEMICOLON) {
2758 Expect(Token::SEMICOLON, CHECK_OK);
2761 if (peek() != Token::RPAREN) {
2765 Expect(Token::RPAREN, CHECK_OK);
2781 while (peek() == Token::COMMA) {
2782 Expect(Token::COMMA, CHECK_OK);
2784 result = NEW(BinaryOperation(Token::COMMA, result, right));
2798 if (!Token::IsAssignmentOp(peek())) {
2812 Token::Value op = Next(); // Get assignment operator.
2822 if (op == Token::ASSIGN &&
2841 if (peek() != Token::CONDITIONAL) return expression;
2842 Consume(Token::CONDITIONAL);
2847 Expect(Token::COLON, CHECK_OK);
2853 static int Precedence(Token::Value tok, bool accept_IN) {
2854 if (tok == Token::IN && !accept_IN)
2857 return Token::Precedence(tok);
2868 Token::Value op = Next();
2878 case Token::ADD:
2881 case Token::SUB:
2884 case Token::MUL:
2887 case Token::DIV:
2890 case Token::BIT_OR:
2893 case Token::BIT_AND:
2896 case Token::BIT_XOR:
2899 case Token::SHL: {
2904 case Token::SHR: {
2910 case Token::SAR: {
2922 if (op == Token::DIV &&
2937 op = Token::MUL;
2944 if (Token::IsCompareOp(op)) {
2946 Token::Value cmp = op;
2948 case Token::NE: cmp = Token::EQ; break;
2949 case Token::NE_STRICT: cmp = Token::EQ_STRICT; break;
2955 x = NEW(UnaryOperation(Token::NOT, x));
2981 Token::Value op = peek();
2982 if (Token::IsUnaryOp(op)) {
2991 case Token::ADD:
2993 case Token::SUB:
2995 case Token::BIT_NOT:
3003 } else if (Token::IsCountOp(op)) {
3027 if (!scanner_.has_line_terminator_before_next() && Token::IsCountOp(peek())) {
3036 Token::Value next = Next();
3048 if (peek() == Token::NEW) {
3056 case Token::LBRACK: {
3057 Consume(Token::LBRACK);
3061 Expect(Token::RBRACK, CHECK_OK);
3065 case Token::LPAREN: {
3091 case Token::PERIOD: {
3092 Consume(Token::PERIOD);
3119 Expect(Token::NEW, CHECK_OK);
3123 if (peek() == Token::NEW) {
3156 if (peek() == Token::FUNCTION) {
3157 Expect(Token::FUNCTION, CHECK_OK);
3160 if (peek() == Token::IDENTIFIER) name = ParseIdentifier(CHECK_OK);
3169 case Token::LBRACK: {
3170 Consume(Token::LBRACK);
3174 Expect(Token::RBRACK, CHECK_OK);
3177 case Token::PERIOD: {
3178 Consume(Token::PERIOD);
3184 case Token::LPAREN: {
3206 Expect(Token::DEBUGGER, CHECK_OK);
3212 void Parser::ReportUnexpectedToken(Token::Value token) {
3216 if (token == Token::ILLEGAL && scanner().stack_overflow())
3219 switch (token) {
3220 case Token::EOS:
3222 case Token::NUMBER:
3225 case Token::STRING:
3228 case Token::IDENTIFIER:
3232 const char* name = Token::String(token);
3255 case Token::THIS: {
3256 Consume(Token::THIS);
3267 case Token::NULL_LITERAL:
3268 Consume(Token::NULL_LITERAL);
3272 case Token::TRUE_LITERAL:
3273 Consume(Token::TRUE_LITERAL);
3277 case Token::FALSE_LITERAL:
3278 Consume(Token::FALSE_LITERAL);
3282 case Token::IDENTIFIER: {
3292 case Token::NUMBER: {
3293 Consume(Token::NUMBER);
3300 case Token::STRING: {
3301 Consume(Token::STRING);
3309 case Token::ASSIGN_DIV:
3313 case Token::DIV:
3317 case Token::LBRACK:
3321 case Token::LBRACE:
3325 case Token::LPAREN:
3326 Consume(Token::LPAREN);
3328 Expect(Token::RPAREN, CHECK_OK);
3331 case Token::MOD:
3340 Token::Value tok = peek();
3341 // Token::Peek returns the value of the next token but
3342 // location() gives info about the current token.
3343 // Therefore, we need to read ahead to the next token
3387 Expect(Token::LBRACK, CHECK_OK);
3388 while (peek() != Token::RBRACK) {
3390 if (peek() == Token::COMMA) {
3396 if (peek() != Token::RBRACK) {
3397 Expect(Token::COMMA, CHECK_OK);
3400 Expect(Token::RBRACK, CHECK_OK);
3532 Expect(Token::LBRACE, CHECK_OK);
3533 while (peek() != Token::RBRACE) {
3536 case Token::IDENTIFIER: {
3546 if (peek() == Token::IDENTIFIER) {
3556 if (peek() != Token::RBRACE) Expect(Token::COMMA, CHECK_OK);
3564 case Token::STRING: {
3565 Consume(Token::STRING);
3578 case Token::NUMBER: {
3579 Consume(Token::NUMBER);
3587 Expect(Token::RBRACE, CHECK_OK);
3591 Expect(Token::COLON, CHECK_OK);
3602 if (peek() != Token::RBRACE) Expect(Token::COMMA, CHECK_OK);
3604 Expect(Token::RBRACE, CHECK_OK);
3665 Expect(Token::LPAREN, CHECK_OK);
3666 bool done = (peek() == Token::RPAREN);
3670 done = (peek() == Token::RPAREN);
3671 if (!done) Expect(Token::COMMA, CHECK_OK);
3673 Expect(Token::RPAREN, CHECK_OK);
3708 Expect(Token::LPAREN, CHECK_OK);
3710 bool done = (peek() == Token::RPAREN);
3718 done = (peek() == Token::RPAREN);
3719 if (!done) Expect(Token::COMMA, CHECK_OK);
3721 Expect(Token::RPAREN, CHECK_OK);
3723 Expect(Token::LBRACE, CHECK_OK);
3738 new Assignment(Token::INIT_CONST, fproxy,
3762 ParseSourceElements(&body, Token::RBRACE, CHECK_OK);
3770 Expect(Token::RBRACE, CHECK_OK);
3804 Expect(Token::MOD, CHECK_OK);
3842 void Parser::Consume(Token::Value token) {
3843 Token::Value next = Next();
3845 USE(token);
3846 ASSERT(next == token);
3850 void Parser::Expect(Token::Value token, bool* ok) {
3851 Token::Value next = Next();
3852 if (next == token) return;
3858 bool Parser::Check(Token::Value token) {
3859 Token::Value next = peek();
3860 if (next == token) {
3871 Token::Value tok = peek();
3872 if (tok == Token::SEMICOLON) {
3877 tok == Token::RBRACE ||
3878 tok == Token::EOS) {
3881 Expect(Token::SEMICOLON, ok);
3901 Expect(Token::IDENTIFIER, ok);
3914 Expect(Token::IDENTIFIER, ok);
3917 const char* token = scanner_.literal_string();
3918 *is_get = strcmp(token, "get") == 0;
3919 *is_set = !*is_get && strcmp(token, "set") == 0;
4039 Expect(Token::EOS, CHECK_OK);
4046 Token::Value token = peek();
4047 switch (token) {
4048 case Token::STRING: {
4049 Consume(Token::STRING);
4058 case Token::NUMBER: {
4059 Consume(Token::NUMBER);
4066 case Token::FALSE_LITERAL:
4067 Consume(Token::FALSE_LITERAL);
4069 case Token::TRUE_LITERAL:
4070 Consume(Token::TRUE_LITERAL);
4072 case Token::NULL_LITERAL:
4073 Consume(Token::NULL_LITERAL);
4075 case Token::LBRACE: {
4079 case Token::LBRACK: {
4085 ReportUnexpectedToken(token);
4091 // Parse a JSON object. Scanner must be right after '{' token.
4093 Consume(Token::LBRACE);
4097 if (peek() != Token::RBRACE) {
4099 Expect(Token::STRING, CHECK_OK);
4102 Expect(Token::COLON, CHECK_OK);
4118 } while (Check(Token::COMMA));
4120 Expect(Token::RBRACE, CHECK_OK);
4141 // Parse a JSON array. Scanner must be right after '[' token.
4143 Consume(Token::LBRACK);
4146 if (peek() != Token::RBRACK) {
4150 } while (Check(Token::COMMA));
4152 Expect(Token::RBRACK, CHECK_OK);
