remove Isolate::Current from most files starting with 'd' and 'e'
R=svenpanne@chromium.org BUG= Review URL: https://codereview.chromium.org/23606012 git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@16490 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
This commit is contained in:
dcarney@chromium.org
parent
675ac2660d
commit
0157c9f9e1
@ -127,9 +127,11 @@ MaybeObject* Accessors::ArraySetLength(Isolate* isolate,
|
||||
Handle<Object> value_handle(value, isolate);
|
||||
|
||||
bool has_exception;
|
||||
Handle<Object> uint32_v = Execution::ToUint32(value_handle, &has_exception);
|
||||
Handle<Object> uint32_v =
|
||||
Execution::ToUint32(isolate, value_handle, &has_exception);
|
||||
if (has_exception) return Failure::Exception();
|
||||
Handle<Object> number_v = Execution::ToNumber(value_handle, &has_exception);
|
||||
Handle<Object> number_v =
|
||||
Execution::ToNumber(isolate, value_handle, &has_exception);
|
||||
if (has_exception) return Failure::Exception();
|
||||
|
||||
if (uint32_v->Number() == number_v->Number()) {
|
||||
|
||||
40
src/api.cc
40
src/api.cc
@ -2738,7 +2738,7 @@ Local<String> Value::ToString() const {
|
||||
LOG_API(isolate, "ToString");
|
||||
ENTER_V8(isolate);
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
str = i::Execution::ToString(obj, &has_pending_exception);
|
||||
str = i::Execution::ToString(isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, Local<String>());
|
||||
}
|
||||
return ToApiHandle<String>(str);
|
||||
@ -2758,7 +2758,7 @@ Local<String> Value::ToDetailString() const {
|
||||
LOG_API(isolate, "ToDetailString");
|
||||
ENTER_V8(isolate);
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
str = i::Execution::ToDetailString(obj, &has_pending_exception);
|
||||
str = i::Execution::ToDetailString(isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, Local<String>());
|
||||
}
|
||||
return ToApiHandle<String>(str);
|
||||
@ -2778,7 +2778,7 @@ Local<v8::Object> Value::ToObject() const {
|
||||
LOG_API(isolate, "ToObject");
|
||||
ENTER_V8(isolate);
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
val = i::Execution::ToObject(obj, &has_pending_exception);
|
||||
val = i::Execution::ToObject(isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Object>());
|
||||
}
|
||||
return ToApiHandle<Object>(val);
|
||||
@ -2816,7 +2816,7 @@ Local<Number> Value::ToNumber() const {
|
||||
LOG_API(isolate, "ToNumber");
|
||||
ENTER_V8(isolate);
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
num = i::Execution::ToNumber(obj, &has_pending_exception);
|
||||
num = i::Execution::ToNumber(isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, Local<Number>());
|
||||
}
|
||||
return ToApiHandle<Number>(num);
|
||||
@ -2834,7 +2834,7 @@ Local<Integer> Value::ToInteger() const {
|
||||
LOG_API(isolate, "ToInteger");
|
||||
ENTER_V8(isolate);
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
num = i::Execution::ToInteger(obj, &has_pending_exception);
|
||||
num = i::Execution::ToInteger(isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, Local<Integer>());
|
||||
}
|
||||
return ToApiHandle<Integer>(num);
|
||||
@ -3054,7 +3054,7 @@ double Value::NumberValue() const {
|
||||
LOG_API(isolate, "NumberValue");
|
||||
ENTER_V8(isolate);
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
num = i::Execution::ToNumber(obj, &has_pending_exception);
|
||||
num = i::Execution::ToNumber(isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, i::OS::nan_value());
|
||||
}
|
||||
return num->Number();
|
||||
@ -3072,7 +3072,7 @@ int64_t Value::IntegerValue() const {
|
||||
LOG_API(isolate, "IntegerValue");
|
||||
ENTER_V8(isolate);
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
num = i::Execution::ToInteger(obj, &has_pending_exception);
|
||||
num = i::Execution::ToInteger(isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, 0);
|
||||
}
|
||||
if (num->IsSmi()) {
|
||||
@ -3094,7 +3094,7 @@ Local<Int32> Value::ToInt32() const {
|
||||
LOG_API(isolate, "ToInt32");
|
||||
ENTER_V8(isolate);
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
num = i::Execution::ToInt32(obj, &has_pending_exception);
|
||||
num = i::Execution::ToInt32(isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, Local<Int32>());
|
||||
}
|
||||
return ToApiHandle<Int32>(num);
|
||||
@ -3112,7 +3112,7 @@ Local<Uint32> Value::ToUint32() const {
|
||||
LOG_API(isolate, "ToUInt32");
|
||||
ENTER_V8(isolate);
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
num = i::Execution::ToUint32(obj, &has_pending_exception);
|
||||
num = i::Execution::ToUint32(isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, Local<Uint32>());
|
||||
}
|
||||
return ToApiHandle<Uint32>(num);
|
||||
@ -3131,7 +3131,7 @@ Local<Uint32> Value::ToArrayIndex() const {
|
||||
ENTER_V8(isolate);
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
i::Handle<i::Object> string_obj =
|
||||
i::Execution::ToString(obj, &has_pending_exception);
|
||||
i::Execution::ToString(isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, Local<Uint32>());
|
||||
i::Handle<i::String> str = i::Handle<i::String>::cast(string_obj);
|
||||
uint32_t index;
|
||||
@ -3159,7 +3159,7 @@ int32_t Value::Int32Value() const {
|
||||
ENTER_V8(isolate);
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
i::Handle<i::Object> num =
|
||||
i::Execution::ToInt32(obj, &has_pending_exception);
|
||||
i::Execution::ToInt32(isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, 0);
|
||||
if (num->IsSmi()) {
|
||||
return i::Smi::cast(*num)->value();
|
||||
@ -3240,7 +3240,7 @@ uint32_t Value::Uint32Value() const {
|
||||
ENTER_V8(isolate);
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
i::Handle<i::Object> num =
|
||||
i::Execution::ToUint32(obj, &has_pending_exception);
|
||||
i::Execution::ToUint32(isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, 0);
|
||||
if (num->IsSmi()) {
|
||||
return i::Smi::cast(*num)->value();
|
||||
@ -3377,7 +3377,7 @@ PropertyAttribute v8::Object::GetPropertyAttributes(v8::Handle<Value> key) {
|
||||
i::Handle<i::Object> key_obj = Utils::OpenHandle(*key);
|
||||
if (!key_obj->IsName()) {
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
key_obj = i::Execution::ToString(key_obj, &has_pending_exception);
|
||||
key_obj = i::Execution::ToString(isolate, key_obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, static_cast<PropertyAttribute>(NONE));
|
||||
}
|
||||
i::Handle<i::Name> key_name = i::Handle<i::Name>::cast(key_obj);
|
||||
@ -4079,7 +4079,7 @@ bool v8::Object::IsCallable() {
|
||||
i::HandleScope scope(isolate);
|
||||
i::Handle<i::JSObject> obj = Utils::OpenHandle(this);
|
||||
if (obj->IsJSFunction()) return true;
|
||||
return i::Execution::GetFunctionDelegate(obj)->IsJSFunction();
|
||||
return i::Execution::GetFunctionDelegate(isolate, obj)->IsJSFunction();
|
||||
}
|
||||
|
||||
|
||||
@ -4103,8 +4103,8 @@ Local<v8::Value> Object::CallAsFunction(v8::Handle<v8::Object> recv,
|
||||
fun = i::Handle<i::JSFunction>::cast(obj);
|
||||
} else {
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
i::Handle<i::Object> delegate =
|
||||
i::Execution::TryGetFunctionDelegate(obj, &has_pending_exception);
|
||||
i::Handle<i::Object> delegate = i::Execution::TryGetFunctionDelegate(
|
||||
isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, Local<Value>());
|
||||
fun = i::Handle<i::JSFunction>::cast(delegate);
|
||||
recv_obj = obj;
|
||||
@ -4140,8 +4140,8 @@ Local<v8::Value> Object::CallAsConstructor(int argc,
|
||||
i::Handle<i::JSObject>::cast(returned)));
|
||||
}
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
i::Handle<i::Object> delegate =
|
||||
i::Execution::TryGetConstructorDelegate(obj, &has_pending_exception);
|
||||
i::Handle<i::Object> delegate = i::Execution::TryGetConstructorDelegate(
|
||||
isolate, obj, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Object>());
|
||||
if (!delegate->IsUndefined()) {
|
||||
i::Handle<i::JSFunction> fun = i::Handle<i::JSFunction>::cast(delegate);
|
||||
@ -6050,7 +6050,7 @@ Local<v8::Value> v8::Date::New(double time) {
|
||||
ENTER_V8(isolate);
|
||||
EXCEPTION_PREAMBLE(isolate);
|
||||
i::Handle<i::Object> obj =
|
||||
i::Execution::NewDate(time, &has_pending_exception);
|
||||
i::Execution::NewDate(isolate, time, &has_pending_exception);
|
||||
EXCEPTION_BAILOUT_CHECK(isolate, Local<v8::Value>());
|
||||
return Utils::ToLocal(obj);
|
||||
}
|
||||
@ -7170,7 +7170,7 @@ void Debug::DisableAgent() {
|
||||
|
||||
|
||||
void Debug::ProcessDebugMessages() {
|
||||
i::Execution::ProcessDebugMessages(true);
|
||||
i::Execution::ProcessDebugMessages(i::Isolate::Current(), true);
|
||||
}
|
||||
|
||||
|
||||
|
||||
@ -766,7 +766,7 @@ void Shell::InstallUtilityScript(Isolate* isolate) {
|
||||
#ifdef ENABLE_DEBUGGER_SUPPORT
|
||||
if (i::FLAG_debugger) printf("JavaScript debugger enabled\n");
|
||||
// Install the debugger object in the utility scope
|
||||
i::Debug* debug = i::Isolate::Current()->debug();
|
||||
i::Debug* debug = reinterpret_cast<i::Isolate*>(isolate)->debug();
|
||||
debug->Load();
|
||||
i::Handle<i::JSObject> js_debug
|
||||
= i::Handle<i::JSObject>(debug->debug_context()->global_object());
|
||||
@ -935,7 +935,7 @@ Local<Context> Shell::CreateEvaluationContext(Isolate* isolate) {
|
||||
Context::Scope scope(context);
|
||||
|
||||
#ifndef V8_SHARED
|
||||
i::Factory* factory = i::Isolate::Current()->factory();
|
||||
i::Factory* factory = reinterpret_cast<i::Isolate*>(isolate)->factory();
|
||||
i::JSArguments js_args = i::FLAG_js_arguments;
|
||||
i::Handle<i::FixedArray> arguments_array =
|
||||
factory->NewFixedArray(js_args.argc());
|
||||
|
||||
@ -43,9 +43,9 @@ class DebuggerAgentSession;
|
||||
// handles connection from a remote debugger.
|
||||
class DebuggerAgent: public Thread {
|
||||
public:
|
||||
DebuggerAgent(const char* name, int port)
|
||||
DebuggerAgent(Isolate* isolate, const char* name, int port)
|
||||
: Thread(name),
|
||||
isolate_(Isolate::Current()),
|
||||
isolate_(isolate),
|
||||
name_(StrDup(name)), port_(port),
|
||||
server_(OS::CreateSocket()), terminate_(false),
|
||||
session_(NULL),
|
||||
|
||||
66
src/debug.cc
66
src/debug.cc
@ -86,8 +86,9 @@ static void PrintLn(v8::Local<v8::Value> value) {
|
||||
}
|
||||
|
||||
|
||||
static Handle<Code> ComputeCallDebugPrepareStepIn(int argc, Code::Kind kind) {
|
||||
Isolate* isolate = Isolate::Current();
|
||||
static Handle<Code> ComputeCallDebugPrepareStepIn(Isolate* isolate,
|
||||
int argc,
|
||||
Code::Kind kind) {
|
||||
return isolate->stub_cache()->ComputeCallDebugPrepareStepIn(argc, kind);
|
||||
}
|
||||
|
||||
@ -433,7 +434,7 @@ void BreakLocationIterator::PrepareStepIn(Isolate* isolate) {
|
||||
// the call in the original code as it is the code there that will be
|
||||
// executed in place of the debug break call.
|
||||
Handle<Code> stub = ComputeCallDebugPrepareStepIn(
|
||||
target_code->arguments_count(), target_code->kind());
|
||||
isolate, target_code->arguments_count(), target_code->kind());
|
||||
if (IsDebugBreak()) {
|
||||
original_rinfo()->set_target_address(stub->entry());
|
||||
} else {
|
||||
@ -633,7 +634,7 @@ const int Debug::kFrameDropperFrameSize = 4;
|
||||
|
||||
|
||||
void ScriptCache::Add(Handle<Script> script) {
|
||||
GlobalHandles* global_handles = Isolate::Current()->global_handles();
|
||||
GlobalHandles* global_handles = isolate_->global_handles();
|
||||
// Create an entry in the hash map for the script.
|
||||
int id = script->id()->value();
|
||||
HashMap::Entry* entry =
|
||||
@ -655,7 +656,7 @@ void ScriptCache::Add(Handle<Script> script) {
|
||||
|
||||
|
||||
Handle<FixedArray> ScriptCache::GetScripts() {
|
||||
Factory* factory = Isolate::Current()->factory();
|
||||
Factory* factory = isolate_->factory();
|
||||
Handle<FixedArray> instances = factory->NewFixedArray(occupancy());
|
||||
int count = 0;
|
||||
for (HashMap::Entry* entry = Start(); entry != NULL; entry = Next(entry)) {
|
||||
@ -670,7 +671,7 @@ Handle<FixedArray> ScriptCache::GetScripts() {
|
||||
|
||||
|
||||
void ScriptCache::ProcessCollectedScripts() {
|
||||
Debugger* debugger = Isolate::Current()->debugger();
|
||||
Debugger* debugger = isolate_->debugger();
|
||||
for (int i = 0; i < collected_scripts_.length(); i++) {
|
||||
debugger->OnScriptCollected(collected_scripts_[i]);
|
||||
}
|
||||
@ -679,7 +680,7 @@ void ScriptCache::ProcessCollectedScripts() {
|
||||
|
||||
|
||||
void ScriptCache::Clear() {
|
||||
GlobalHandles* global_handles = Isolate::Current()->global_handles();
|
||||
GlobalHandles* global_handles = isolate_->global_handles();
|
||||
// Iterate the script cache to get rid of all the weak handles.
|
||||
for (HashMap::Entry* entry = Start(); entry != NULL; entry = Next(entry)) {
|
||||
ASSERT(entry != NULL);
|
||||
@ -750,7 +751,7 @@ void Debug::HandleWeakDebugInfo(v8::Isolate* isolate,
|
||||
|
||||
|
||||
DebugInfoListNode::DebugInfoListNode(DebugInfo* debug_info): next_(NULL) {
|
||||
GlobalHandles* global_handles = Isolate::Current()->global_handles();
|
||||
GlobalHandles* global_handles = debug_info->GetIsolate()->global_handles();
|
||||
// Globalize the request debug info object and make it weak.
|
||||
debug_info_ = Handle<DebugInfo>::cast(
|
||||
(global_handles->Create(debug_info)));
|
||||
@ -761,13 +762,12 @@ DebugInfoListNode::DebugInfoListNode(DebugInfo* debug_info): next_(NULL) {
|
||||
|
||||
|
||||
DebugInfoListNode::~DebugInfoListNode() {
|
||||
Isolate::Current()->global_handles()->Destroy(
|
||||
debug_info_->GetIsolate()->global_handles()->Destroy(
|
||||
reinterpret_cast<Object**>(debug_info_.location()));
|
||||
}
|
||||
|
||||
|
||||
bool Debug::CompileDebuggerScript(int index) {
|
||||
Isolate* isolate = Isolate::Current();
|
||||
bool Debug::CompileDebuggerScript(Isolate* isolate, int index) {
|
||||
Factory* factory = isolate->factory();
|
||||
HandleScope scope(isolate);
|
||||
|
||||
@ -824,7 +824,7 @@ bool Debug::CompileDebuggerScript(int index) {
|
||||
ASSERT(!isolate->has_pending_exception());
|
||||
if (!exception.is_null()) {
|
||||
isolate->set_pending_exception(*exception);
|
||||
MessageHandler::ReportMessage(Isolate::Current(), NULL, message);
|
||||
MessageHandler::ReportMessage(isolate, NULL, message);
|
||||
isolate->clear_pending_exception();
|
||||
}
|
||||
return false;
|
||||
@ -852,7 +852,7 @@ bool Debug::Load() {
|
||||
|
||||
// Disable breakpoints and interrupts while compiling and running the
|
||||
// debugger scripts including the context creation code.
|
||||
DisableBreak disable(true);
|
||||
DisableBreak disable(isolate_, true);
|
||||
PostponeInterruptsScope postpone(isolate_);
|
||||
|
||||
// Create the debugger context.
|
||||
@ -886,12 +886,12 @@ bool Debug::Load() {
|
||||
// Compile the JavaScript for the debugger in the debugger context.
|
||||
debugger->set_compiling_natives(true);
|
||||
bool caught_exception =
|
||||
!CompileDebuggerScript(Natives::GetIndex("mirror")) ||
|
||||
!CompileDebuggerScript(Natives::GetIndex("debug"));
|
||||
!CompileDebuggerScript(isolate_, Natives::GetIndex("mirror")) ||
|
||||
!CompileDebuggerScript(isolate_, Natives::GetIndex("debug"));
|
||||
|
||||
if (FLAG_enable_liveedit) {
|
||||
caught_exception = caught_exception ||
|
||||
!CompileDebuggerScript(Natives::GetIndex("liveedit"));
|
||||
!CompileDebuggerScript(isolate_, Natives::GetIndex("liveedit"));
|
||||
}
|
||||
|
||||
debugger->set_compiling_natives(false);
|
||||
@ -958,7 +958,7 @@ Object* Debug::Break(Arguments args) {
|
||||
}
|
||||
|
||||
// Enter the debugger.
|
||||
EnterDebugger debugger;
|
||||
EnterDebugger debugger(isolate_);
|
||||
if (debugger.FailedToEnter()) {
|
||||
return heap->undefined_value();
|
||||
}
|
||||
@ -1649,7 +1649,7 @@ bool Debug::IsBreakStub(Code* code) {
|
||||
|
||||
// Find the builtin to use for invoking the debug break
|
||||
Handle<Code> Debug::FindDebugBreak(Handle<Code> code, RelocInfo::Mode mode) {
|
||||
Isolate* isolate = Isolate::Current();
|
||||
Isolate* isolate = code->GetIsolate();
|
||||
|
||||
// Find the builtin debug break function matching the calling convention
|
||||
// used by the call site.
|
||||
@ -1704,7 +1704,7 @@ Handle<Code> Debug::FindDebugBreak(Handle<Code> code, RelocInfo::Mode mode) {
|
||||
Handle<Object> Debug::GetSourceBreakLocations(
|
||||
Handle<SharedFunctionInfo> shared,
|
||||
BreakPositionAlignment position_alignment) {
|
||||
Isolate* isolate = Isolate::Current();
|
||||
Isolate* isolate = shared->GetIsolate();
|
||||
Heap* heap = isolate->heap();
|
||||
if (!HasDebugInfo(shared)) {
|
||||
return Handle<Object>(heap->undefined_value(), isolate);
|
||||
@ -1883,7 +1883,7 @@ static bool CompileFullCodeForDebugging(Handle<JSFunction> function,
|
||||
// Use compile lazy which will end up compiling the full code in the
|
||||
// configuration configured above.
|
||||
bool result = Compiler::CompileLazy(&info);
|
||||
ASSERT(result != Isolate::Current()->has_pending_exception());
|
||||
ASSERT(result != info.isolate()->has_pending_exception());
|
||||
info.isolate()->clear_pending_exception();
|
||||
#if DEBUG
|
||||
if (result) {
|
||||
@ -2537,7 +2537,7 @@ void Debug::CreateScriptCache() {
|
||||
"Debug::CreateScriptCache");
|
||||
|
||||
ASSERT(script_cache_ == NULL);
|
||||
script_cache_ = new ScriptCache();
|
||||
script_cache_ = new ScriptCache(isolate_);
|
||||
|
||||
// Scan heap for Script objects.
|
||||
int count = 0;
|
||||
@ -2754,7 +2754,7 @@ void Debugger::OnException(Handle<Object> exception, bool uncaught) {
|
||||
}
|
||||
|
||||
// Enter the debugger.
|
||||
EnterDebugger debugger;
|
||||
EnterDebugger debugger(isolate_);
|
||||
if (debugger.FailedToEnter()) return;
|
||||
|
||||
// Clear all current stepping setup.
|
||||
@ -2820,7 +2820,7 @@ void Debugger::OnBeforeCompile(Handle<Script> script) {
|
||||
if (!EventActive(v8::BeforeCompile)) return;
|
||||
|
||||
// Enter the debugger.
|
||||
EnterDebugger debugger;
|
||||
EnterDebugger debugger(isolate_);
|
||||
if (debugger.FailedToEnter()) return;
|
||||
|
||||
// Create the event data object.
|
||||
@ -2857,7 +2857,7 @@ void Debugger::OnAfterCompile(Handle<Script> script,
|
||||
bool in_debugger = debug->InDebugger();
|
||||
|
||||
// Enter the debugger.
|
||||
EnterDebugger debugger;
|
||||
EnterDebugger debugger(isolate_);
|
||||
if (debugger.FailedToEnter()) return;
|
||||
|
||||
// If debugging there might be script break points registered for this
|
||||
@ -2885,7 +2885,7 @@ void Debugger::OnAfterCompile(Handle<Script> script,
|
||||
bool caught_exception;
|
||||
Handle<Object> argv[] = { wrapper };
|
||||
Execution::TryCall(Handle<JSFunction>::cast(update_script_break_points),
|
||||
Isolate::Current()->js_builtins_object(),
|
||||
isolate_->js_builtins_object(),
|
||||
ARRAY_SIZE(argv),
|
||||
argv,
|
||||
&caught_exception);
|
||||
@ -2920,7 +2920,7 @@ void Debugger::OnScriptCollected(int id) {
|
||||
if (!Debugger::EventActive(v8::ScriptCollected)) return;
|
||||
|
||||
// Enter the debugger.
|
||||
EnterDebugger debugger;
|
||||
EnterDebugger debugger(isolate_);
|
||||
if (debugger.FailedToEnter()) return;
|
||||
|
||||
// Create the script collected state object.
|
||||
@ -3037,7 +3037,7 @@ void Debugger::CallJSEventCallback(v8::DebugEvent event,
|
||||
|
||||
Handle<Context> Debugger::GetDebugContext() {
|
||||
never_unload_debugger_ = true;
|
||||
EnterDebugger debugger;
|
||||
EnterDebugger debugger(isolate_);
|
||||
return isolate_->debug()->debug_context();
|
||||
}
|
||||
|
||||
@ -3390,7 +3390,7 @@ Handle<Object> Debugger::Call(Handle<JSFunction> fun,
|
||||
Debugger::never_unload_debugger_ = true;
|
||||
|
||||
// Enter the debugger.
|
||||
EnterDebugger debugger;
|
||||
EnterDebugger debugger(isolate_);
|
||||
if (debugger.FailedToEnter()) {
|
||||
return isolate_->factory()->undefined_value();
|
||||
}
|
||||
@ -3435,7 +3435,7 @@ bool Debugger::StartAgent(const char* name, int port,
|
||||
|
||||
if (Socket::SetUp()) {
|
||||
if (agent_ == NULL) {
|
||||
agent_ = new DebuggerAgent(name, port);
|
||||
agent_ = new DebuggerAgent(isolate_, name, port);
|
||||
agent_->Start();
|
||||
}
|
||||
return true;
|
||||
@ -3475,8 +3475,8 @@ void Debugger::CallMessageDispatchHandler() {
|
||||
}
|
||||
|
||||
|
||||
EnterDebugger::EnterDebugger()
|
||||
: isolate_(Isolate::Current()),
|
||||
EnterDebugger::EnterDebugger(Isolate* isolate)
|
||||
: isolate_(isolate),
|
||||
prev_(isolate_->debug()->debugger_entry()),
|
||||
it_(isolate_),
|
||||
has_js_frames_(!it_.done()),
|
||||
@ -3656,7 +3656,7 @@ v8::Handle<v8::String> MessageImpl::GetJSON() const {
|
||||
|
||||
|
||||
v8::Handle<v8::Context> MessageImpl::GetEventContext() const {
|
||||
Isolate* isolate = Isolate::Current();
|
||||
Isolate* isolate = event_data_->GetIsolate();
|
||||
v8::Handle<v8::Context> context = GetDebugEventContext(isolate);
|
||||
// Isolate::context() may be NULL when "script collected" event occures.
|
||||
ASSERT(!context.IsEmpty() || event_ == v8::ScriptCollected);
|
||||
@ -3697,7 +3697,7 @@ v8::Handle<v8::Object> EventDetailsImpl::GetEventData() const {
|
||||
|
||||
|
||||
v8::Handle<v8::Context> EventDetailsImpl::GetEventContext() const {
|
||||
return GetDebugEventContext(Isolate::Current());
|
||||
return GetDebugEventContext(exec_state_->GetIsolate());
|
||||
}
|
||||
|
||||
|
||||
|
||||
11
src/debug.h
11
src/debug.h
@ -174,7 +174,8 @@ class BreakLocationIterator {
|
||||
// the cache is the script id.
|
||||
class ScriptCache : private HashMap {
|
||||
public:
|
||||
ScriptCache() : HashMap(ScriptMatch), collected_scripts_(10) {}
|
||||
explicit ScriptCache(Isolate* isolate)
|
||||
: HashMap(ScriptMatch), isolate_(isolate), collected_scripts_(10) {}
|
||||
virtual ~ScriptCache() { Clear(); }
|
||||
|
||||
// Add script to the cache.
|
||||
@ -203,6 +204,7 @@ class ScriptCache : private HashMap {
|
||||
v8::Persistent<v8::Value>* obj,
|
||||
void* data);
|
||||
|
||||
Isolate* isolate_;
|
||||
// List used during GC to temporarily store id's of collected scripts.
|
||||
List<int> collected_scripts_;
|
||||
};
|
||||
@ -532,7 +534,7 @@ class Debug {
|
||||
explicit Debug(Isolate* isolate);
|
||||
~Debug();
|
||||
|
||||
static bool CompileDebuggerScript(int index);
|
||||
static bool CompileDebuggerScript(Isolate* isolate, int index);
|
||||
void ClearOneShot();
|
||||
void ActivateStepIn(StackFrame* frame);
|
||||
void ClearStepIn();
|
||||
@ -955,7 +957,7 @@ class Debugger {
|
||||
// some reason could not be entered FailedToEnter will return true.
|
||||
class EnterDebugger BASE_EMBEDDED {
|
||||
public:
|
||||
EnterDebugger();
|
||||
explicit EnterDebugger(Isolate* isolate);
|
||||
~EnterDebugger();
|
||||
|
||||
// Check whether the debugger could be entered.
|
||||
@ -982,7 +984,8 @@ class EnterDebugger BASE_EMBEDDED {
|
||||
// Stack allocated class for disabling break.
|
||||
class DisableBreak BASE_EMBEDDED {
|
||||
public:
|
||||
explicit DisableBreak(bool disable_break) : isolate_(Isolate::Current()) {
|
||||
explicit DisableBreak(Isolate* isolate, bool disable_break)
|
||||
: isolate_(isolate) {
|
||||
prev_disable_break_ = isolate_->debug()->disable_break();
|
||||
isolate_->debug()->set_disable_break(disable_break);
|
||||
}
|
||||
|
||||
@ -71,7 +71,7 @@ class V8NameConverter: public disasm::NameConverter {
|
||||
|
||||
|
||||
const char* V8NameConverter::NameOfAddress(byte* pc) const {
|
||||
const char* name = Isolate::Current()->builtins()->Lookup(pc);
|
||||
const char* name = code_->GetIsolate()->builtins()->Lookup(pc);
|
||||
if (name != NULL) {
|
||||
OS::SNPrintF(v8_buffer_, "%s (%p)", name, pc);
|
||||
return v8_buffer_.start();
|
||||
|
||||
@ -492,7 +492,6 @@ static void TraceTopFrame(Isolate* isolate) {
|
||||
}
|
||||
StackFrame* raw_frame = it.frame();
|
||||
if (raw_frame->is_internal()) {
|
||||
Isolate* isolate = Isolate::Current();
|
||||
Code* apply_builtin = isolate->builtins()->builtin(
|
||||
Builtins::kFunctionApply);
|
||||
if (raw_frame->unchecked_code() == apply_builtin) {
|
||||
|
||||
@ -156,8 +156,9 @@ Handle<Object> Execution::Call(Handle<Object> callable,
|
||||
bool convert_receiver) {
|
||||
*pending_exception = false;
|
||||
|
||||
Isolate* isolate = Isolate::Current();
|
||||
if (!callable->IsJSFunction()) {
|
||||
callable = TryGetFunctionDelegate(callable, pending_exception);
|
||||
callable = TryGetFunctionDelegate(isolate, callable, pending_exception);
|
||||
if (*pending_exception) return callable;
|
||||
}
|
||||
Handle<JSFunction> func = Handle<JSFunction>::cast(callable);
|
||||
@ -174,7 +175,7 @@ Handle<Object> Execution::Call(Handle<Object> callable,
|
||||
receiver = Handle<Object>(global, func->GetIsolate());
|
||||
}
|
||||
} else {
|
||||
receiver = ToObject(receiver, pending_exception);
|
||||
receiver = ToObject(isolate, receiver, pending_exception);
|
||||
}
|
||||
if (*pending_exception) return callable;
|
||||
}
|
||||
@ -234,9 +235,9 @@ Handle<Object> Execution::TryCall(Handle<JSFunction> func,
|
||||
}
|
||||
|
||||
|
||||
Handle<Object> Execution::GetFunctionDelegate(Handle<Object> object) {
|
||||
Handle<Object> Execution::GetFunctionDelegate(Isolate* isolate,
|
||||
Handle<Object> object) {
|
||||
ASSERT(!object->IsJSFunction());
|
||||
Isolate* isolate = Isolate::Current();
|
||||
Factory* factory = isolate->factory();
|
||||
|
||||
// If you return a function from here, it will be called when an
|
||||
@ -261,10 +262,10 @@ Handle<Object> Execution::GetFunctionDelegate(Handle<Object> object) {
|
||||
}
|
||||
|
||||
|
||||
Handle<Object> Execution::TryGetFunctionDelegate(Handle<Object> object,
|
||||
Handle<Object> Execution::TryGetFunctionDelegate(Isolate* isolate,
|
||||
Handle<Object> object,
|
||||
bool* has_pending_exception) {
|
||||
ASSERT(!object->IsJSFunction());
|
||||
Isolate* isolate = Isolate::Current();
|
||||
|
||||
// If object is a function proxy, get its handler. Iterate if necessary.
|
||||
Object* fun = *object;
|
||||
@ -292,9 +293,9 @@ Handle<Object> Execution::TryGetFunctionDelegate(Handle<Object> object,
|
||||
}
|
||||
|
||||
|
||||
Handle<Object> Execution::GetConstructorDelegate(Handle<Object> object) {
|
||||
Handle<Object> Execution::GetConstructorDelegate(Isolate* isolate,
|
||||
Handle<Object> object) {
|
||||
ASSERT(!object->IsJSFunction());
|
||||
Isolate* isolate = Isolate::Current();
|
||||
|
||||
// If you return a function from here, it will be called when an
|
||||
// attempt is made to call the given object as a constructor.
|
||||
@ -319,10 +320,10 @@ Handle<Object> Execution::GetConstructorDelegate(Handle<Object> object) {
|
||||
|
||||
|
||||
Handle<Object> Execution::TryGetConstructorDelegate(
|
||||
Isolate* isolate,
|
||||
Handle<Object> object,
|
||||
bool* has_pending_exception) {
|
||||
ASSERT(!object->IsJSFunction());
|
||||
Isolate* isolate = Isolate::Current();
|
||||
|
||||
// If you return a function from here, it will be called when an
|
||||
// attempt is made to call the given object as a constructor.
|
||||
@ -596,7 +597,6 @@ void StackGuard::InitThread(const ExecutionAccess& lock) {
|
||||
|
||||
#define RETURN_NATIVE_CALL(name, args, has_pending_exception) \
|
||||
do { \
|
||||
Isolate* isolate = Isolate::Current(); \
|
||||
Handle<Object> argv[] = args; \
|
||||
ASSERT(has_pending_exception != NULL); \
|
||||
return Call(isolate->name##_fun(), \
|
||||
@ -606,44 +606,50 @@ void StackGuard::InitThread(const ExecutionAccess& lock) {
|
||||
} while (false)
|
||||
|
||||
|
||||
Handle<Object> Execution::ToNumber(Handle<Object> obj, bool* exc) {
|
||||
Handle<Object> Execution::ToNumber(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc) {
|
||||
RETURN_NATIVE_CALL(to_number, { obj }, exc);
|
||||
}
|
||||
|
||||
|
||||
Handle<Object> Execution::ToString(Handle<Object> obj, bool* exc) {
|
||||
Handle<Object> Execution::ToString(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc) {
|
||||
RETURN_NATIVE_CALL(to_string, { obj }, exc);
|
||||
}
|
||||
|
||||
|
||||
Handle<Object> Execution::ToDetailString(Handle<Object> obj, bool* exc) {
|
||||
Handle<Object> Execution::ToDetailString(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc) {
|
||||
RETURN_NATIVE_CALL(to_detail_string, { obj }, exc);
|
||||
}
|
||||
|
||||
|
||||
Handle<Object> Execution::ToObject(Handle<Object> obj, bool* exc) {
|
||||
Handle<Object> Execution::ToObject(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc) {
|
||||
if (obj->IsSpecObject()) return obj;
|
||||
RETURN_NATIVE_CALL(to_object, { obj }, exc);
|
||||
}
|
||||
|
||||
|
||||
Handle<Object> Execution::ToInteger(Handle<Object> obj, bool* exc) {
|
||||
Handle<Object> Execution::ToInteger(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc) {
|
||||
RETURN_NATIVE_CALL(to_integer, { obj }, exc);
|
||||
}
|
||||
|
||||
|
||||
Handle<Object> Execution::ToUint32(Handle<Object> obj, bool* exc) {
|
||||
Handle<Object> Execution::ToUint32(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc) {
|
||||
RETURN_NATIVE_CALL(to_uint32, { obj }, exc);
|
||||
}
|
||||
|
||||
|
||||
Handle<Object> Execution::ToInt32(Handle<Object> obj, bool* exc) {
|
||||
Handle<Object> Execution::ToInt32(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc) {
|
||||
RETURN_NATIVE_CALL(to_int32, { obj }, exc);
|
||||
}
|
||||
|
||||
|
||||
Handle<Object> Execution::NewDate(double time, bool* exc) {
|
||||
Isolate* isolate = Isolate::Current();
|
||||
Handle<Object> Execution::NewDate(Isolate* isolate, double time, bool* exc) {
|
||||
Handle<Object> time_obj = isolate->factory()->NewNumber(time);
|
||||
RETURN_NATIVE_CALL(create_date, { time_obj }, exc);
|
||||
}
|
||||
@ -749,10 +755,10 @@ Handle<JSObject> Execution::InstantiateObject(Handle<ObjectTemplateInfo> data,
|
||||
}
|
||||
|
||||
|
||||
void Execution::ConfigureInstance(Handle<Object> instance,
|
||||
void Execution::ConfigureInstance(Isolate* isolate,
|
||||
Handle<Object> instance,
|
||||
Handle<Object> instance_template,
|
||||
bool* exc) {
|
||||
Isolate* isolate = Isolate::Current();
|
||||
Handle<Object> args[] = { instance, instance_template };
|
||||
Execution::Call(isolate->configure_instance_fun(),
|
||||
isolate->js_builtins_object(),
|
||||
@ -782,9 +788,7 @@ Handle<String> Execution::GetStackTraceLine(Handle<Object> recv,
|
||||
}
|
||||
|
||||
|
||||
static Object* RuntimePreempt() {
|
||||
Isolate* isolate = Isolate::Current();
|
||||
|
||||
static Object* RuntimePreempt(Isolate* isolate) {
|
||||
// Clear the preempt request flag.
|
||||
isolate->stack_guard()->Continue(PREEMPT);
|
||||
|
||||
@ -813,9 +817,7 @@ static Object* RuntimePreempt() {
|
||||
|
||||
|
||||
#ifdef ENABLE_DEBUGGER_SUPPORT
|
||||
Object* Execution::DebugBreakHelper() {
|
||||
Isolate* isolate = Isolate::Current();
|
||||
|
||||
Object* Execution::DebugBreakHelper(Isolate* isolate) {
|
||||
// Just continue if breaks are disabled.
|
||||
if (isolate->debug()->disable_break()) {
|
||||
return isolate->heap()->undefined_value();
|
||||
@ -861,15 +863,15 @@ Object* Execution::DebugBreakHelper() {
|
||||
// Clear the debug break request flag.
|
||||
isolate->stack_guard()->Continue(DEBUGBREAK);
|
||||
|
||||
ProcessDebugMessages(debug_command_only);
|
||||
ProcessDebugMessages(isolate, debug_command_only);
|
||||
|
||||
// Return to continue execution.
|
||||
return isolate->heap()->undefined_value();
|
||||
}
|
||||
|
||||
|
||||
void Execution::ProcessDebugMessages(bool debug_command_only) {
|
||||
Isolate* isolate = Isolate::Current();
|
||||
void Execution::ProcessDebugMessages(Isolate* isolate,
|
||||
bool debug_command_only) {
|
||||
// Clear the debug command request flag.
|
||||
isolate->stack_guard()->Continue(DEBUGCOMMAND);
|
||||
|
||||
@ -880,7 +882,7 @@ void Execution::ProcessDebugMessages(bool debug_command_only) {
|
||||
|
||||
HandleScope scope(isolate);
|
||||
// Enter the debugger. Just continue if we fail to enter the debugger.
|
||||
EnterDebugger debugger;
|
||||
EnterDebugger debugger(isolate);
|
||||
if (debugger.FailedToEnter()) {
|
||||
return;
|
||||
}
|
||||
@ -911,10 +913,10 @@ MaybeObject* Execution::HandleStackGuardInterrupt(Isolate* isolate) {
|
||||
isolate->runtime_profiler()->OptimizeNow();
|
||||
#ifdef ENABLE_DEBUGGER_SUPPORT
|
||||
if (stack_guard->IsDebugBreak() || stack_guard->IsDebugCommand()) {
|
||||
DebugBreakHelper();
|
||||
DebugBreakHelper(isolate);
|
||||
}
|
||||
#endif
|
||||
if (stack_guard->IsPreempted()) RuntimePreempt();
|
||||
if (stack_guard->IsPreempted()) RuntimePreempt(isolate);
|
||||
if (stack_guard->IsTerminateExecution()) {
|
||||
stack_guard->Continue(TERMINATE);
|
||||
return isolate->TerminateExecution();
|
||||
|
||||
@ -92,28 +92,36 @@ class Execution : public AllStatic {
|
||||
bool* caught_exception);
|
||||
|
||||
// ECMA-262 9.3
|
||||
static Handle<Object> ToNumber(Handle<Object> obj, bool* exc);
|
||||
static Handle<Object> ToNumber(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc);
|
||||
|
||||
// ECMA-262 9.4
|
||||
static Handle<Object> ToInteger(Handle<Object> obj, bool* exc);
|
||||
static Handle<Object> ToInteger(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc);
|
||||
|
||||
// ECMA-262 9.5
|
||||
static Handle<Object> ToInt32(Handle<Object> obj, bool* exc);
|
||||
static Handle<Object> ToInt32(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc);
|
||||
|
||||
// ECMA-262 9.6
|
||||
static Handle<Object> ToUint32(Handle<Object> obj, bool* exc);
|
||||
static Handle<Object> ToUint32(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc);
|
||||
|
||||
// ECMA-262 9.8
|
||||
static Handle<Object> ToString(Handle<Object> obj, bool* exc);
|
||||
static Handle<Object> ToString(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc);
|
||||
|
||||
// ECMA-262 9.8
|
||||
static Handle<Object> ToDetailString(Handle<Object> obj, bool* exc);
|
||||
static Handle<Object> ToDetailString(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc);
|
||||
|
||||
// ECMA-262 9.9
|
||||
static Handle<Object> ToObject(Handle<Object> obj, bool* exc);
|
||||
static Handle<Object> ToObject(
|
||||
Isolate* isolate, Handle<Object> obj, bool* exc);
|
||||
|
||||
// Create a new date object from 'time'.
|
||||
static Handle<Object> NewDate(double time, bool* exc);
|
||||
static Handle<Object> NewDate(
|
||||
Isolate* isolate, double time, bool* exc);
|
||||
|
||||
// Create a new regular expression object from 'pattern' and 'flags'.
|
||||
static Handle<JSRegExp> NewJSRegExp(Handle<String> pattern,
|
||||
@ -128,7 +136,8 @@ class Execution : public AllStatic {
|
||||
Handle<FunctionTemplateInfo> data, bool* exc);
|
||||
static Handle<JSObject> InstantiateObject(Handle<ObjectTemplateInfo> data,
|
||||
bool* exc);
|
||||
static void ConfigureInstance(Handle<Object> instance,
|
||||
static void ConfigureInstance(Isolate* isolate,
|
||||
Handle<Object> instance,
|
||||
Handle<Object> data,
|
||||
bool* exc);
|
||||
static Handle<String> GetStackTraceLine(Handle<Object> recv,
|
||||
@ -136,8 +145,8 @@ class Execution : public AllStatic {
|
||||
Handle<Object> pos,
|
||||
Handle<Object> is_global);
|
||||
#ifdef ENABLE_DEBUGGER_SUPPORT
|
||||
static Object* DebugBreakHelper();
|
||||
static void ProcessDebugMessages(bool debug_command_only);
|
||||
static Object* DebugBreakHelper(Isolate* isolate);
|
||||
static void ProcessDebugMessages(Isolate* isolate, bool debug_command_only);
|
||||
#endif
|
||||
|
||||
// If the stack guard is triggered, but it is not an actual
|
||||
@ -147,14 +156,18 @@ class Execution : public AllStatic {
|
||||
|
||||
// Get a function delegate (or undefined) for the given non-function
|
||||
// object. Used for support calling objects as functions.
|
||||
static Handle<Object> GetFunctionDelegate(Handle<Object> object);
|
||||
static Handle<Object> TryGetFunctionDelegate(Handle<Object> object,
|
||||
static Handle<Object> GetFunctionDelegate(Isolate* isolate,
|
||||
Handle<Object> object);
|
||||
static Handle<Object> TryGetFunctionDelegate(Isolate* isolate,
|
||||
Handle<Object> object,
|
||||
bool* has_pending_exception);
|
||||
|
||||
// Get a function delegate (or undefined) for the given non-function
|
||||
// object. Used for support calling objects as constructors.
|
||||
static Handle<Object> GetConstructorDelegate(Handle<Object> object);
|
||||
static Handle<Object> TryGetConstructorDelegate(Handle<Object> object,
|
||||
static Handle<Object> GetConstructorDelegate(Isolate* isolate,
|
||||
Handle<Object> object);
|
||||
static Handle<Object> TryGetConstructorDelegate(Isolate* isolate,
|
||||
Handle<Object> object,
|
||||
bool* has_pending_exception);
|
||||
};
|
||||
|
||||
|
||||
@ -1586,7 +1586,8 @@ void Factory::ConfigureInstance(Handle<FunctionTemplateInfo> desc,
|
||||
// instance template.
|
||||
Handle<Object> instance_template(desc->instance_template(), isolate());
|
||||
if (!instance_template->IsUndefined()) {
|
||||
Execution::ConfigureInstance(instance,
|
||||
Execution::ConfigureInstance(isolate(),
|
||||
instance,
|
||||
instance_template,
|
||||
pending_exception);
|
||||
} else {
|
||||
|
||||
@ -500,7 +500,7 @@ static void LookupForRead(Handle<Object> object,
|
||||
|
||||
|
||||
Handle<Object> CallICBase::TryCallAsFunction(Handle<Object> object) {
|
||||
Handle<Object> delegate = Execution::GetFunctionDelegate(object);
|
||||
Handle<Object> delegate = Execution::GetFunctionDelegate(isolate(), object);
|
||||
|
||||
if (delegate->IsJSFunction() && !object->IsJSFunctionProxy()) {
|
||||
// Patch the receiver and use the delegate as the function to
|
||||
|
||||
@ -1369,7 +1369,8 @@ void Isolate::DoThrow(Object* exception, MessageLocation* location) {
|
||||
// exception object to be set later must not be turned into a string.
|
||||
if (exception_arg->IsJSObject() && !IsErrorObject(exception_arg)) {
|
||||
bool failed = false;
|
||||
exception_arg = Execution::ToDetailString(exception_arg, &failed);
|
||||
exception_arg =
|
||||
Execution::ToDetailString(this, exception_arg, &failed);
|
||||
if (failed) {
|
||||
exception_arg = factory()->InternalizeOneByteString(
|
||||
STATIC_ASCII_VECTOR("exception"));
|
||||
|
||||
@ -495,11 +495,13 @@ BasicJsonStringifier::Result BasicJsonStringifier::SerializeJSValue(
|
||||
bool has_exception = false;
|
||||
String* class_name = object->class_name();
|
||||
if (class_name == isolate_->heap()->String_string()) {
|
||||
Handle<Object> value = Execution::ToString(object, &has_exception);
|
||||
Handle<Object> value =
|
||||
Execution::ToString(isolate_, object, &has_exception);
|
||||
if (has_exception) return EXCEPTION;
|
||||
SerializeString(Handle<String>::cast(value));
|
||||
} else if (class_name == isolate_->heap()->Number_string()) {
|
||||
Handle<Object> value = Execution::ToNumber(object, &has_exception);
|
||||
Handle<Object> value =
|
||||
Execution::ToNumber(isolate_, object, &has_exception);
|
||||
if (has_exception) return EXCEPTION;
|
||||
if (value->IsSmi()) return SerializeSmi(Smi::cast(*value));
|
||||
SerializeHeapNumber(Handle<HeapNumber>::cast(value));
|
||||
|
||||
@ -12127,7 +12127,8 @@ Handle<Object> JSObject::SetElement(Handle<JSObject> object,
|
||||
if (object->HasExternalArrayElements()) {
|
||||
if (!value->IsNumber() && !value->IsUndefined()) {
|
||||
bool has_exception;
|
||||
Handle<Object> number = Execution::ToNumber(value, &has_exception);
|
||||
Handle<Object> number =
|
||||
Execution::ToNumber(object->GetIsolate(), value, &has_exception);
|
||||
if (has_exception) return Handle<Object>();
|
||||
value = number;
|
||||
}
|
||||
|
||||
@ -2621,8 +2621,8 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_IsClassicModeFunction) {
|
||||
if (!callable->IsJSFunction()) {
|
||||
HandleScope scope(isolate);
|
||||
bool threw = false;
|
||||
Handle<Object> delegate =
|
||||
Execution::TryGetFunctionDelegate(Handle<JSReceiver>(callable), &threw);
|
||||
Handle<Object> delegate = Execution::TryGetFunctionDelegate(
|
||||
isolate, Handle<JSReceiver>(callable), &threw);
|
||||
if (threw) return Failure::Exception();
|
||||
callable = JSFunction::cast(*delegate);
|
||||
}
|
||||
@ -2640,8 +2640,8 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_GetDefaultReceiver) {
|
||||
if (!callable->IsJSFunction()) {
|
||||
HandleScope scope(isolate);
|
||||
bool threw = false;
|
||||
Handle<Object> delegate =
|
||||
Execution::TryGetFunctionDelegate(Handle<JSReceiver>(callable), &threw);
|
||||
Handle<Object> delegate = Execution::TryGetFunctionDelegate(
|
||||
isolate, Handle<JSReceiver>(callable), &threw);
|
||||
if (threw) return Failure::Exception();
|
||||
callable = JSFunction::cast(*delegate);
|
||||
}
|
||||
@ -4799,7 +4799,7 @@ MaybeObject* Runtime::HasObjectProperty(Isolate* isolate,
|
||||
} else {
|
||||
bool has_pending_exception = false;
|
||||
Handle<Object> converted =
|
||||
Execution::ToString(key, &has_pending_exception);
|
||||
Execution::ToString(isolate, key, &has_pending_exception);
|
||||
if (has_pending_exception) return Failure::Exception();
|
||||
name = Handle<Name>::cast(converted);
|
||||
}
|
||||
@ -4841,7 +4841,7 @@ MaybeObject* Runtime::GetObjectProperty(Isolate* isolate,
|
||||
} else {
|
||||
bool has_pending_exception = false;
|
||||
Handle<Object> converted =
|
||||
Execution::ToString(key, &has_pending_exception);
|
||||
Execution::ToString(isolate, key, &has_pending_exception);
|
||||
if (has_pending_exception) return Failure::Exception();
|
||||
name = Handle<Name>::cast(converted);
|
||||
}
|
||||
@ -5139,7 +5139,7 @@ MaybeObject* Runtime::SetObjectProperty(Isolate* isolate,
|
||||
if (object->IsJSProxy()) {
|
||||
bool has_pending_exception = false;
|
||||
Handle<Object> name = key->IsSymbol()
|
||||
? key : Execution::ToString(key, &has_pending_exception);
|
||||
? key : Execution::ToString(isolate, key, &has_pending_exception);
|
||||
if (has_pending_exception) return Failure::Exception();
|
||||
return JSProxy::cast(*object)->SetProperty(
|
||||
Name::cast(*name), *value, attr, strict_mode);
|
||||
@ -5168,7 +5168,8 @@ MaybeObject* Runtime::SetObjectProperty(Isolate* isolate,
|
||||
if (js_object->HasExternalArrayElements()) {
|
||||
if (!value->IsNumber() && !value->IsUndefined()) {
|
||||
bool has_exception;
|
||||
Handle<Object> number = Execution::ToNumber(value, &has_exception);
|
||||
Handle<Object> number =
|
||||
Execution::ToNumber(isolate, value, &has_exception);
|
||||
if (has_exception) return Failure::Exception();
|
||||
value = number;
|
||||
}
|
||||
@ -5187,7 +5188,8 @@ MaybeObject* Runtime::SetObjectProperty(Isolate* isolate,
|
||||
if (js_object->HasExternalArrayElements()) {
|
||||
if (!value->IsNumber() && !value->IsUndefined()) {
|
||||
bool has_exception;
|
||||
Handle<Object> number = Execution::ToNumber(value, &has_exception);
|
||||
Handle<Object> number =
|
||||
Execution::ToNumber(isolate, value, &has_exception);
|
||||
if (has_exception) return Failure::Exception();
|
||||
value = number;
|
||||
}
|
||||
@ -5204,7 +5206,8 @@ MaybeObject* Runtime::SetObjectProperty(Isolate* isolate,
|
||||
|
||||
// Call-back into JavaScript to convert the key to a string.
|
||||
bool has_pending_exception = false;
|
||||
Handle<Object> converted = Execution::ToString(key, &has_pending_exception);
|
||||
Handle<Object> converted =
|
||||
Execution::ToString(isolate, key, &has_pending_exception);
|
||||
if (has_pending_exception) return Failure::Exception();
|
||||
Handle<String> name = Handle<String>::cast(converted);
|
||||
|
||||
@ -5255,7 +5258,8 @@ MaybeObject* Runtime::ForceSetObjectProperty(Isolate* isolate,
|
||||
|
||||
// Call-back into JavaScript to convert the key to a string.
|
||||
bool has_pending_exception = false;
|
||||
Handle<Object> converted = Execution::ToString(key, &has_pending_exception);
|
||||
Handle<Object> converted =
|
||||
Execution::ToString(isolate, key, &has_pending_exception);
|
||||
if (has_pending_exception) return Failure::Exception();
|
||||
Handle<String> name = Handle<String>::cast(converted);
|
||||
|
||||
@ -5298,7 +5302,8 @@ MaybeObject* Runtime::DeleteObjectProperty(Isolate* isolate,
|
||||
} else {
|
||||
// Call-back into JavaScript to convert the key to a string.
|
||||
bool has_pending_exception = false;
|
||||
Handle<Object> converted = Execution::ToString(key, &has_pending_exception);
|
||||
Handle<Object> converted = Execution::ToString(
|
||||
isolate, key, &has_pending_exception);
|
||||
if (has_pending_exception) return Failure::Exception();
|
||||
name = Handle<String>::cast(converted);
|
||||
}
|
||||
@ -5890,7 +5895,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_GetArgumentsProperty) {
|
||||
HandleScope scope(isolate);
|
||||
bool exception = false;
|
||||
Handle<Object> converted =
|
||||
Execution::ToString(args.at<Object>(0), &exception);
|
||||
Execution::ToString(isolate, args.at<Object>(0), &exception);
|
||||
if (exception) return Failure::Exception();
|
||||
Handle<String> key = Handle<String>::cast(converted);
|
||||
|
||||
@ -8151,7 +8156,8 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_NewObjectFromBound) {
|
||||
|
||||
if (!bound_function->IsJSFunction()) {
|
||||
bool exception_thrown;
|
||||
bound_function = Execution::TryGetConstructorDelegate(bound_function,
|
||||
bound_function = Execution::TryGetConstructorDelegate(isolate,
|
||||
bound_function,
|
||||
&exception_thrown);
|
||||
if (exception_thrown) return Failure::Exception();
|
||||
}
|
||||
@ -8781,7 +8787,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_GetFunctionDelegate) {
|
||||
HandleScope scope(isolate);
|
||||
ASSERT(args.length() == 1);
|
||||
RUNTIME_ASSERT(!args[0]->IsJSFunction());
|
||||
return *Execution::GetFunctionDelegate(args.at<Object>(0));
|
||||
return *Execution::GetFunctionDelegate(isolate, args.at<Object>(0));
|
||||
}
|
||||
|
||||
|
||||
@ -8789,7 +8795,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_GetConstructorDelegate) {
|
||||
HandleScope scope(isolate);
|
||||
ASSERT(args.length() == 1);
|
||||
RUNTIME_ASSERT(!args[0]->IsJSFunction());
|
||||
return *Execution::GetConstructorDelegate(args.at<Object>(0));
|
||||
return *Execution::GetConstructorDelegate(isolate, args.at<Object>(0));
|
||||
}
|
||||
|
||||
|
||||
@ -10576,7 +10582,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_LookupAccessor) {
|
||||
RUNTIME_FUNCTION(MaybeObject*, Runtime_DebugBreak) {
|
||||
SealHandleScope shs(isolate);
|
||||
ASSERT(args.length() == 0);
|
||||
return Execution::DebugBreakHelper();
|
||||
return Execution::DebugBreakHelper(isolate);
|
||||
}
|
||||
|
||||
|
||||
@ -12687,7 +12693,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DebugEvaluate) {
|
||||
Handle<Object> context_extension(args[5], isolate);
|
||||
|
||||
// Handle the processing of break.
|
||||
DisableBreak disable_break_save(disable_break);
|
||||
DisableBreak disable_break_save(isolate, disable_break);
|
||||
|
||||
// Get the frame where the debugging is performed.
|
||||
StackFrame::Id id = UnwrapFrameId(wrapped_id);
|
||||
@ -12754,7 +12760,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_DebugEvaluateGlobal) {
|
||||
Handle<Object> context_extension(args[3], isolate);
|
||||
|
||||
// Handle the processing of break.
|
||||
DisableBreak disable_break_save(disable_break);
|
||||
DisableBreak disable_break_save(isolate, disable_break);
|
||||
|
||||
// Enter the top context from before the debugger was invoked.
|
||||
SaveContext save(isolate);
|
||||
@ -13422,7 +13428,7 @@ RUNTIME_FUNCTION(MaybeObject*, Runtime_ExecuteInDebugContext) {
|
||||
result = Execution::Call(function, isolate->global_object(), 0, NULL,
|
||||
&pending_exception);
|
||||
} else {
|
||||
EnterDebugger enter_debugger;
|
||||
EnterDebugger enter_debugger(isolate);
|
||||
result = Execution::Call(function, isolate->global_object(), 0, NULL,
|
||||
&pending_exception);
|
||||
}
|
||||
|
||||
@ -4197,7 +4197,8 @@ TEST(DisableBreak) {
|
||||
|
||||
{
|
||||
v8::Debug::DebugBreak();
|
||||
v8::internal::DisableBreak disable_break(true);
|
||||
i::Isolate* isolate = reinterpret_cast<i::Isolate*>(env->GetIsolate());
|
||||
v8::internal::DisableBreak disable_break(isolate, true);
|
||||
f->Call(env->Global(), 0, NULL);
|
||||
CHECK_EQ(1, break_point_hit_count);
|
||||
}
|
||||
|
||||
@ -82,16 +82,18 @@ TEST(HeapMaps) {
|
||||
static void CheckOddball(Isolate* isolate, Object* obj, const char* string) {
|
||||
CHECK(obj->IsOddball());
|
||||
bool exc;
|
||||
Handle<Object> handle(obj, isolate);
|
||||
Object* print_string =
|
||||
*Execution::ToString(Handle<Object>(obj, isolate), &exc);
|
||||
*Execution::ToString(isolate, handle, &exc);
|
||||
CHECK(String::cast(print_string)->IsUtf8EqualTo(CStrVector(string)));
|
||||
}
|
||||
|
||||
|
||||
static void CheckSmi(Isolate* isolate, int value, const char* string) {
|
||||
bool exc;
|
||||
Handle<Object> handle(Smi::FromInt(value), isolate);
|
||||
Object* print_string =
|
||||
*Execution::ToString(Handle<Object>(Smi::FromInt(value), isolate), &exc);
|
||||
*Execution::ToString(isolate, handle, &exc);
|
||||
CHECK(String::cast(print_string)->IsUtf8EqualTo(CStrVector(string)));
|
||||
}
|
||||
|
||||
@ -100,8 +102,9 @@ static void CheckNumber(Isolate* isolate, double value, const char* string) {
|
||||
Object* obj = HEAP->NumberFromDouble(value)->ToObjectChecked();
|
||||
CHECK(obj->IsNumber());
|
||||
bool exc;
|
||||
Handle<Object> handle(obj, isolate);
|
||||
Object* print_string =
|
||||
*Execution::ToString(Handle<Object>(obj, isolate), &exc);
|
||||
*Execution::ToString(isolate, handle, &exc);
|
||||
CHECK(String::cast(print_string)->IsUtf8EqualTo(CStrVector(string)));
|
||||
}
|
||||
|
||||
|
||||
Loading…
Reference in New Issue
Block a user