Merge isolates to bleeding_edge.

src/parser.h

 // 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 370 matching lines @@
     // Linked list implementation of stack of states.
     RegExpParserState* previous_state_;
     // Builder for the stored disjunction.
     RegExpBuilder* builder_;
     // Stored disjunction type (capture, look-ahead or grouping), if any.
     SubexpressionType group_type_;
     // Stored disjunction's capture index (if any).
     int disjunction_capture_index_;
   };
 
+  Isolate* isolate() { return isolate_; }
+
   uc32 current() { return current_; }
   bool has_more() { return has_more_; }
   bool has_next() { return next_pos_ < in()->length(); }
   uc32 Next();
   FlatStringReader* in() { return in_; }
   void ScanForCaptures();
 
+  Isolate* isolate_;
   Handle<String>* error_;
   ZoneList<RegExpCapture*>* captures_;
   FlatStringReader* in_;
   uc32 current_;
   int next_pos_;
   // The capture count is only valid after we have scanned for captures.
   int capture_count_;
   bool has_more_;
   bool multiline_;
   bool simple_;
@@ skipping 34 matching lines @@
   // should be checked.
   static const int kMaxNumFunctionParameters = 32766;
   FunctionLiteral* ParseLazy(CompilationInfo* info,
                              UC16CharacterStream* source,
                              ZoneScope* zone_scope);
   enum Mode {
     PARSE_LAZILY,
     PARSE_EAGERLY
   };
 
+  Isolate* isolate() { return isolate_; }
+
   // Called by ParseProgram after setting up the scanner.
   FunctionLiteral* DoParseProgram(Handle<String> source,
                                   bool in_global_context,
                                   StrictModeFlag strict_mode,
                                   ZoneScope* zone_scope);
 
   // Report syntax error
   void ReportUnexpectedToken(Token::Value token);
   void ReportInvalidPreparseData(Handle<String> name, bool* ok);
   void ReportMessage(const char* message, Vector<const char*> args);
@@ skipping 105 matching lines @@
     return scanner().peek();
   }
 
   INLINE(Token::Value Next()) {
     // BUG 1215673: Find a thread safe way to set a stack limit in
     // pre-parse mode. Otherwise, we cannot safely pre-parse from other
     // threads.
     if (stack_overflow_) {
       return Token::ILLEGAL;
     }
-    if (StackLimitCheck().HasOverflowed()) {
+    if (StackLimitCheck(isolate()).HasOverflowed()) {
       // Any further calls to Next or peek will return the illegal token.
       // The current call must return the next token, which might already
       // have been peek'ed.
       stack_overflow_ = true;
     }
     return scanner().Next();
   }
 
   bool peek_any_identifier();
 
   INLINE(void Consume(Token::Value token));
   void Expect(Token::Value token, bool* ok);
   bool Check(Token::Value token);
   void ExpectSemicolon(bool* ok);
 
   Handle<String> LiteralString(PretenureFlag tenured) {
     if (scanner().is_literal_ascii()) {
-      return Factory::NewStringFromAscii(scanner().literal_ascii_string(),
-                                         tenured);
+      return isolate_->factory()->NewStringFromAscii(
+          scanner().literal_ascii_string(), tenured);
     } else {
-      return Factory::NewStringFromTwoByte(scanner().literal_uc16_string(),
-                                           tenured);
+      return isolate_->factory()->NewStringFromTwoByte(
+            scanner().literal_uc16_string(), tenured);
     }
   }
 
   Handle<String> NextLiteralString(PretenureFlag tenured) {
     if (scanner().is_next_literal_ascii()) {
-      return Factory::NewStringFromAscii(scanner().next_literal_ascii_string(),
-                                         tenured);
+      return isolate_->factory()->NewStringFromAscii(
+          scanner().next_literal_ascii_string(), tenured);
     } else {
-      return Factory::NewStringFromTwoByte(scanner().next_literal_uc16_string(),
-                                           tenured);
+      return isolate_->factory()->NewStringFromTwoByte(
+          scanner().next_literal_uc16_string(), tenured);
     }
   }
 
   Handle<String> GetSymbol(bool* ok);
 
   // Get odd-ball literals.
   Literal* GetLiteralUndefined();
   Literal* GetLiteralTheHole();
   Literal* GetLiteralNumber(double value);
 
@@ skipping 59 matching lines @@
   // type. Both arguments must be non-null (in the handle sense).
   Expression* NewThrowTypeError(Handle<String> type,
                                 Handle<Object> first,
                                 Handle<Object> second);
 
   // Generic AST generator for throwing errors from compiled code.
   Expression* NewThrowError(Handle<String> constructor,
                             Handle<String> type,
                             Vector< Handle<Object> > arguments);
 
+  Isolate* isolate_;
   ZoneList<Handle<String> > symbol_cache_;
 
   Handle<Script> script_;
   V8JavaScriptScanner scanner_;
 
   Scope* top_scope_;
   int with_nesting_level_;
 
   TemporaryScope* temp_scope_;
   Mode mode_;
@@ skipping 59 matching lines @@
       ExternalTwoByteStringUC16CharacterStream stream(
           Handle<ExternalTwoByteString>::cast(source), 0, source->length());
       return JsonParser().ParseJson(source, &stream);
     } else {
       GenericStringUC16CharacterStream stream(source, 0, source->length());
       return JsonParser().ParseJson(source, &stream);
     }
   }
 
  private:
-  JsonParser() { }
+  JsonParser() : isolate_(Isolate::Current()), scanner_(isolate_) { }
   ~JsonParser() { }
 
+  Isolate* isolate() { return isolate_; }
+
   // Parse a string containing a single JSON value.
   Handle<Object> ParseJson(Handle<String> script, UC16CharacterStream* source);
   // Parse a single JSON value from input (grammar production JSONValue).
   // A JSON value is either a (double-quoted) string literal, a number literal,
   // one of "true", "false", or "null", or an object or array literal.
   Handle<Object> ParseJsonValue();
   // Parse a JSON object literal (grammar production JSONObject).
   // An object literal is a squiggly-braced and comma separated sequence
   // (possibly empty) of key/value pairs, where the key is a JSON string
   // literal, the value is a JSON value, and the two are separated by a colon.
   // A JSON array dosn't allow numbers and identifiers as keys, like a
   // JavaScript array.
   Handle<Object> ParseJsonObject();
   // Parses a JSON array literal (grammar production JSONArray). An array
   // literal is a square-bracketed and comma separated sequence (possibly empty)
   // of JSON values.
   // A JSON array doesn't allow leaving out values from the sequence, nor does
   // it allow a terminal comma, like a JavaScript array does.
   Handle<Object> ParseJsonArray();
 
   // Mark that a parsing error has happened at the current token, and
   // return a null handle. Primarily for readability.
   Handle<Object> ReportUnexpectedToken() { return Handle<Object>::null(); }
   // Converts the currently parsed literal to a JavaScript String.
   Handle<String> GetString();
 
+  Isolate* isolate_;
   JsonScanner scanner_;
   bool stack_overflow_;
 };
 } }  // namespace v8::internal
 
 #endif  // V8_PARSER_H_