(Pre)Parser: Move FunctionState, BlockState and Scope handling to ParserBase.

src/parser.cc

 // 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 445 matching lines @@
     *variable_ = previous_;
   }
 
  private:
   Target** variable_;
   Target* previous_;
 };
 
 
 // ----------------------------------------------------------------------------
-// FunctionState and BlockState together implement the parser's scope stack.
-// The parser's current scope is in scope_.  The BlockState and
-// FunctionState constructors push on the scope stack and the destructors
-// pop.  They are also used to hold the parser's per-function and per-block
-// state.
-
-class Parser::BlockState BASE_EMBEDDED {
- public:
-  BlockState(Scope** scope_stack, Scope* scope)
-      : scope_stack_(scope_stack),
-        outer_scope_(*scope_stack) {
-    *scope_stack = scope;
-  }
-
-  ~BlockState() { *scope_stack_ = outer_scope_; }
-
- private:
-  Scope** scope_stack_;
-  Scope* outer_scope_;
-};
-
-
-Parser::FunctionState::FunctionState(FunctionState** function_state_stack,
-                                     Scope** scope_stack, Scope* scope,
-                                     Zone* zone)
-    : next_materialized_literal_index_(JSFunction::kLiteralsPrefixSize),
-      next_handler_index_(0),
-      expected_property_count_(0),
-      generator_object_variable_(NULL),
-      function_state_stack_(function_state_stack),
-      outer_function_state_(*function_state_stack),
-      scope_stack_(scope_stack),
-      outer_scope_(*scope_stack),
-      isolate_(zone->isolate()),
-      saved_ast_node_id_(isolate_->ast_node_id()),
-      factory_(zone) {
-  *scope_stack_ = scope;
-  *function_state_stack = this;
-  isolate_->set_ast_node_id(BailoutId::FirstUsable().ToInt());
-}
-
-
-Parser::FunctionState::~FunctionState() {
-  *scope_stack_ = outer_scope_;
-  *function_state_stack_ = outer_function_state_;
-  if (outer_function_state_ != NULL) {
-    isolate_->set_ast_node_id(saved_ast_node_id_);
-  }
-}
-
-
-// ----------------------------------------------------------------------------
 // The CHECK_OK macro is a convenient macro to enforce error
 // handling for functions that may fail (by returning !*ok).
 //
 // CAUTION: This macro appends extra statements after a call,
 // thus it must never be used where only a single statement
 // is correct (e.g. an if statement branch w/o braces)!
 
 #define CHECK_OK  ok);   \
   if (!*ok) return NULL; \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 #define CHECK_FAILED  /**/);   \
   if (failed_) return NULL; \
   ((void)0
 #define DUMMY )  // to make indentation work
 #undef DUMMY
 
 // ----------------------------------------------------------------------------
 // Implementation of Parser
 
-bool ParserTraits::is_classic_mode() const {
-  return parser_->scope_->is_classic_mode();
-}
-
-
-bool ParserTraits::is_generator() const {
-  return parser_->function_state_->is_generator();
-}
-
-
 bool ParserTraits::IsEvalOrArguments(Handle<String> identifier) const {
   return identifier.is_identical_to(
              parser_->isolate()->factory()->eval_string()) ||
          identifier.is_identical_to(
              parser_->isolate()->factory()->arguments_string());
 }
 
 
-int ParserTraits::NextMaterializedLiteralIndex() {
-  return parser_->function_state_->NextMaterializedLiteralIndex();
-}
-
-
 void ParserTraits::ReportMessageAt(Scanner::Location source_location,
                                    const char* message,
                                    Vector<const char*> args) {
   MessageLocation location(parser_->script_,
                            source_location.beg_pos,
                            source_location.end_pos);
   Factory* factory = parser_->isolate()->factory();
   Handle<FixedArray> elements = factory->NewFixedArray(args.length());
   for (int i = 0; i < args.length(); i++) {
     Handle<String> arg_string = factory->NewStringFromUtf8(CStrVector(args[i]));
@@ skipping 43 matching lines @@
   if (scanner.is_next_literal_ascii()) {
     return parser_->isolate_->factory()->NewStringFromAscii(
         scanner.next_literal_ascii_string(), tenured);
   } else {
     return parser_->isolate_->factory()->NewStringFromTwoByte(
         scanner.next_literal_utf16_string(), tenured);
   }
 }
 
 
-Expression* ParserTraits::NewRegExpLiteral(Handle<String> js_pattern,
-                                           Handle<String> js_flags,
-                                           int literal_index,
-                                           int pos) {
-  return parser_->factory()->NewRegExpLiteral(
-      js_pattern, js_flags, literal_index, pos);
-}
-
 Parser::Parser(CompilationInfo* info)
     : ParserBase<ParserTraits>(&scanner_,
                                info->isolate()->stack_guard()->real_climit(),
                                this),
       isolate_(info->isolate()),
       symbol_cache_(0, info->zone()),
       script_(info->script()),
       scanner_(isolate_->unicode_cache()),
       reusable_preparser_(NULL),
-      scope_(NULL),
       original_scope_(NULL),
-      function_state_(NULL),
       target_stack_(NULL),
       extension_(info->extension()),
       pre_parse_data_(NULL),
       fni_(NULL),
       zone_(info->zone()),
       info_(info) {
   ASSERT(!script_.is_null());
   isolate_->set_ast_node_id(0);
   set_allow_harmony_scoping(!info->is_native() && FLAG_harmony_scoping);
   set_allow_modules(!info->is_native() && FLAG_harmony_modules);
@@ skipping 3403 matching lines @@
     scope_->SetScopeName(function_name);
 
     if (is_generator) {
       // For generators, allocating variables in contexts is currently a win
       // because it minimizes the work needed to suspend and resume an
       // activation.
       scope_->ForceContextAllocation();
 
       // Calling a generator returns a generator object.  That object is stored
       // in a temporary variable, a definition that is used by "yield"
-      // expressions.  Presence of a variable for the generator object in the
-      // FunctionState indicates that this function is a generator.
+      // expressions. This also marks the FunctionState as a generator.
       Variable* temp = scope_->DeclarationScope()->NewTemporary(
           isolate()->factory()->dot_generator_object_string());
       function_state.set_generator_object_variable(temp);
     }
 
     //  FormalParameterList ::
     //    '(' (Identifier)*[','] ')'
     Expect(Token::LPAREN, CHECK_OK);
     scope->set_start_position(scanner().location().beg_pos);
 
@@ skipping 1448 matching lines @@
       ASSERT(info()->isolate()->has_pending_exception());
     } else {
       result = ParseProgram();
     }
   }
   info()->SetFunction(result);
   return (result != NULL);
 }
 
 } }  // namespace v8::internal