mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-06-09 11:29:39 +00:00
253 lines
8.3 KiB
C++
253 lines
8.3 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: set ts=8 sts=4 et sw=4 tw=99:
|
|
* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
#ifndef frontend_TokenKind_h
|
|
#define frontend_TokenKind_h
|
|
|
|
/*
|
|
* List of token kinds and their ranges.
|
|
*
|
|
* The format for each line is:
|
|
*
|
|
* macro(<TOKEN_KIND_NAME>, <DESCRIPTION>)
|
|
*
|
|
* or
|
|
*
|
|
* range(<TOKEN_RANGE_NAME>, <TOKEN_KIND_NAME>)
|
|
*
|
|
* where ;
|
|
* <TOKEN_KIND_NAME> is a legal C identifier of the token, that will be used in
|
|
* the JS engine source, with `TOK_` prefix.
|
|
*
|
|
* <DESCRIPTION> is a string that describe about the token, and will be used in
|
|
* error message.
|
|
*
|
|
* <TOKEN_RANGE_NAME> is a legal C identifier of the range that will be used to
|
|
* JS engine source, with `TOK_` prefix. It should end with `_FIRST` or `_LAST`.
|
|
* This is used to check TokenKind by range-testing:
|
|
* TOK_BINOP_FIRST <= tt && tt <= TOK_BINOP_LAST
|
|
*
|
|
* Second argument of `range` is the actual value of the <TOKEN_RANGE_NAME>,
|
|
* should be same as one of <TOKEN_KIND_NAME> in other `macro`s.
|
|
*
|
|
* To use this macro, define two macros for `macro` and `range`, and pass them
|
|
* as arguments.
|
|
*
|
|
* #define EMIT_TOKEN(name, desc) ...
|
|
* #define EMIT_RANGE(name, value) ...
|
|
* FOR_EACH_TOKEN_KIND_WITH_RANGE(EMIT_TOKEN, EMIT_RANGE)
|
|
* #undef EMIT_TOKEN
|
|
* #undef EMIT_RANGE
|
|
*
|
|
* If you don't need range data, use FOR_EACH_TOKEN_KIND instead.
|
|
*
|
|
* #define EMIT_TOKEN(name, desc) ...
|
|
* FOR_EACH_TOKEN_KIND(EMIT_TOKEN)
|
|
* #undef EMIT_TOKEN
|
|
*
|
|
* Note that this list does not contain ERROR and LIMIT.
|
|
*/
|
|
#define FOR_EACH_TOKEN_KIND_WITH_RANGE(macro, range) \
|
|
macro(EOF, "end of script") \
|
|
\
|
|
/* only returned by peekTokenSameLine() */ \
|
|
macro(EOL, "line terminator") \
|
|
\
|
|
macro(SEMI, "';'") \
|
|
macro(COMMA, "','") \
|
|
macro(HOOK, "'?'") /* conditional */ \
|
|
macro(COLON, "':'") /* conditional */ \
|
|
macro(INC, "'++'") /* increment */ \
|
|
macro(DEC, "'--'") /* decrement */ \
|
|
macro(DOT, "'.'") /* member operator */ \
|
|
macro(TRIPLEDOT, "'...'") /* rest arguments and spread operator */ \
|
|
macro(LB, "'['") \
|
|
macro(RB, "']'") \
|
|
macro(LC, "'{'") \
|
|
macro(RC, "'}'") \
|
|
macro(LP, "'('") \
|
|
macro(RP, "')'") \
|
|
macro(NAME, "identifier") \
|
|
macro(NUMBER, "numeric literal") \
|
|
macro(STRING, "string literal") \
|
|
\
|
|
/* start of template literal with substitutions */ \
|
|
macro(TEMPLATE_HEAD, "'${'") \
|
|
/* template literal without substitutions */ \
|
|
macro(NO_SUBS_TEMPLATE, "template literal") \
|
|
\
|
|
macro(REGEXP, "regular expression literal") \
|
|
macro(TRUE, "boolean literal 'true'") \
|
|
macro(FALSE, "boolean literal 'false'") \
|
|
macro(NULL, "null literal") \
|
|
macro(THIS, "keyword 'this'") \
|
|
macro(FUNCTION, "keyword 'function'") \
|
|
macro(IF, "keyword 'if'") \
|
|
macro(ELSE, "keyword 'else'") \
|
|
macro(SWITCH, "keyword 'switch'") \
|
|
macro(CASE, "keyword 'case'") \
|
|
macro(DEFAULT, "keyword 'default'") \
|
|
macro(WHILE, "keyword 'while'") \
|
|
macro(DO, "keyword 'do'") \
|
|
macro(FOR, "keyword 'for'") \
|
|
macro(BREAK, "keyword 'break'") \
|
|
macro(CONTINUE, "keyword 'continue'") \
|
|
macro(VAR, "keyword 'var'") \
|
|
macro(CONST, "keyword 'const'") \
|
|
macro(WITH, "keyword 'with'") \
|
|
macro(RETURN, "keyword 'return'") \
|
|
macro(NEW, "keyword 'new'") \
|
|
macro(DELETE, "keyword 'delete'") \
|
|
macro(TRY, "keyword 'try'") \
|
|
macro(CATCH, "keyword 'catch'") \
|
|
macro(FINALLY, "keyword 'finally'") \
|
|
macro(THROW, "keyword 'throw'") \
|
|
macro(DEBUGGER, "keyword 'debugger'") \
|
|
macro(YIELD, "keyword 'yield'") \
|
|
macro(AWAIT, "keyword 'await'") \
|
|
macro(LET, "keyword 'let'") \
|
|
macro(EXPORT, "keyword 'export'") \
|
|
macro(IMPORT, "keyword 'import'") \
|
|
macro(CLASS, "keyword 'class'") \
|
|
macro(EXTENDS, "keyword 'extends'") \
|
|
macro(SUPER, "keyword 'super'") \
|
|
macro(RESERVED, "reserved keyword") \
|
|
/* reserved keywords in strict mode */ \
|
|
macro(STRICT_RESERVED, "reserved keyword") \
|
|
\
|
|
/* \
|
|
* The following token types occupy contiguous ranges to enable easy \
|
|
* range-testing. \
|
|
*/ \
|
|
/* \
|
|
* Binary operators tokens, TOK_OR thru TOK_POW. These must be in the same \
|
|
* order as F(OR) and friends in FOR_EACH_PARSE_NODE_KIND in ParseNode.h. \
|
|
*/ \
|
|
macro(OR, "'||'") /* logical or */ \
|
|
range(BINOP_FIRST, OR) \
|
|
macro(AND, "'&&'") /* logical and */ \
|
|
macro(BITOR, "'|'") /* bitwise-or */ \
|
|
macro(BITXOR, "'^'") /* bitwise-xor */ \
|
|
macro(BITAND, "'&'") /* bitwise-and */ \
|
|
\
|
|
/* Equality operation tokens, per TokenKindIsEquality. */ \
|
|
macro(STRICTEQ, "'==='") \
|
|
range(EQUALITY_START, STRICTEQ) \
|
|
macro(EQ, "'=='") \
|
|
macro(STRICTNE, "'!=='") \
|
|
macro(NE, "'!='") \
|
|
range(EQUALITY_LAST, NE) \
|
|
\
|
|
/* Relational ops, per TokenKindIsRelational. */ \
|
|
macro(LT, "'<'") \
|
|
range(RELOP_START, LT) \
|
|
macro(LE, "'<='") \
|
|
macro(GT, "'>'") \
|
|
macro(GE, "'>='") \
|
|
range(RELOP_LAST, GE) \
|
|
\
|
|
macro(INSTANCEOF, "keyword 'instanceof'") \
|
|
macro(IN, "keyword 'in'") \
|
|
\
|
|
/* Shift ops, per TokenKindIsShift. */ \
|
|
macro(LSH, "'<<'") \
|
|
range(SHIFTOP_START, LSH) \
|
|
macro(RSH, "'>>'") \
|
|
macro(URSH, "'>>>'") \
|
|
range(SHIFTOP_LAST, URSH) \
|
|
\
|
|
macro(ADD, "'+'") \
|
|
macro(SUB, "'-'") \
|
|
macro(MUL, "'*'") \
|
|
macro(DIV, "'/'") \
|
|
macro(MOD, "'%'") \
|
|
macro(POW, "'**'") \
|
|
range(BINOP_LAST, POW) \
|
|
\
|
|
/* Unary operation tokens. */ \
|
|
macro(TYPEOF, "keyword 'typeof'") \
|
|
macro(VOID, "keyword 'void'") \
|
|
macro(NOT, "'!'") \
|
|
macro(BITNOT, "'~'") \
|
|
\
|
|
macro(ARROW, "'=>'") /* function arrow */ \
|
|
\
|
|
/* Assignment ops, per TokenKindIsAssignment */ \
|
|
macro(ASSIGN, "'='") \
|
|
range(ASSIGNMENT_START, ASSIGN) \
|
|
macro(ADDASSIGN, "'+='") \
|
|
macro(SUBASSIGN, "'-='") \
|
|
macro(BITORASSIGN, "'|='") \
|
|
macro(BITXORASSIGN, "'^='") \
|
|
macro(BITANDASSIGN, "'&='") \
|
|
macro(LSHASSIGN, "'<<='") \
|
|
macro(RSHASSIGN, "'>>='") \
|
|
macro(URSHASSIGN, "'>>>='") \
|
|
macro(MULASSIGN, "'*='") \
|
|
macro(DIVASSIGN, "'/='") \
|
|
macro(MODASSIGN, "'%='") \
|
|
macro(POWASSIGN, "'**='") \
|
|
range(ASSIGNMENT_LAST, POWASSIGN)
|
|
|
|
#define TOKEN_KIND_RANGE_EMIT_NONE(name, value)
|
|
#define FOR_EACH_TOKEN_KIND(macro) \
|
|
FOR_EACH_TOKEN_KIND_WITH_RANGE(macro, TOKEN_KIND_RANGE_EMIT_NONE)
|
|
|
|
namespace js {
|
|
namespace frontend {
|
|
|
|
// Values of this type are used to index into arrays such as isExprEnding[],
|
|
// so the first value must be zero.
|
|
enum TokenKind {
|
|
#define EMIT_ENUM(name, desc) TOK_##name,
|
|
#define EMIT_ENUM_RANGE(name, value) TOK_##name = TOK_##value,
|
|
FOR_EACH_TOKEN_KIND_WITH_RANGE(EMIT_ENUM, EMIT_ENUM_RANGE)
|
|
#undef EMIT_ENUM
|
|
#undef EMIT_ENUM_RANGE
|
|
TOK_LIMIT // domain size
|
|
};
|
|
|
|
inline bool
|
|
TokenKindIsBinaryOp(TokenKind tt)
|
|
{
|
|
return TOK_BINOP_FIRST <= tt && tt <= TOK_BINOP_LAST;
|
|
}
|
|
|
|
inline bool
|
|
TokenKindIsEquality(TokenKind tt)
|
|
{
|
|
return TOK_EQUALITY_START <= tt && tt <= TOK_EQUALITY_LAST;
|
|
}
|
|
|
|
inline bool
|
|
TokenKindIsRelational(TokenKind tt)
|
|
{
|
|
return TOK_RELOP_START <= tt && tt <= TOK_RELOP_LAST;
|
|
}
|
|
|
|
inline bool
|
|
TokenKindIsShift(TokenKind tt)
|
|
{
|
|
return TOK_SHIFTOP_START <= tt && tt <= TOK_SHIFTOP_LAST;
|
|
}
|
|
|
|
inline bool
|
|
TokenKindIsAssignment(TokenKind tt)
|
|
{
|
|
return TOK_ASSIGNMENT_START <= tt && tt <= TOK_ASSIGNMENT_LAST;
|
|
}
|
|
|
|
inline bool
|
|
TokenKindIsDecl(TokenKind tt)
|
|
{
|
|
return tt == TOK_VAR || tt == TOK_LET;
|
|
}
|
|
|
|
} // namespace frontend
|
|
} // namespace js
|
|
|
|
#endif /* frontend_TokenKind_h */
|