iv-phonic 0.0.9 → 0.1.0

data/ext/include/iv/lexer.h

@@ -262,7 +262,7 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
           Advance();
           if (Chars::IsDecimalDigit(c_)) {
             // float number parse
-            token = ScanNumber(true);
+            token = ScanNumber<true>();
           } else {
             token = Token::PERIOD;
           }
@@ -342,7 +342,7 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
           if (Chars::IsIdentifierStart(c_)) {
             token = ScanIdentifier<LexType>(strict);
           } else if (Chars::IsDecimalDigit(c_)) {
-            token = ScanNumber(false);
+            token = ScanNumber<false>();
           } else if (Chars::IsLineTerminator(c_)) {
             SkipLineTerminator();
             has_line_terminator_before_next_ = true;
@@ -733,7 +733,8 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
     return true;
   }
 
-  Token::Type ScanNumber(const bool period) {
+  template<bool period>
+  Token::Type ScanNumber() {
     buffer8_.clear();
     State type = DECIMAL;
     if (period) {
@@ -798,16 +799,21 @@ class Lexer: private Noncopyable<Lexer<Source> >::type {
       return Token::ILLEGAL;
     }
 
-    if (type == OCTAL) {
-      double val = 0;
-      for (typename std::vector<char>::const_iterator it = buffer8_.begin(),
-           last = buffer8_.end(); it != last; ++it) {
-        val = val * 8 + (*it - '0');
-      }
-      numeric_ = val;
-    } else {
+
+    if (type == DECIMAL) {
       const std::string buf(buffer8_.begin(), buffer8_.end());
       numeric_ = std::atof(buf.c_str());
+    } else if (type == HEX) {
+      assert(buffer8_.size() > 2);  // first 0x
+      numeric_ = ParseIntegerOverflow(buffer8_.begin() + 2,
+                                      buffer8_.end(),
+                                      16);
+    } else {
+      assert(type == OCTAL);
+      assert(buffer8_.size() > 1);  // first 0
+      numeric_ = ParseIntegerOverflow(buffer8_.begin() + 1,
+                                      buffer8_.end(),
+                                      8);
     }
     type_ = type;
     return Token::NUMBER;

data/ext/include/iv/parser.h

@@ -135,11 +135,16 @@ const UString ParserData<T>::kSet(
 
 typedef detail::ParserData<None> ParserData;
 
-template<typename Factory, typename Source, bool UseFunctionStatement>
+template<typename Factory,
+         typename Source,
+         bool UseFunctionStatement,
+         bool ReduceExpressions>
 class Parser
-  : private Noncopyable<Parser<Factory, Source, UseFunctionStatement> >::type {
+  : private Noncopyable<
+    Parser<Factory, Source, UseFunctionStatement, ReduceExpressions> >::type {
  public:
-  typedef Parser<Factory, Source, UseFunctionStatement> this_type;
+  typedef Parser<Factory, Source,
+                 UseFunctionStatement, ReduceExpressions> this_type;
   typedef this_type parser_type;
   typedef Lexer<Source> lexer_type;
 #define V(AST) typedef typename ast::AST<Factory> AST;
@@ -461,16 +466,17 @@ class Parser
 //    | StatementList Statement
   Block* ParseBlock(bool *res) {
     assert(token_ == Token::LBRACE);
-    Block* const block = factory_->NewBlock();
+    Statements* const body = factory_->template NewVector<Statement*>();
     Statement* stmt;
     Target target(this, Target::kNamedOnlyStatement);
 
     Next();
     while (token_ != Token::RBRACE) {
       stmt = ParseStatement(CHECK);
-      block->AddStatement(stmt);
+      body->push_back(stmt);
     }
     Next();
+    Block* const block = factory_->NewBlock(body);
     target.set_node(block);
     return block;
   }
@@ -480,10 +486,10 @@ class Parser
 //    : CONST VariableDeclarationList ';'
   Statement* ParseVariableStatement(bool *res) {
     assert(token_ == Token::VAR || token_ == Token::CONST);
-    VariableStatement* const stmt = factory_->NewVariableStatement(token_);
-    ParseVariableDeclarations(stmt, true, CHECK);
+    Declarations* const decls = factory_->template NewVector<Declaration*>();
+    ParseVariableDeclarations(decls, token_ == Token::CONST, true, CHECK);
     ExpectSemicolon(CHECK);
-    return stmt;
+    return factory_->NewVariableStatement(token_, decls);
   }
 
 //  VariableDeclarationList
@@ -499,9 +505,10 @@ class Parser
 //
 //  Initialiser
 //    : '=' AssignmentExpression
-  Statement* ParseVariableDeclarations(VariableStatement* stmt,
-                                       bool contains_in,
-                                       bool *res) {
+  Declarations* ParseVariableDeclarations(Declarations* decls,
+                                          bool is_const,
+                                          bool contains_in,
+                                          bool *res) {
     Identifier* name;
     Expression* expr;
     Declaration* decl;
@@ -533,11 +540,11 @@ class Parser
         // Undefined Expression
         decl = factory_->NewDeclaration(name, factory_->NewUndefined());
       }
-      stmt->AddDeclaration(decl);
-      scope_->AddUnresolved(name, stmt->IsConst());
+      decls->push_back(decl);
+      scope_->AddUnresolved(name, is_const);
     } while (token_ == Token::COMMA);
 
-    return stmt;
+    return decls;
   }
 
 //  EmptyStatement
@@ -649,8 +656,11 @@ class Parser
 
     if (token_ != Token::SEMICOLON) {
       if (token_ == Token::VAR || token_ == Token::CONST) {
-        VariableStatement* const var = factory_->NewVariableStatement(token_);
-        ParseVariableDeclarations(var, false, CHECK);
+        Declarations* const decls =
+            factory_->template NewVector<Declaration*>();
+        ParseVariableDeclarations(decls, token_ == Token::CONST, false, CHECK);
+        VariableStatement* const var =
+            factory_->NewVariableStatement(token_, decls);
         init = var;
         if (token_ == Token::IN) {
           // for in loop
@@ -841,13 +851,13 @@ class Parser
 //    | '{' CaseClauses_opt DefaultClause CaseClauses_opt '}'
   Statement* ParseSwitchStatement(bool *res) {
     assert(token_ == Token::SWITCH);
-    CaseClause *case_clause;
+    CaseClause* case_clause;
     Next();
 
     EXPECT(Token::LPAREN);
 
-    Expression *expr = ParseExpression(true, CHECK);
-    SwitchStatement *switch_stmt = factory_->NewSwitchStatement(expr);
+    Expression* expr = ParseExpression(true, CHECK);
+    CaseClauses* clauses = factory_->template NewVector<CaseClause*>();
     Target target(this, Target::kSwitchStatement);
 
     EXPECT(Token::RPAREN);
@@ -869,10 +879,12 @@ class Parser
           default_found = true;
         }
       }
-      switch_stmt->AddCaseClause(case_clause);
+      clauses->push_back(case_clause);
     }
     Next();
 
+    SwitchStatement* const switch_stmt =
+        factory_->NewSwitchStatement(expr, clauses);
     target.set_node(switch_stmt);
     return switch_stmt;
   }
@@ -888,16 +900,14 @@ class Parser
 //    : DEFAULT ':' StatementList_opt
   CaseClause* ParseCaseClause(bool *res) {
     assert(token_ == Token::CASE || token_ == Token::DEFAULT);
-    CaseClause* clause;
-    Statement* stmt;
+    Expression* expr = NULL;
+    Statements* const body = factory_->template NewVector<Statement*>();
 
     if (token_ == Token::CASE) {
       Next();
-      Expression* const expr = ParseExpression(true, CHECK);
-      clause = factory_->NewCaseClause(false, expr);
+      expr = ParseExpression(true, CHECK);
     } else  {
       EXPECT(Token::DEFAULT);
-      clause = factory_->NewCaseClause(true, NULL);
     }
 
     EXPECT(Token::COLON);
@@ -905,11 +915,11 @@ class Parser
     while (token_ != Token::RBRACE &&
            token_ != Token::CASE   &&
            token_ != Token::DEFAULT) {
-      stmt = ParseStatement(CHECK);
-      clause->AddStatement(stmt);
+      Statement* const stmt = ParseStatement(CHECK);
+      body->push_back(stmt);
     }
 
-    return clause;
+    return factory_->NewCaseClause(expr == NULL, expr, body);
   }
 
 //  ThrowStatement
@@ -1023,7 +1033,7 @@ class Parser
       Identifier* const label = expr->AsIdentifier();
       const bool exist_labels = labels;
       if (!exist_labels) {
-        labels = factory_->NewLabels();
+        labels = factory_->template NewVector<Identifier*>();
       }
       if (ContainsLabel(labels, label) || TargetsContainsLabel(label)) {
         // duplicate label
@@ -1188,7 +1198,7 @@ class Parser
       op = token_;
       Next();
       right = ParseUnaryExpression(CHECK);
-      left = ReduceBinaryOperation(op, left, right);
+      left = ReduceBinaryOperation<ReduceExpressions>(op, left, right);
     }
     if (prec < 1) return left;
 
@@ -1198,7 +1208,7 @@ class Parser
       op = token_;
       Next();
       right = ParseBinaryExpression(contains_in, 0, CHECK);
-      left = ReduceBinaryOperation(op, left, right);
+      left = ReduceBinaryOperation<ReduceExpressions>(op, left, right);
     }
     if (prec < 2) return left;
 
@@ -1209,7 +1219,7 @@ class Parser
       op = token_;
       Next();
       right = ParseBinaryExpression(contains_in, 1, CHECK);
-      left = ReduceBinaryOperation(op, left, right);
+      left = ReduceBinaryOperation<ReduceExpressions>(op, left, right);
     }
     if (prec < 3) return left;
 
@@ -1241,7 +1251,7 @@ class Parser
       op = token_;
       Next();
       right = ParseBinaryExpression(contains_in, 4, CHECK);
-      left = ReduceBinaryOperation(op, left, right);
+      left = ReduceBinaryOperation<ReduceExpressions>(op, left, right);
     }
     if (prec < 6) return left;
 
@@ -1250,7 +1260,7 @@ class Parser
       op = token_;
       Next();
       right = ParseBinaryExpression(contains_in, 5, CHECK);
-      left = ReduceBinaryOperation(op, left, right);
+      left = ReduceBinaryOperation<ReduceExpressions>(op, left, right);
     }
     if (prec < 7) return left;
 
@@ -1259,7 +1269,7 @@ class Parser
       op = token_;
       Next();
       right = ParseBinaryExpression(contains_in, 6, CHECK);
-      left = ReduceBinaryOperation(op, left, right);
+      left = ReduceBinaryOperation<ReduceExpressions>(op, left, right);
     }
     if (prec < 8) return left;
 
@@ -1282,9 +1292,11 @@ class Parser
     return left;
   }
 
+  template<bool Reduce>
   Expression* ReduceBinaryOperation(Token::Type op,
                                     Expression* left,
-                                    Expression* right) {
+                                    Expression* right,
+                                    typename enable_if_c<Reduce>::type* = 0) {
     if (left->AsNumberLiteral() &&
         right->AsNumberLiteral()) {
       const double l_val = left->AsNumberLiteral()->value();
@@ -1354,6 +1366,14 @@ class Parser
     }
   }
 
+  template<bool Reduce>
+  Expression* ReduceBinaryOperation(Token::Type op,
+                                    Expression* left,
+                                    Expression* right,
+                                    typename enable_if_c<!Reduce>::type* = 0) {
+    return factory_->NewBinaryOperation(op, left, right);
+  }
+
 //  UnaryExpression
 //    : PostfixExpression
 //    | DELETE UnaryExpression
@@ -1511,11 +1531,11 @@ class Parser
     } else {
       Next();
       Expression* const target = ParseMemberExpression(false, CHECK);
-      ConstructorCall* const con = factory_->NewConstructorCall(target);
+      Expressions* const args = factory_->template NewVector<Expression*>();
       if (token_ == Token::LPAREN) {
-        ParseArguments(con, CHECK);
+        ParseArguments(args, CHECK);
       }
-      expr = con;
+      expr = factory_->NewConstructorCall(target, args);
     }
     while (true) {
       switch (token_) {
@@ -1537,9 +1557,10 @@ class Parser
 
         case Token::LPAREN:
           if (allow_call) {
-            FunctionCall* const funcall = factory_->NewFunctionCall(expr);
-            ParseArguments(funcall, CHECK);
-            expr = funcall;
+            Expressions* const args =
+                factory_->template NewVector<Expression*>();
+            ParseArguments(args, CHECK);
+            expr = factory_->NewFunctionCall(expr, args);
           } else {
             return expr;
           }
@@ -1653,20 +1674,20 @@ class Parser
 //  ArgumentList
 //    : AssignmentExpression
 //    | ArgumentList ',' AssignmentExpression
-  template<typename Callable>
-  Callable* ParseArguments(Callable* func, bool *res) {
+  template<typename Container>
+  Container* ParseArguments(Container* container, bool *res) {
     Next();
     if (token_ != Token::RPAREN) {
       Expression* const first = ParseAssignmentExpression(true, CHECK);
-      func->AddArgument(first);
+      container->push_back(first);
       while (token_ == Token::COMMA) {
         Next();
         Expression* const expr = ParseAssignmentExpression(true, CHECK);
-        func->AddArgument(expr);
+        container->push_back(expr);
       }
     }
     EXPECT(Token::RPAREN);
-    return func;
+    return container;
   }
 
   Expression* ParseRegExpLiteral(bool contains_eq, bool *res) {
@@ -1700,23 +1721,22 @@ class Parser
 //    : ','
 //    | Elision ','
   Expression* ParseArrayLiteral(bool *res) {
-    ArrayLiteral* const array = factory_->NewArrayLiteral();
-    Expression* expr;
+    Expressions* const items = factory_->template NewVector<Expression*>();
     Next();
     while (token_ != Token::RBRACK) {
       if (token_ == Token::COMMA) {
         // when Token::COMMA, only increment length
-        array->AddItem(NULL);
+        items->push_back(NULL);
       } else {
-        expr = ParseAssignmentExpression(true, CHECK);
-        array->AddItem(expr);
+        Expression* const expr = ParseAssignmentExpression(true, CHECK);
+        items->push_back(expr);
       }
       if (token_ != Token::RBRACK) {
         EXPECT(Token::COMMA);
       }
     }
     Next();
-    return array;
+    return factory_->NewArrayLiteral(items);
   }
 
 
@@ -1746,7 +1766,9 @@ class Parser
 //    : IDENTIFIER
   Expression* ParseObjectLiteral(bool *res) {
     typedef std::tr1::unordered_map<IdentifierKey, int> ObjectMap;
-    ObjectLiteral* const object = factory_->NewObjectLiteral();
+    typedef typename ObjectLiteral::Property Property;
+    typedef typename ObjectLiteral::Properties Properties;
+    Properties* const prop = factory_->template NewVector<Property>();
     ObjectMap map;
     Expression* expr;
     Identifier* ident;
@@ -1763,7 +1785,7 @@ class Parser
           ident = ParseIdentifier(
               is_get ? ParserData::kGet : ParserData::kSet);
           expr = ParseAssignmentExpression(true, CHECK);
-          object->AddDataProperty(ident, expr);
+          ObjectLiteral::AddDataProperty(prop, ident, expr);
           typename ObjectMap::iterator it = map.find(ident);
           if (it == map.end()) {
             map.insert(std::make_pair(ident, ObjectLiteral::DATA));
@@ -1794,7 +1816,7 @@ class Parser
                 FunctionLiteral::EXPRESSION,
                 (is_get) ? FunctionLiteral::GETTER : FunctionLiteral::SETTER,
                 CHECK);
-            object->AddAccessor(type, ident, expr);
+            ObjectLiteral::AddAccessor(prop, type, ident, expr);
             typename ObjectMap::iterator it = map.find(ident);
             if (it == map.end()) {
               map.insert(std::make_pair(ident, type));
@@ -1823,7 +1845,7 @@ class Parser
         }
         EXPECT(Token::COLON);
         expr = ParseAssignmentExpression(true, CHECK);
-        object->AddDataProperty(ident, expr);
+        ObjectLiteral::AddDataProperty(prop, ident, expr);
         typename ObjectMap::iterator it = map.find(ident);
         if (it == map.end()) {
           map.insert(std::make_pair(ident, ObjectLiteral::DATA));
@@ -1849,7 +1871,7 @@ class Parser
       }
     }
     Next();
-    return object;
+    return factory_->NewObjectLiteral(prop);
   }
 
   FunctionLiteral* ParseFunctionLiteral(
@@ -1866,7 +1888,8 @@ class Parser
       kDetectArgumentsName,
       kDetectEvalParameter,
       kDetectArgumentsParameter,
-      kDetectDuplicateParameter
+      kDetectDuplicateParameter,
+      kDetectFutureReservedWords
     } throw_error_if_strict_code = kDetectNone;
 
     FunctionLiteral* const literal = factory_->NewFunctionLiteral(decl_type);
@@ -1874,15 +1897,23 @@ class Parser
 
     if (arg_type == FunctionLiteral::GENERAL) {
       assert(token_ == Token::FUNCTION);
-      Next();
-      if (token_ == Token::IDENTIFIER) {
+      Next(true);  // preparing for strict directive
+      const Token::Type current = token_;
+      if (current == Token::IDENTIFIER ||
+          Token::IsAddedFutureReservedWordInStrictCode(current)) {
         Identifier* const name = ParseIdentifier(lexer_.Buffer());
         literal->SetName(name);
-        const EvalOrArguments val = IsEvalOrArguments(name);
-        if (val) {
-          throw_error_if_strict_code = (val == kEval) ?
-              kDetectEvalName : kDetectArgumentsName;
+        if (Token::IsAddedFutureReservedWordInStrictCode(current)) {
+          throw_error_if_strict_code = kDetectFutureReservedWords;
           throw_error_if_strict_code_line = lexer_.line_number();
+        } else {
+          assert(current == Token::IDENTIFIER);
+          const EvalOrArguments val = IsEvalOrArguments(name);
+          if (val) {
+            throw_error_if_strict_code = (val == kEval) ?
+                kDetectEvalName : kDetectArgumentsName;
+            throw_error_if_strict_code_line = lexer_.line_number();
+          }
         }
       } else if (decl_type == FunctionLiteral::DECLARATION ||
                  decl_type == FunctionLiteral::STATEMENT) {
@@ -1895,21 +1926,32 @@ class Parser
     literal->set_start_position(lexer_.begin_position());
 
     //  '(' FormalParameterList_opt ')'
-    EXPECT(Token::LPAREN);
+    IS(Token::LPAREN);
+    Next(true);  // preparing for strict directive
 
     if (arg_type == FunctionLiteral::GETTER) {
       // if getter, parameter count is 0
       EXPECT(Token::RPAREN);
     } else if (arg_type == FunctionLiteral::SETTER) {
       // if setter, parameter count is 1
-      IS(Token::IDENTIFIER);
+      const Token::Type current = token_;
+      if (current != Token::IDENTIFIER &&
+          !Token::IsAddedFutureReservedWordInStrictCode(current)) {
+        IS(Token::IDENTIFIER);
+      }
       Identifier* const ident = ParseIdentifier(lexer_.Buffer());
       if (!throw_error_if_strict_code) {
-        const EvalOrArguments val = IsEvalOrArguments(ident);
-        if (val) {
-          throw_error_if_strict_code = (val == kEval) ?
-              kDetectEvalParameter : kDetectArgumentsParameter;
+        if (Token::IsAddedFutureReservedWordInStrictCode(current)) {
+          throw_error_if_strict_code = kDetectFutureReservedWords;
           throw_error_if_strict_code_line = lexer_.line_number();
+        } else {
+          assert(current == Token::IDENTIFIER);
+          const EvalOrArguments val = IsEvalOrArguments(ident);
+          if (val) {
+            throw_error_if_strict_code = (val == kEval) ?
+                kDetectEvalName : kDetectArgumentsName;
+            throw_error_if_strict_code_line = lexer_.line_number();
+          }
         }
       }
       literal->AddParameter(ident);
@@ -1917,14 +1959,24 @@ class Parser
     } else {
       if (token_ != Token::RPAREN) {
         do {
-          IS(Token::IDENTIFIER);
+          const Token::Type current = token_;
+          if (current != Token::IDENTIFIER &&
+              !Token::IsAddedFutureReservedWordInStrictCode(current)) {
+            IS(Token::IDENTIFIER);
+          }
           Identifier* const ident = ParseIdentifier(lexer_.Buffer());
           if (!throw_error_if_strict_code) {
-            const EvalOrArguments val = IsEvalOrArguments(ident);
-            if (val) {
-              throw_error_if_strict_code = (val == kEval) ?
-                  kDetectEvalParameter : kDetectArgumentsParameter;
+            if (Token::IsAddedFutureReservedWordInStrictCode(current)) {
+              throw_error_if_strict_code = kDetectFutureReservedWords;
               throw_error_if_strict_code_line = lexer_.line_number();
+            } else {
+              assert(current == Token::IDENTIFIER);
+              const EvalOrArguments val = IsEvalOrArguments(ident);
+              if (val) {
+                throw_error_if_strict_code = (val == kEval) ?
+                    kDetectEvalName : kDetectArgumentsName;
+                throw_error_if_strict_code_line = lexer_.line_number();
+              }
             }
             if ((!throw_error_if_strict_code) &&
                 (param_set.find(ident) != param_set.end())) {
@@ -1935,7 +1987,7 @@ class Parser
           literal->AddParameter(ident);
           param_set.insert(ident);
           if (token_ == Token::COMMA) {
-            Next();
+            Next(true);
           } else {
             break;
           }
@@ -1983,6 +2035,11 @@ class Parser
               "duplicate parameter not allowed in strict code",
               throw_error_if_strict_code_line);
           break;
+        case kDetectFutureReservedWords:
+          RAISE_WITH_NUMBER(
+              "FutureReservedWords is found in strict code",
+              throw_error_if_strict_code_line);
+          break;
       }
     }
     literal->set_end_position(lexer_.end_position());
@@ -2136,6 +2193,9 @@ class Parser
   inline Token::Type Next() {
     return token_ = lexer_.Next<IdentifyReservedWords>(strict_);
   }
+  inline Token::Type Next(bool strict) {
+    return token_ = lexer_.Next<IdentifyReservedWords>(strict);
+  }
   inline Token::Type Peek() const {
     return token_;
   }

data/ext/include/iv/token.h

@@ -125,29 +125,32 @@ class Token {
     FINAL,           // final
     FLOAT,           // float
     GOTO,            // goto
-    IMPLEMENTS,      // implements
     IMPORT,          // import
     INT,             // int
-    INTERFACE,       // interface
     LONG,            // long
     NATIVE,          // native
-    PACKAGE,         // package
-    PRIVATE,         // private
-    PROTECTED,       // protected
-    PUBLIC,          // public
     SHORT,           // short
-    STATIC,          // static
     SUPER,           // super
     SYNCHRONIZED,    // synchronized
     THROWS,          // throws
     TRANSIENT,       // transient
     VOLATILE,        // volatile
-    LET,             // let
-    YIELD,           // yield
 
     GET,             // get
     SET,             // set
 
+    STRICT_FIRST,    // STRICT FIRST
+    IMPLEMENTS,      // implements
+    LET,             // let
+    PRIVATE,         // private
+    PUBLIC,          // public
+    YIELD,           // yield
+    INTERFACE,       // interface
+    PACKAGE,         // package
+    PROTECTED,       // protected
+    STATIC,          // static
+    STRICT_LAST,     // STRICT LAST
+
     NULL_LITERAL,    // NULL   LITERAL
     FALSE_LITERAL,   // FALSE  LITERAL
     TRUE_LITERAL,    // TRUE   LITERAL
@@ -165,12 +168,19 @@ class Token {
   static inline bool IsAssignOp(Token::Type type) {
     return Token::ASSIGN_FIRST < type && type < Token::ASSIGN_LAST;
   }
+
+  static inline bool IsAddedFutureReservedWordInStrictCode(Token::Type type) {
+    return Token::STRICT_FIRST < type && type < Token::STRICT_LAST;
+  }
+
   static inline const char* ToString(Token::Type type) {
     assert(0 <= type && type < NUM_TOKENS);
     assert(type != Token::ASSIGN_FIRST &&
            type != Token::ASSIGN_LAST &&
            type != Token::REL_FIRST &&
            type != Token::REL_LAST &&
+           type != Token::STRICT_FIRST &&
+           type != Token::STRICT_LAST &&
            type != Token::STRING &&
            type != Token::NUMBER &&
            type != Token::IDENTIFIER &&
@@ -278,27 +288,29 @@ const char* TokenContents<T>::kContents[Token::NUM_TOKENS] = {
   "final",
   "float",
   "goto",
-  "implements",
   "import",
   "int",
-  "interface",
   "long",
   "native",
-  "package",
-  "private",
-  "protected",
-  "public",
   "short",
-  "static",
   "super",
   "synchronized",
   "throws",
   "transient",
   "volatile",
-  "let",
-  "yield",
   "get",
   "set",
+  NULL,
+  "implements",
+  "let",
+  "private",
+  "public",
+  "yield",
+  "interface",
+  "package",
+  "protected",
+  "static",
+  NULL,
   "null",
   "false",
   "true",