Implement experimental exponentiation operator

src/token.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_TOKEN_H_
 #define V8_TOKEN_H_
 
 #include "src/base/logging.h"
 #include "src/globals.h"
 
@@ skipping 48 matching lines @@
   T(ASSIGN_BIT_XOR, "^=", 2)                                         \
   T(ASSIGN_BIT_AND, "&=", 2)                                         \
   T(ASSIGN_SHL, "<<=", 2)                                            \
   T(ASSIGN_SAR, ">>=", 2)                                            \
   T(ASSIGN_SHR, ">>>=", 2)                                           \
   T(ASSIGN_ADD, "+=", 2)                                             \
   T(ASSIGN_SUB, "-=", 2)                                             \
   T(ASSIGN_MUL, "*=", 2)                                             \
   T(ASSIGN_DIV, "/=", 2)                                             \
   T(ASSIGN_MOD, "%=", 2)                                             \
+  T(ASSIGN_EXP, "**=", 2)                                            \
                                                                      \
   /* Binary operators sorted by precedence. */                       \
   /* IsBinaryOp() relies on this block of enum values */             \
   /* being contiguous and sorted in the same order! */               \
   T(COMMA, ",", 1)                                                   \
   T(OR, "||", 4)                                                     \
   T(AND, "&&", 5)                                                    \
   T(BIT_OR, "|", 6)                                                  \
   T(BIT_XOR, "^", 7)                                                 \
   T(BIT_AND, "&", 8)                                                 \
   T(SHL, "<<", 11)                                                   \
   T(SAR, ">>", 11)                                                   \
   T(SHR, ">>>", 11)                                                  \
   T(ROR, "rotate right", 11) /* only used by Crankshaft */           \
   T(ADD, "+", 12)                                                    \
   T(SUB, "-", 12)                                                    \
   T(MUL, "*", 13)                                                    \
   T(DIV, "/", 13)                                                    \
   T(MOD, "%", 13)                                                    \
+  T(EXP, "**", 14)                                                   \
                                                                      \
   /* Compare operators sorted by precedence. */                      \
   /* IsCompareOp() relies on this block of enum values */            \
   /* being contiguous and sorted in the same order! */               \
   T(EQ, "==", 9)                                                     \
   T(NE, "!=", 9)                                                     \
   T(EQ_STRICT, "===", 9)                                             \
   T(NE_STRICT, "!==", 9)                                             \
   T(LT, "<", 10)                                                     \
   T(GT, ">", 10)                                                     \
@@ skipping 107 matching lines @@
       case YIELD:
         return !is_generator && is_sloppy(language_mode);
       default:
         return false;
     }
     UNREACHABLE();
     return false;
   }
 
   static bool IsAssignmentOp(Value tok) {
-    return INIT_VAR <= tok && tok <= ASSIGN_MOD;
+    return INIT_VAR <= tok && tok <= ASSIGN_EXP;
   }
 
   static bool IsBinaryOp(Value op) {
-    return COMMA <= op && op <= MOD;
+    return COMMA <= op && op <= EXP;
   }
 
   static bool IsTruncatingBinaryOp(Value op) {
     return BIT_OR <= op && op <= ROR;
   }
 
   static bool IsCompareOp(Value op) {
     return EQ <= op && op <= IN;
   }
 
@@ skipping 82 matching lines @@
  private:
   static const char* const name_[NUM_TOKENS];
   static const char* const string_[NUM_TOKENS];
   static const int8_t precedence_[NUM_TOKENS];
   static const char token_type[NUM_TOKENS];
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_TOKEN_H_