Version 3.7.1

src/preparser.h

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 100 matching lines @@
   };
 
   ~PreParser() {}
 
   // Pre-parse the program from the character stream; returns true on
   // success (even if parsing failed, the pre-parse data successfully
   // captured the syntax error), and false if a stack-overflow happened
   // during parsing.
   static PreParseResult PreParseProgram(i::JavaScriptScanner* scanner,
                                         i::ParserRecorder* log,
-                                        bool allow_lazy,
+                                        int flags,
                                         uintptr_t stack_limit) {
-    return PreParser(scanner, log, stack_limit, allow_lazy).PreParse();
+    bool allow_lazy = (flags & i::kAllowLazy) != 0;
+    bool allow_natives_syntax = (flags & i::kAllowNativesSyntax) != 0;
+    return PreParser(scanner, log, stack_limit,
+                     allow_lazy, allow_natives_syntax).PreParse();
   }
 
  private:
   // Used to detect duplicates in object literals. Each of the values
   // kGetterProperty, kSetterProperty and kValueProperty represents
   // a type of object literal property. When parsing a property, its
   // type value is stored in the DuplicateFinder for the property name.
   // Values are chosen so that having intersection bits means the there is
   // an incompatibility.
   // I.e., you can add a getter to a property that already has a setter, since
@@ skipping 38 matching lines @@
     kTopLevelScope,
     kFunctionScope
   };
 
   enum VariableDeclarationContext {
     kSourceElement,
     kStatement,
     kForStatement
   };
 
+  // If a list of variable declarations includes any initializers.
+  enum VariableDeclarationProperties {
+    kHasInitializers,
+    kHasNoInitializers
+  };
+
   class Expression;
 
   class Identifier {
    public:
     static Identifier Default() {
       return Identifier(kUnknownIdentifier);
     }
     static Identifier Eval()  {
       return Identifier(kEvalIdentifier);
     }
@@ skipping 200 matching lines @@
     explicit Statement(Type code) : code_(code) {}
     Type code_;
   };
 
   enum SourceElements {
     kUnknownSourceElements
   };
 
   typedef int Arguments;
 
+  // The Strict Mode (ECMA-262 5th edition, 4.2.2).
+  enum StrictModeFlag {
+    kNonStrictMode,
+    kStrictMode,
+    // This value is never used, but is needed to prevent GCC 4.5 from failing
+    // to compile when we assert that a flag is either kNonStrictMode or
+    // kStrictMode.
+    kInvalidStrictFlag
+  };
+
   class Scope {
    public:
     Scope(Scope** variable, ScopeType type)
         : variable_(variable),
           prev_(*variable),
           type_(type),
           materialized_literal_count_(0),
           expected_properties_(0),
           with_nesting_count_(0),
-          strict_((prev_ != NULL) && prev_->is_strict()) {
+          strict_mode_flag_((prev_ != NULL) ? prev_->strict_mode_flag()
+                            : kNonStrictMode) {
       *variable = this;
     }
     ~Scope() { *variable_ = prev_; }
     void NextMaterializedLiteralIndex() { materialized_literal_count_++; }
     void AddProperty() { expected_properties_++; }
     ScopeType type() { return type_; }
     int expected_properties() { return expected_properties_; }
     int materialized_literal_count() { return materialized_literal_count_; }
     bool IsInsideWith() { return with_nesting_count_ != 0; }
-    bool is_strict() { return strict_; }
-    void set_strict() { strict_ = true; }
+    bool is_strict_mode() { return strict_mode_flag_ == kStrictMode; }
+    StrictModeFlag strict_mode_flag() {
+      return strict_mode_flag_;
+    }
+    void set_strict_mode_flag(StrictModeFlag strict_mode_flag) {
+      strict_mode_flag_ = strict_mode_flag;
+    }
     void EnterWith() { with_nesting_count_++; }
     void LeaveWith() { with_nesting_count_--; }
 
    private:
     Scope** const variable_;
     Scope* const prev_;
     const ScopeType type_;
     int materialized_literal_count_;
     int expected_properties_;
     int with_nesting_count_;
-    bool strict_;
+    StrictModeFlag strict_mode_flag_;
   };
 
   // Private constructor only used in PreParseProgram.
   PreParser(i::JavaScriptScanner* scanner,
             i::ParserRecorder* log,
             uintptr_t stack_limit,
-            bool allow_lazy)
+            bool allow_lazy,
+            bool allow_natives_syntax)
       : scanner_(scanner),
         log_(log),
         scope_(NULL),
         stack_limit_(stack_limit),
         strict_mode_violation_location_(i::Scanner::Location::invalid()),
         strict_mode_violation_type_(NULL),
         stack_overflow_(false),
-        allow_lazy_(true),
+        allow_lazy_(allow_lazy),
+        allow_natives_syntax_(allow_natives_syntax),
         parenthesized_function_(false),
         harmony_scoping_(scanner->HarmonyScoping()) { }
 
   // Preparse the program. Only called in PreParseProgram after creating
   // the instance.
   PreParseResult PreParse() {
     Scope top_scope(&scope_, kTopLevelScope);
     bool ok = true;
     int start_position = scanner_->peek_location().beg_pos;
     ParseSourceElements(i::Token::EOS, &ok);
     if (stack_overflow_) return kPreParseStackOverflow;
     if (!ok) {
       ReportUnexpectedToken(scanner_->current_token());
-    } else if (scope_->is_strict()) {
+    } else if (scope_->is_strict_mode()) {
       CheckOctalLiteral(start_position, scanner_->location().end_pos, &ok);
     }
     return kPreParseSuccess;
   }
 
   // Report syntax error
   void ReportUnexpectedToken(i::Token::Value token);
   void ReportMessageAt(i::Scanner::Location location,
                        const char* type,
                        const char* name_opt) {
@@ skipping 13 matching lines @@
   // By making the 'exception handling' explicit, we are forced to check
   // for failure at the call sites.
   Statement ParseSourceElement(bool* ok);
   SourceElements ParseSourceElements(int end_token, bool* ok);
   Statement ParseStatement(bool* ok);
   Statement ParseFunctionDeclaration(bool* ok);
   Statement ParseBlock(bool* ok);
   Statement ParseVariableStatement(VariableDeclarationContext var_context,
                                    bool* ok);
   Statement ParseVariableDeclarations(VariableDeclarationContext var_context,
+                                      VariableDeclarationProperties* decl_props,
                                       int* num_decl,
                                       bool* ok);
   Statement ParseExpressionOrLabelledStatement(bool* ok);
   Statement ParseIfStatement(bool* ok);
   Statement ParseContinueStatement(bool* ok);
   Statement ParseBreakStatement(bool* ok);
   Statement ParseReturnStatement(bool* ok);
   Statement ParseWithStatement(bool* ok);
   Statement ParseSwitchStatement(bool* ok);
   Statement ParseDoWhileStatement(bool* ok);
@@ skipping 50 matching lines @@
         // have been seen using peek.
         stack_overflow_ = true;
       }
     }
     return scanner_->Next();
   }
 
   bool peek_any_identifier();
 
   void set_strict_mode() {
-    scope_->set_strict();
+    scope_->set_strict_mode_flag(kStrictMode);
   }
 
-  bool strict_mode() { return scope_->is_strict(); }
+  bool strict_mode() { return scope_->strict_mode_flag() == kStrictMode; }
 
   void Consume(i::Token::Value token) { Next(); }
 
   void Expect(i::Token::Value token, bool* ok) {
     if (Next() != token) {
       *ok = false;
     }
   }
 
   bool Check(i::Token::Value token) {
@@ skipping 20 matching lines @@
                                      bool* ok);
 
   i::JavaScriptScanner* scanner_;
   i::ParserRecorder* log_;
   Scope* scope_;
   uintptr_t stack_limit_;
   i::Scanner::Location strict_mode_violation_location_;
   const char* strict_mode_violation_type_;
   bool stack_overflow_;
   bool allow_lazy_;
+  bool allow_natives_syntax_;
   bool parenthesized_function_;
   bool harmony_scoping_;
 };
 } }  // v8::preparser
 
 #endif  // V8_PREPARSER_H