[Isolates] Moved more compilation-related globals (builtins, runtime, &c.)...

src/parser.cc

 // Copyright 2010 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 799 matching lines @@
 
   virtual Handle<String> LookupSymbol(const char* string, int length) {
     return Handle<String>();
   }
 
   virtual Handle<String> EmptySymbol() {
     return Handle<String>();
   }
 
   virtual Expression* NewProperty(Expression* obj, Expression* key, int pos) {
-    if (obj == VariableProxySentinel::this_proxy()) {
-      return Property::this_property();
+    Isolate* isolate = Isolate::Current();
+    if (obj == isolate->ast_sentinels()->this_proxy()) {
+      return isolate->ast_sentinels()->this_property();
     } else {
-      return ValidLeftHandSideSentinel::instance();
+      return isolate->ast_sentinels()->valid_left_hand_side_sentinel();
     }
   }
 
   virtual Expression* NewCall(Expression* expression,
                               ZoneList<Expression*>* arguments,
                               int pos) {
-    return Call::sentinel();
+    return Isolate::Current()->ast_sentinels()->call_sentinel();
   }
 
   virtual Statement* EmptyStatement() {
     return NULL;
   }
 
   template <typename T> ZoneListWrapper<T> NewList(int size) {
     return is_pre_parsing_ ? ZoneListWrapper<T>() : ZoneListWrapper<T>(size);
   }
 
@@ skipping 32 matching lines @@
   virtual Expression* NewProperty(Expression* obj, Expression* key, int pos) {
     return new Property(obj, key, pos);
   }
 
   virtual Expression* NewCall(Expression* expression,
                               ZoneList<Expression*>* arguments,
                               int pos) {
     return new Call(expression, arguments, pos);
   }
 
-  virtual Statement* EmptyStatement();
+  virtual Statement* EmptyStatement() {
+    return Isolate::Current()->ast_sentinels()->empty_statement();
+  }
 };
 
 
 class ParserRecorder: public ParserLog {
  public:
   ParserRecorder();
   virtual FunctionEntry LogFunction(int start);
   virtual void LogError() { }
   virtual void LogMessage(Scanner::Location loc,
                           const char* message,
@@ skipping 172 matching lines @@
 
 
 Scope* AstBuildingParserFactory::NewScope(Scope* parent, Scope::Type type,
                                           bool inside_with) {
   Scope* result = new Scope(parent, type);
   result->Initialize(inside_with);
   return result;
 }
 
 
-Statement* AstBuildingParserFactory::EmptyStatement() {
-  // Use a statically allocated empty statement singleton to avoid
-  // allocating lots and lots of empty statements.
-  static v8::internal::EmptyStatement empty;
-  return &empty;
-}
-
-
 Scope* ParserFactory::NewScope(Scope* parent, Scope::Type type,
                                bool inside_with) {
   ASSERT(parent != NULL);
   parent->type_ = type;
   return parent;
 }
 
 
 VariableProxy* PreParser::Declare(Handle<String> name, Variable::Mode mode,
                                   FunctionLiteral* fun, bool resolve,
@@ skipping 942 matching lines @@
 
 
 // If the variable declaration declares exactly one non-const
 // variable, then *var is set to that variable. In all other cases,
 // *var is untouched; in particular, it is the caller's responsibility
 // to initialize it properly. This mechanism is used for the parsing
 // of 'for-in' loops.
 Block* Parser::ParseVariableDeclarations(bool accept_IN,
                                          Expression** var,
                                          bool* ok) {
+  Isolate* isolate = Isolate::Current();
   // VariableDeclarations ::
   //   ('var' | 'const') (Identifier ('=' AssignmentExpression)?)+[',']
 
   Variable::Mode mode = Variable::VAR;
   bool is_const = false;
   if (peek() == Token::VAR) {
     Consume(Token::VAR);
   } else if (peek() == Token::CONST) {
     Consume(Token::CONST);
     mode = Variable::CONST;
@@ skipping 149 matching lines @@
       Assignment* assignment = NEW(Assignment(op, last_var, value, position));
       if (block) block->AddStatement(NEW(ExpressionStatement(assignment)));
     }
   } while (peek() == Token::COMMA);
 
   if (!is_const && nvars == 1) {
     // We have a single, non-const variable.
     if (is_pre_parsing_) {
       // If we're preparsing then we need to set the var to something
       // in order for for-in loops to parse correctly.
-      *var = ValidLeftHandSideSentinel::instance();
+      *var = isolate->ast_sentinels()->valid_left_hand_side_sentinel();
     } else {
       ASSERT(last_var != NULL);
       *var = last_var;
     }
   }
 
   return block;
 }
 
 
@@ skipping 1031 matching lines @@
                          Vector<const char*>::empty());
   default:
     const char* name = Token::String(token);
     ASSERT(name != NULL);
     ReportMessage("unexpected_token", Vector<const char*>(&name, 1));
   }
 }
 
 
 Expression* Parser::ParsePrimaryExpression(bool* ok) {
+  Isolate* isolate = Isolate::Current();
   // PrimaryExpression ::
   //   'this'
   //   'null'
   //   'true'
   //   'false'
   //   Identifier
   //   Number
   //   String
   //   ArrayLiteral
   //   ObjectLiteral
   //   RegExpLiteral
   //   '(' Expression ')'
 
   Expression* result = NULL;
   switch (peek()) {
     case Token::THIS: {
       Consume(Token::THIS);
       if (is_pre_parsing_) {
-        result = VariableProxySentinel::this_proxy();
+        result = isolate->ast_sentinels()->this_proxy();
       } else {
         VariableProxy* recv = top_scope_->receiver();
         result = recv;
       }
       break;
     }
 
     case Token::NULL_LITERAL:
       Consume(Token::NULL_LITERAL);
       result = NEW(Literal(Factory::null_value()));
       break;
 
     case Token::TRUE_LITERAL:
       Consume(Token::TRUE_LITERAL);
       result = NEW(Literal(Factory::true_value()));
       break;
 
     case Token::FALSE_LITERAL:
       Consume(Token::FALSE_LITERAL);
       result = NEW(Literal(Factory::false_value()));
       break;
 
     case Token::IDENTIFIER: {
       Handle<String> name = ParseIdentifier(CHECK_OK);
       if (is_pre_parsing_) {
-        result = VariableProxySentinel::identifier_proxy();
+        result = isolate->ast_sentinels()->identifier_proxy();
       } else {
         result = top_scope_->NewUnresolved(name, inside_with());
       }
       break;
     }
 
     case Token::NUMBER: {
       Consume(Token::NUMBER);
       double value =
         StringToDouble(scanner_.literal_string(), ALLOW_HEX | ALLOW_OCTALS);
@@ skipping 539 matching lines @@
   }
 }
 
 
 Expression* Parser::ParseV8Intrinsic(bool* ok) {
   // CallRuntime ::
   //   '%' Identifier Arguments
 
   Expect(Token::MOD, CHECK_OK);
   Handle<String> name = ParseIdentifier(CHECK_OK);
-  Runtime::Function* function =
+  const Runtime::Function* function =
       Runtime::FunctionForName(scanner_.literal_string());
   ZoneList<Expression*>* args = ParseArguments(CHECK_OK);
   if (function == NULL && extension_ != NULL) {
     // The extension structures are only accessible while parsing the
     // very first time not when reparsing because of lazy compilation.
     top_scope_->ForceEagerCompilation();
   }
 
   // Check for built-in macros.
   if (!is_pre_parsing_) {
@@ skipping 778 matching lines @@
       Advance();
     } else if (FLAG_regexp_possessive_quantifier && current() == '+') {
       // FLAG_regexp_possessive_quantifier is a debug-only flag.
       type = RegExpQuantifier::POSSESSIVE;
       Advance();
     }
     builder->AddQuantifierToAtom(min, max, type);
   }
 }
 
-class SourceCharacter {
- public:
-  static bool Is(uc32 c) {
-    switch (c) {
-      // case ']': case '}':
-      // In spidermonkey and jsc these are treated as source characters
-      // so we do too.
-      case '^': case '$': case '\\': case '.': case '*': case '+':
-      case '?': case '(': case ')': case '[': case '{': case '|':
-      case RegExpParser::kEndMarker:
-        return false;
-      default:
-        return true;
-    }
-  }
-};
-
-
-static unibrow::Predicate<SourceCharacter> source_character;
-
-
-static inline bool IsSourceCharacter(uc32 c) {
-  return source_character.get(c);
-}
 
 #ifdef DEBUG
 // Currently only used in an ASSERT.
 static bool IsSpecialClassEscape(uc32 c) {
   switch (c) {
     case 'd': case 'D':
     case 's': case 'S':
     case 'w': case 'W':
       return true;
     default:
@@ skipping 349 matching lines @@
   return new RegExpCharacterClass(ranges, is_negated);
 }
 
 
 // ----------------------------------------------------------------------------
 // The Parser interface.
 
 // MakeAST() is just a wrapper for the corresponding Parser calls
 // so we don't have to expose the entire Parser class in the .h file.
 
-static bool always_allow_natives_syntax = false;
-
 
 ParserMessage::~ParserMessage() {
   for (int i = 0; i < args().length(); i++)
     DeleteArray(args()[i]);
   DeleteArray(args().start());
 }
 
 
 ScriptDataImpl::~ScriptDataImpl() {
   store_.Dispose();
@@ skipping 13 matching lines @@
 bool ScriptDataImpl::HasError() {
   return has_error();
 }
 
 
 ScriptDataImpl* PreParse(Handle<String> source,
                          unibrow::CharacterStream* stream,
                          v8::Extension* extension) {
   Handle<Script> no_script;
   bool allow_natives_syntax =
-      always_allow_natives_syntax ||
+      Isolate::Current()->always_allow_natives_syntax() ||
       FLAG_allow_natives_syntax ||
       Isolate::Current()->bootstrapper()->IsActive();
   PreParser parser(no_script, allow_natives_syntax, extension);
   if (!parser.PreParseProgram(source, stream)) return NULL;
   // The list owns the backing store so we need to clone the vector.
   // That way, the result will be exactly the right size rather than
   // the expected 50% too large.
   Vector<unsigned> store = parser.recorder()->store()->ToVector().Clone();
   return new ScriptDataImpl(store);
 }
@@ skipping 20 matching lines @@
   return !parser.failed();
 }
 
 
 FunctionLiteral* MakeAST(bool compile_in_global_context,
                          Handle<Script> script,
                          v8::Extension* extension,
                          ScriptDataImpl* pre_data,
                          bool is_json) {
   bool allow_natives_syntax =
-      always_allow_natives_syntax ||
+      Isolate::Current()->always_allow_natives_syntax() ||
       FLAG_allow_natives_syntax ||
       Isolate::Current()->bootstrapper()->IsActive();
   AstBuildingParser parser(script, allow_natives_syntax, extension, pre_data);
   if (pre_data != NULL && pre_data->has_error()) {
     Scanner::Location loc = pre_data->MessageLocation();
     const char* message = pre_data->BuildMessage();
     Vector<const char*> args = pre_data->BuildArgs();
     parser.ReportMessageAt(loc, message, args);
     DeleteArray(message);
     for (int i = 0; i < args.length(); i++) {
@@ skipping 12 matching lines @@
   }
   return result;
 }
 
 
 FunctionLiteral* MakeLazyAST(Handle<Script> script,
                              Handle<String> name,
                              int start_position,
                              int end_position,
                              bool is_expression) {
-  bool allow_natives_syntax_before = always_allow_natives_syntax;
-  always_allow_natives_syntax = true;
+  bool allow_natives_syntax_before =
+      Isolate::Current()->always_allow_natives_syntax();
+  Isolate::Current()->set_always_allow_natives_syntax(true);
   AstBuildingParser parser(script, true, NULL, NULL);  // always allow
-  always_allow_natives_syntax = allow_natives_syntax_before;
+  Isolate::Current()->set_always_allow_natives_syntax(
+      allow_natives_syntax_before);
   // Parse the function by pointing to the function source in the script source.
   Handle<String> script_source(String::cast(script->source()));
   FunctionLiteral* result =
       parser.ParseLazy(script_source, name,
                        start_position, end_position, is_expression);
   return result;
 }
 
 
 #undef NEW
 
 
 } }  // namespace v8::internal