Add parser support for generators.

src/preparser.h

 // Copyright 2012 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 222 matching lines @@
     }
     static Identifier Arguments()  {
       return Identifier(kArgumentsIdentifier);
     }
     static Identifier FutureReserved()  {
       return Identifier(kFutureReservedIdentifier);
     }
     static Identifier FutureStrictReserved()  {
       return Identifier(kFutureStrictReservedIdentifier);
     }
+    static Identifier Yield()  {
+      return Identifier(kFutureStrictReservedIdentifier);
+    }
     bool IsEval() { return type_ == kEvalIdentifier; }
     bool IsArguments() { return type_ == kArgumentsIdentifier; }
     bool IsEvalOrArguments() { return type_ >= kEvalIdentifier; }
+    bool IsYield() { return type_ == kYieldIdentifier; }
     bool IsFutureReserved() { return type_ == kFutureReservedIdentifier; }
     bool IsFutureStrictReserved() {
       return type_ == kFutureStrictReservedIdentifier;
     }
     bool IsValidStrictVariable() { return type_ == kUnknownIdentifier; }
 
    private:
     enum Type {
       kUnknownIdentifier,
       kFutureReservedIdentifier,
       kFutureStrictReservedIdentifier,
+      kYieldIdentifier,
       kEvalIdentifier,
       kArgumentsIdentifier
     };
     explicit Identifier(Type type) : type_(type) { }
     Type type_;
 
     friend class Expression;
   };
 
   // Bits 0 and 1 are used to identify the type of expression:
@@ skipping 177 matching lines @@
   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),
           language_mode_(
-              (prev_ != NULL) ? prev_->language_mode() : i::CLASSIC_MODE) {
+              (prev_ != NULL) ? prev_->language_mode() : i::CLASSIC_MODE),
+          is_generator_(false) {
       *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_generator() { return is_generator_; }
+    void set_is_generator(bool is_generator) { is_generator_ = is_generator; }
     bool is_classic_mode() {
       return language_mode_ == i::CLASSIC_MODE;
     }
     i::LanguageMode language_mode() {
       return language_mode_;
     }
     void set_language_mode(i::LanguageMode language_mode) {
       language_mode_ = language_mode;
     }
 
@@ skipping 11 matching lines @@
     };
 
    private:
     Scope** const variable_;
     Scope* const prev_;
     const ScopeType type_;
     int materialized_literal_count_;
     int expected_properties_;
     int with_nesting_count_;
     i::LanguageMode language_mode_;
+    bool is_generator_;
   };
 
   // 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;
@@ skipping 158 matching lines @@
   bool stack_overflow_;
   bool allow_lazy_;
   bool allow_modules_;
   bool allow_natives_syntax_;
   bool parenthesized_function_;
   bool harmony_scoping_;
 };
 } }  // v8::preparser
 
 #endif  // V8_PREPARSER_H