v8  3.14.5(node0.10.28)
V8 is Google's open source JavaScript engine
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
token.h
Go to the documentation of this file.
1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Redistribution and use in source and binary forms, with or without
3 // modification, are permitted provided that the following conditions are
4 // met:
5 //
6 // * Redistributions of source code must retain the above copyright
7 // notice, this list of conditions and the following disclaimer.
8 // * Redistributions in binary form must reproduce the above
9 // copyright notice, this list of conditions and the following
10 // disclaimer in the documentation and/or other materials provided
11 // with the distribution.
12 // * Neither the name of Google Inc. nor the names of its
13 // contributors may be used to endorse or promote products derived
14 // from this software without specific prior written permission.
15 //
16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27 
28 #ifndef V8_TOKEN_H_
29 #define V8_TOKEN_H_
30 
31 #include "checks.h"
32 
33 namespace v8 {
34 namespace internal {
35 
36 // TOKEN_LIST takes a list of 3 macros M, all of which satisfy the
37 // same signature M(name, string, precedence), where name is the
38 // symbolic token name, string is the corresponding syntactic symbol
39 // (or NULL, for literals), and precedence is the precedence (or 0).
40 // The parameters are invoked for token categories as follows:
41 //
42 // T: Non-keyword tokens
43 // K: Keyword tokens
44 
45 // IGNORE_TOKEN is a convenience macro that can be supplied as
46 // an argument (at any position) for a TOKEN_LIST call. It does
47 // nothing with tokens belonging to the respective category.
48 
49 #define IGNORE_TOKEN(name, string, precedence)
50 
51 #define TOKEN_LIST(T, K) \
52  /* End of source indicator. */ \
53  T(EOS, "EOS", 0) \
54  \
55  /* Punctuators (ECMA-262, section 7.7, page 15). */ \
56  T(LPAREN, "(", 0) \
57  T(RPAREN, ")", 0) \
58  T(LBRACK, "[", 0) \
59  T(RBRACK, "]", 0) \
60  T(LBRACE, "{", 0) \
61  T(RBRACE, "}", 0) \
62  T(COLON, ":", 0) \
63  T(SEMICOLON, ";", 0) \
64  T(PERIOD, ".", 0) \
65  T(CONDITIONAL, "?", 3) \
66  T(INC, "++", 0) \
67  T(DEC, "--", 0) \
68  \
69  /* Assignment operators. */ \
70  /* IsAssignmentOp() and Assignment::is_compound() relies on */ \
71  /* this block of enum values being contiguous and sorted in the */ \
72  /* same order! */ \
73  T(INIT_VAR, "=init_var", 2) /* AST-use only. */ \
74  T(INIT_LET, "=init_let", 2) /* AST-use only. */ \
75  T(INIT_CONST, "=init_const", 2) /* AST-use only. */ \
76  T(INIT_CONST_HARMONY, "=init_const_harmony", 2) /* AST-use only. */ \
77  T(ASSIGN, "=", 2) \
78  T(ASSIGN_BIT_OR, "|=", 2) \
79  T(ASSIGN_BIT_XOR, "^=", 2) \
80  T(ASSIGN_BIT_AND, "&=", 2) \
81  T(ASSIGN_SHL, "<<=", 2) \
82  T(ASSIGN_SAR, ">>=", 2) \
83  T(ASSIGN_SHR, ">>>=", 2) \
84  T(ASSIGN_ADD, "+=", 2) \
85  T(ASSIGN_SUB, "-=", 2) \
86  T(ASSIGN_MUL, "*=", 2) \
87  T(ASSIGN_DIV, "/=", 2) \
88  T(ASSIGN_MOD, "%=", 2) \
89  \
90  /* Binary operators sorted by precedence. */ \
91  /* IsBinaryOp() relies on this block of enum values */ \
92  /* being contiguous and sorted in the same order! */ \
93  T(COMMA, ",", 1) \
94  T(OR, "||", 4) \
95  T(AND, "&&", 5) \
96  T(BIT_OR, "|", 6) \
97  T(BIT_XOR, "^", 7) \
98  T(BIT_AND, "&", 8) \
99  T(SHL, "<<", 11) \
100  T(SAR, ">>", 11) \
101  T(SHR, ">>>", 11) \
102  T(ADD, "+", 12) \
103  T(SUB, "-", 12) \
104  T(MUL, "*", 13) \
105  T(DIV, "/", 13) \
106  T(MOD, "%", 13) \
107  \
108  /* Compare operators sorted by precedence. */ \
109  /* IsCompareOp() relies on this block of enum values */ \
110  /* being contiguous and sorted in the same order! */ \
111  T(EQ, "==", 9) \
112  T(NE, "!=", 9) \
113  T(EQ_STRICT, "===", 9) \
114  T(NE_STRICT, "!==", 9) \
115  T(LT, "<", 10) \
116  T(GT, ">", 10) \
117  T(LTE, "<=", 10) \
118  T(GTE, ">=", 10) \
119  K(INSTANCEOF, "instanceof", 10) \
120  K(IN, "in", 10) \
121  \
122  /* Unary operators. */ \
123  /* IsUnaryOp() relies on this block of enum values */ \
124  /* being contiguous and sorted in the same order! */ \
125  T(NOT, "!", 0) \
126  T(BIT_NOT, "~", 0) \
127  K(DELETE, "delete", 0) \
128  K(TYPEOF, "typeof", 0) \
129  K(VOID, "void", 0) \
130  \
131  /* Keywords (ECMA-262, section 7.5.2, page 13). */ \
132  K(BREAK, "break", 0) \
133  K(CASE, "case", 0) \
134  K(CATCH, "catch", 0) \
135  K(CONTINUE, "continue", 0) \
136  K(DEBUGGER, "debugger", 0) \
137  K(DEFAULT, "default", 0) \
138  /* DELETE */ \
139  K(DO, "do", 0) \
140  K(ELSE, "else", 0) \
141  K(FINALLY, "finally", 0) \
142  K(FOR, "for", 0) \
143  K(FUNCTION, "function", 0) \
144  K(IF, "if", 0) \
145  /* IN */ \
146  /* INSTANCEOF */ \
147  K(NEW, "new", 0) \
148  K(RETURN, "return", 0) \
149  K(SWITCH, "switch", 0) \
150  K(THIS, "this", 0) \
151  K(THROW, "throw", 0) \
152  K(TRY, "try", 0) \
153  /* TYPEOF */ \
154  K(VAR, "var", 0) \
155  /* VOID */ \
156  K(WHILE, "while", 0) \
157  K(WITH, "with", 0) \
158  \
159  /* Literals (ECMA-262, section 7.8, page 16). */ \
160  K(NULL_LITERAL, "null", 0) \
161  K(TRUE_LITERAL, "true", 0) \
162  K(FALSE_LITERAL, "false", 0) \
163  T(NUMBER, NULL, 0) \
164  T(STRING, NULL, 0) \
165  \
166  /* Identifiers (not keywords or future reserved words). */ \
167  T(IDENTIFIER, NULL, 0) \
168  \
169  /* Future reserved words (ECMA-262, section 7.6.1.2). */ \
170  T(FUTURE_RESERVED_WORD, NULL, 0) \
171  T(FUTURE_STRICT_RESERVED_WORD, NULL, 0) \
172  K(CONST, "const", 0) \
173  K(EXPORT, "export", 0) \
174  K(IMPORT, "import", 0) \
175  K(LET, "let", 0) \
176  \
177  /* Illegal token - not able to scan. */ \
178  T(ILLEGAL, "ILLEGAL", 0) \
179  \
180  /* Scanner-internal use only. */ \
181  T(WHITESPACE, NULL, 0)
182 
183 
184 class Token {
185  public:
186  // All token values.
187 #define T(name, string, precedence) name,
188  enum Value {
189  TOKEN_LIST(T, T)
191  };
192 #undef T
193 
194  // Returns a string corresponding to the C++ token name
195  // (e.g. "LT" for the token LT).
196  static const char* Name(Value tok) {
197  ASSERT(tok < NUM_TOKENS); // tok is unsigned
198  return name_[tok];
199  }
200 
201  // Predicates
202  static bool IsKeyword(Value tok) {
203  return token_type[tok] == 'K';
204  }
205 
206  static bool IsAssignmentOp(Value tok) {
207  return INIT_VAR <= tok && tok <= ASSIGN_MOD;
208  }
209 
210  static bool IsBinaryOp(Value op) {
211  return COMMA <= op && op <= MOD;
212  }
213 
214  static bool IsCompareOp(Value op) {
215  return EQ <= op && op <= IN;
216  }
217 
219  return op == LT || op == LTE || op == GT || op == GTE;
220  }
221 
222  static bool IsEqualityOp(Value op) {
223  return op == EQ || op == EQ_STRICT;
224  }
225 
227  ASSERT(IsCompareOp(op));
228  switch (op) {
229  case EQ: return NE;
230  case NE: return EQ;
231  case EQ_STRICT: return NE_STRICT;
232  case LT: return GTE;
233  case GT: return LTE;
234  case LTE: return GT;
235  case GTE: return LT;
236  default:
237  return op;
238  }
239  }
240 
242  ASSERT(IsCompareOp(op));
243  switch (op) {
244  case EQ: return NE;
245  case NE: return EQ;
246  case EQ_STRICT: return NE_STRICT;
247  case LT: return GT;
248  case GT: return LT;
249  case LTE: return GTE;
250  case GTE: return LTE;
251  default:
252  return op;
253  }
254  }
255 
256  static bool IsBitOp(Value op) {
257  return (BIT_OR <= op && op <= SHR) || op == BIT_NOT;
258  }
259 
260  static bool IsUnaryOp(Value op) {
261  return (NOT <= op && op <= VOID) || op == ADD || op == SUB;
262  }
263 
264  static bool IsCountOp(Value op) {
265  return op == INC || op == DEC;
266  }
267 
268  static bool IsShiftOp(Value op) {
269  return (SHL <= op) && (op <= SHR);
270  }
271 
272  // Returns a string corresponding to the JS token string
273  // (.e., "<" for the token LT) or NULL if the token doesn't
274  // have a (unique) string (e.g. an IDENTIFIER).
275  static const char* String(Value tok) {
276  ASSERT(tok < NUM_TOKENS); // tok is unsigned.
277  return string_[tok];
278  }
279 
280  // Returns the precedence > 0 for binary and compare
281  // operators; returns 0 otherwise.
282  static int Precedence(Value tok) {
283  ASSERT(tok < NUM_TOKENS); // tok is unsigned.
284  return precedence_[tok];
285  }
286 
287  private:
288  static const char* const name_[NUM_TOKENS];
289  static const char* const string_[NUM_TOKENS];
290  static const int8_t precedence_[NUM_TOKENS];
291  static const char token_type[NUM_TOKENS];
292 };
293 
294 } } // namespace v8::internal
295 
296 #endif // V8_TOKEN_H_
static const char * Name(Value tok)
Definition: token.h:196
static int Precedence(Value tok)
Definition: token.h:282
static bool IsCompareOp(Value op)
Definition: token.h:214
static bool IsUnaryOp(Value op)
Definition: token.h:260
#define ASSERT(condition)
Definition: checks.h:270
#define TOKEN_LIST(T, K)
Definition: token.h:51
#define IN
static bool IsShiftOp(Value op)
Definition: token.h:268
static bool IsBitOp(Value op)
Definition: token.h:256
static const char * String(Value tok)
Definition: token.h:275
static bool IsAssignmentOp(Value tok)
Definition: token.h:206
static Value NegateCompareOp(Value op)
Definition: token.h:226
static Value InvertCompareOp(Value op)
Definition: token.h:241
static bool IsKeyword(Value tok)
Definition: token.h:202
static bool IsEqualityOp(Value op)
Definition: token.h:222
static bool IsBinaryOp(Value op)
Definition: token.h:210
#define T(name, string, precedence)
Definition: token.h:187
static bool IsCountOp(Value op)
Definition: token.h:264
#define VOID
static bool IsOrderedRelationalCompareOp(Value op)
Definition: token.h:218