ExecArgs() {
exec_args_[0] = NULL;
}
- bool Init(Isolate* isolate,
Handle<Value> arg0, Handle<Array> command_args) {
+ bool Init(Isolate* isolate,
Local<Value> arg0, Local<Array> command_args) {
String::Utf8Value prog(arg0);
if (*prog == NULL) {
const char* message =
"os.system(): String conversion of program name failed";
- isolate->ThrowException(String::NewFromUtf8(isolate, message));
+ isolate->ThrowException(
+ String::NewFromUtf8(isolate, message, NewStringType::kNormal)
+ .ToLocalChecked());
return false;
}
int len = prog.length() + 3;
exec_args_[0] = c_arg;
int i = 1;
for (unsigned j = 0; j < command_args->Length(); i++, j++) {
- Handle<Value> arg(command_args->Get(Integer::New(isolate, j)));
+ Local<Value> arg(
+ command_args->Get(isolate->GetCurrentContext(),
+ Integer::New(isolate, j)).ToLocalChecked());
String::Utf8Value utf8_arg(arg);
if (*utf8_arg == NULL) {
exec_args_[i] = NULL; // Consistent state for destructor.
const char* message =
"os.system(): String conversion of argument failed.";
- isolate->ThrowException(String::NewFromUtf8(isolate, message));
+ isolate->ThrowException(
+ String::NewFromUtf8(isolate, message, NewStringType::kNormal)
+ .ToLocalChecked());
return false;
}
int len = utf8_arg.length() + 1;
int* total_timeout) {
if (args.Length() > 3) {
if (args[3]->IsNumber()) {
- *total_timeout = args[3]->Int32Value();
+ *total_timeout = args[3]
+ ->Int32Value(args.GetIsolate()->GetCurrentContext())
+ .FromJust();
} else {
- args.GetIsolate()->ThrowException(String::NewFromUtf8(
- args.GetIsolate(), "system: Argument 4 must be a number"));
+ args.GetIsolate()->ThrowException(
+ String::NewFromUtf8(args.GetIsolate(),
+ "system: Argument 4 must be a number",
+ NewStringType::kNormal).ToLocalChecked());
return false;
}
}
if (args.Length() > 2) {
if (args[2]->IsNumber()) {
- *read_timeout = args[2]->Int32Value();
+ *read_timeout = args[2]
+ ->Int32Value(args.GetIsolate()->GetCurrentContext())
+ .FromJust();
} else {
- args.GetIsolate()->ThrowException(String::NewFromUtf8(
- args.GetIsolate(), "system: Argument 3 must be a number"));
+ args.GetIsolate()->ThrowException(
+ String::NewFromUtf8(args.GetIsolate(),
+ "system: Argument 3 must be a number",
+ NewStringType::kNormal).ToLocalChecked());
return false;
}
}
bytes_read = read(exec_error_fds[kReadFD], &err, sizeof(err));
} while (bytes_read == -1 && errno == EINTR);
if (bytes_read != 0) {
- isolate->ThrowException(String::NewFromUtf8(isolate, strerror(err)));
+ isolate->ThrowException(
+ String::NewFromUtf8(isolate, strerror(err), NewStringType::kNormal)
+ .ToLocalChecked());
return false;
}
return true;
// Accumulates the output from the child in a string handle. Returns true if it
// succeeded or false if an exception was thrown.
-static Handle<Value> GetStdout(Isolate* isolate,
- int child_fd,
- const struct timeval& start_time,
- int read_timeout,
- int total_timeout) {
- Handle<String> accumulator = String::Empty(isolate);
+static Local<Value> GetStdout(Isolate* isolate, int child_fd,
+ const struct timeval& start_time,
+ int read_timeout, int total_timeout) {
+ Local<String> accumulator = String::Empty(isolate);
int fullness = 0;
static const int kStdoutReadBufferSize = 4096;
if (fcntl(child_fd, F_SETFL, O_NONBLOCK) != 0) {
return isolate->ThrowException(
- String::NewFromUtf8(isolate, strerror(errno)));
+ String::NewFromUtf8(isolate, strerror(errno), NewStringType::kNormal)
+ .ToLocalChecked());
}
int bytes_read;
start_time) ||
(TimeIsOut(start_time, total_timeout))) {
return isolate->ThrowException(
- String::NewFromUtf8(isolate, "Timed out waiting for output"));
+ String::NewFromUtf8(isolate, "Timed out waiting for output",
+ NewStringType::kNormal).ToLocalChecked());
}
continue;
} else if (errno == EINTR) {
int length = bytes_read == 0 ?
bytes_read + fullness :
LengthWithoutIncompleteUtf8(buffer, bytes_read + fullness);
- Handle<String> addition =
- String::NewFromUtf8(isolate, buffer, String::kNormalString, length);
+ Local<String> addition =
+ String::NewFromUtf8(isolate, buffer, NewStringType::kNormal, length)
+ .ToLocalChecked();
accumulator = String::Concat(accumulator, addition);
fullness = bytes_read + fullness - length;
memcpy(buffer, buffer + length, fullness);
if (useconds < 1000000) useconds <<= 1;
if ((read_timeout != -1 && useconds / 1000 > read_timeout) ||
(TimeIsOut(start_time, total_timeout))) {
- isolate->ThrowException(String::NewFromUtf8(
- isolate, "Timed out waiting for process to terminate"));
+ isolate->ThrowException(
+ String::NewFromUtf8(isolate,
+ "Timed out waiting for process to terminate",
+ NewStringType::kNormal).ToLocalChecked());
kill(pid, SIGINT);
return false;
}
sizeof(message),
"Child killed by signal %d",
child_info.si_status);
- isolate->ThrowException(String::NewFromUtf8(isolate, message));
+ isolate->ThrowException(
+ String::NewFromUtf8(isolate, message, NewStringType::kNormal)
+ .ToLocalChecked());
return false;
}
if (child_info.si_code == CLD_EXITED && child_info.si_status != 0) {
sizeof(message),
"Child exited with status %d",
child_info.si_status);
- isolate->ThrowException(String::NewFromUtf8(isolate, message));
+ isolate->ThrowException(
+ String::NewFromUtf8(isolate, message, NewStringType::kNormal)
+ .ToLocalChecked());
return false;
}
sizeof(message),
"Child killed by signal %d",
WTERMSIG(child_status));
- isolate->ThrowException(String::NewFromUtf8(isolate, message));
+ isolate->ThrowException(
+ String::NewFromUtf8(isolate, message, NewStringType::kNormal)
+ .ToLocalChecked());
return false;
}
if (WEXITSTATUS(child_status) != 0) {
sizeof(message),
"Child exited with status %d",
exit_status);
- isolate->ThrowException(String::NewFromUtf8(isolate, message));
+ isolate->ThrowException(
+ String::NewFromUtf8(isolate, message, NewStringType::kNormal)
+ .ToLocalChecked());
return false;
}
int read_timeout = -1;
int total_timeout = -1;
if (!GetTimeouts(args, &read_timeout, &total_timeout)) return;
-
Handle<Array> command_args;
+
Local<Array> command_args;
if (args.Length() > 1) {
if (!args[1]->IsArray()) {
- args.GetIsolate()->ThrowException(String::NewFromUtf8(
- args.GetIsolate(), "system: Argument 2 must be an array"));
+ args.GetIsolate()->ThrowException(
+ String::NewFromUtf8(args.GetIsolate(),
+ "system: Argument 2 must be an array",
+ NewStringType::kNormal).ToLocalChecked());
return;
}
- command_args =
Handle<Array>::Cast(args[1]);
+ command_args =
Local<Array>::Cast(args[1]);
} else {
command_args = Array::New(args.GetIsolate(), 0);
}
if (command_args->Length() > ExecArgs::kMaxArgs) {
- args.GetIsolate()->ThrowException(String::NewFromUtf8(
- args.GetIsolate(), "Too many arguments to system()"));
+ args.GetIsolate()->ThrowException(
+ String::NewFromUtf8(args.GetIsolate(), "Too many arguments to system()",
+ NewStringType::kNormal).ToLocalChecked());
return;
}
if (args.Length() < 1) {
- args.GetIsolate()->ThrowException(String::NewFromUtf8(
- args.GetIsolate(), "Too few arguments to system()"));
+ args.GetIsolate()->ThrowException(
+ String::NewFromUtf8(args.GetIsolate(), "Too few arguments to system()",
+ NewStringType::kNormal).ToLocalChecked());
return;
}
if (pipe(exec_error_fds) != 0) {
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), "pipe syscall failed."));
+ String::NewFromUtf8(args.GetIsolate(), "pipe syscall failed.",
+ NewStringType::kNormal).ToLocalChecked());
return;
}
if (pipe(stdout_fds) != 0) {
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), "pipe syscall failed."));
+ String::NewFromUtf8(args.GetIsolate(), "pipe syscall failed.",
+ NewStringType::kNormal).ToLocalChecked());
return;
}
if (!ChildLaunchedOK(args.GetIsolate(), exec_error_fds)) return;
- Handle<Value> accumulator = GetStdout(args.GetIsolate(),
- stdout_fds[kReadFD],
- start_time,
- read_timeout,
- total_timeout);
+ Local<Value> accumulator = GetStdout(args.GetIsolate(), stdout_fds[kReadFD],
+ start_time, read_timeout, total_timeout);
if (accumulator->IsUndefined()) {
kill(pid, SIGINT); // On timeout, kill the subprocess.
args.GetReturnValue().Set(accumulator);
if (args.Length() != 1) {
const char* message = "chdir() takes one argument";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message, NewStringType::kNormal)
+ .ToLocalChecked());
return;
}
String::Utf8Value directory(args[0]);
if (*directory == NULL) {
const char* message = "os.chdir(): String conversion of argument failed.";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message, NewStringType::kNormal)
+ .ToLocalChecked());
return;
}
if (chdir(*directory) != 0) {
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), strerror(errno)));
+ String::NewFromUtf8(args.GetIsolate(), strerror(errno),
+ NewStringType::kNormal).ToLocalChecked());
return;
}
}
if (args.Length() != 1) {
const char* message = "umask() takes one argument";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message, NewStringType::kNormal)
+ .ToLocalChecked());
return;
}
if (args[0]->IsNumber()) {
// PNaCL has no support for umask.
int previous = 0;
#else
- int previous = umask(args[0]->Int32Value());
+ int previous = umask(
+ args[0]->Int32Value(args.GetIsolate()->GetCurrentContext()).FromJust());
#endif
args.GetReturnValue().Set(previous);
return;
} else {
const char* message = "umask() argument must be numeric";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message, NewStringType::kNormal)
+ .ToLocalChecked());
return;
}
}
struct stat stat_buf;
int stat_result = stat(directory, &stat_buf);
if (stat_result != 0) {
- isolate->ThrowException(String::NewFromUtf8(isolate, strerror(errno)));
+ isolate->ThrowException(
+ String::NewFromUtf8(isolate, strerror(errno), NewStringType::kNormal)
+ .ToLocalChecked());
return false;
}
if ((stat_buf.st_mode & S_IFDIR) != 0) return true;
- isolate->ThrowException(String::NewFromUtf8(isolate, strerror(EEXIST)));
+ isolate->ThrowException(
+ String::NewFromUtf8(isolate, strerror(EEXIST), NewStringType::kNormal)
+ .ToLocalChecked());
return false;
}
} else if (errno == ENOENT) { // Intermediate path element is missing.
char* last_slash = strrchr(directory, '/');
if (last_slash == NULL) {
- isolate->ThrowException(String::NewFromUtf8(isolate, strerror(errno)));
+ isolate->ThrowException(
+ String::NewFromUtf8(isolate, strerror(errno), NewStringType::kNormal)
+ .ToLocalChecked());
return false;
}
*last_slash = 0;
if (errno == EEXIST) {
return CheckItsADirectory(isolate, directory);
}
- isolate->ThrowException(String::NewFromUtf8(isolate, strerror(errno)));
+ isolate->ThrowException(
+ String::NewFromUtf8(isolate, strerror(errno), NewStringType::kNormal)
+ .ToLocalChecked());
return false;
} else {
- isolate->ThrowException(String::NewFromUtf8(isolate, strerror(errno)));
+ isolate->ThrowException(
+ String::NewFromUtf8(isolate, strerror(errno), NewStringType::kNormal)
+ .ToLocalChecked());
return false;
}
}
mode_t mask = 0777;
if (args.Length() == 2) {
if (args[1]->IsNumber()) {
- mask = args[1]->Int32Value();
+ mask = args[1]
+ ->Int32Value(args.GetIsolate()->GetCurrentContext())
+ .FromJust();
} else {
const char* message = "mkdirp() second argument must be numeric";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message,
+ NewStringType::kNormal).ToLocalChecked());
return;
}
} else if (args.Length() != 1) {
const char* message = "mkdirp() takes one or two arguments";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message, NewStringType::kNormal)
+ .ToLocalChecked());
return;
}
String::Utf8Value directory(args[0]);
if (*directory == NULL) {
const char* message = "os.mkdirp(): String conversion of argument failed.";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message, NewStringType::kNormal)
+ .ToLocalChecked());
return;
}
mkdirp(args.GetIsolate(), *directory, mask);
if (args.Length() != 1) {
const char* message = "rmdir() takes one or two arguments";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message, NewStringType::kNormal)
+ .ToLocalChecked());
return;
}
String::Utf8Value directory(args[0]);
if (*directory == NULL) {
const char* message = "os.rmdir(): String conversion of argument failed.";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message, NewStringType::kNormal)
+ .ToLocalChecked());
return;
}
rmdir(*directory);
if (args.Length() != 2) {
const char* message = "setenv() takes two arguments";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message, NewStringType::kNormal)
+ .ToLocalChecked());
return;
}
String::Utf8Value var(args[0]);
const char* message =
"os.setenv(): String conversion of variable name failed.";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message, NewStringType::kNormal)
+ .ToLocalChecked());
return;
}
if (*value == NULL) {
const char* message =
"os.setenv(): String conversion of variable contents failed.";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message, NewStringType::kNormal)
+ .ToLocalChecked());
return;
}
setenv(*var, *value, 1);
if (args.Length() != 1) {
const char* message = "unsetenv() takes one argument";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message, NewStringType::kNormal)
+ .ToLocalChecked());
return;
}
String::Utf8Value var(args[0]);
const char* message =
"os.setenv(): String conversion of variable name failed.";
args.GetIsolate()->ThrowException(
- String::NewFromUtf8(args.GetIsolate(), message));
+ String::NewFromUtf8(args.GetIsolate(), message, NewStringType::kNormal)
+ .ToLocalChecked());
return;
}
unsetenv(*var);
}
-void Shell::AddOSMethods(Isolate* isolate, Handle<ObjectTemplate> os_templ) {
- os_templ->Set(String::NewFromUtf8(isolate, "system"),
+void Shell::AddOSMethods(Isolate* isolate, Local<ObjectTemplate> os_templ) {
+ os_templ->Set(String::NewFromUtf8(isolate, "system", NewStringType::kNormal)
+ .ToLocalChecked(),
FunctionTemplate::New(isolate, System));
- os_templ->Set(String::NewFromUtf8(isolate, "chdir"),
+ os_templ->Set(String::NewFromUtf8(isolate, "chdir", NewStringType::kNormal)
+ .ToLocalChecked(),
FunctionTemplate::New(isolate, ChangeDirectory));
- os_templ->Set(String::NewFromUtf8(isolate, "setenv"),
+ os_templ->Set(String::NewFromUtf8(isolate, "setenv", NewStringType::kNormal)
+ .ToLocalChecked(),
FunctionTemplate::New(isolate, SetEnvironment));
- os_templ->Set(String::NewFromUtf8(isolate, "unsetenv"),
+ os_templ->Set(String::NewFromUtf8(isolate, "unsetenv", NewStringType::kNormal)
+ .ToLocalChecked(),
FunctionTemplate::New(isolate, UnsetEnvironment));
- os_templ->Set(String::NewFromUtf8(isolate, "umask"),
+ os_templ->Set(String::NewFromUtf8(isolate, "umask", NewStringType::kNormal)
+ .ToLocalChecked(),
FunctionTemplate::New(isolate, SetUMask));
- os_templ->Set(String::NewFromUtf8(isolate, "mkdirp"),
+ os_templ->Set(String::NewFromUtf8(isolate, "mkdirp", NewStringType::kNormal)
+ .ToLocalChecked(),
FunctionTemplate::New(isolate, MakeDirectory));
- os_templ->Set(String::NewFromUtf8(isolate, "rmdir"),
+ os_templ->Set(String::NewFromUtf8(isolate, "rmdir", NewStringType::kNormal)
+ .ToLocalChecked(),
FunctionTemplate::New(isolate, RemoveDirectory));
}
#ifndef V8_SHARED
-bool FindInObjectList(Handle<Object> object, const Shell::ObjectList& list) {
+bool FindInObjectList(Local<Object> object, const Shell::ObjectList& list) {
for (int i = 0; i < list.length(); ++i) {
if (list[i]->StrictEquals(object)) {
return true;
} // namespace
-static Handle<Value> Throw(Isolate* isolate, const char* message) {
- return isolate->ThrowException(String::NewFromUtf8(isolate, message));
+static Local<Value> Throw(Isolate* isolate, const char* message) {
+ return isolate->ThrowException(
+ String::NewFromUtf8(isolate, message, NewStringType::kNormal)
+ .ToLocalChecked());
}
int realm_count_;
int realm_current_;
int realm_switch_;
- Persistent<Context>* realms_;
- Persistent<Value> realm_shared_;
+ Global<Context>* realms_;
+ Global<Value> realm_shared_;
int RealmIndexOrThrow(const v8::FunctionCallbackInfo<v8::Value>& args,
int arg_offset);
- int RealmFind(Handle<Context> context);
+ int RealmFind(Local<Context> context);
};
public:
explicit DumbLineEditor(Isolate* isolate)
: LineEditor(LineEditor::DUMB, "dumb"), isolate_(isolate) { }
- virtual Handle<String> Prompt(const char* prompt);
+ virtual Local<String> Prompt(const char* prompt);
+
private:
Isolate* isolate_;
};
-Handle<String> DumbLineEditor::Prompt(const char* prompt) {
+Local<String> DumbLineEditor::Prompt(const char* prompt) {
printf("%s", prompt);
#if defined(__native_client__)
// Native Client libc is used to being embedded in Chrome and
base::LazyMutex Shell::context_mutex_;
const base::TimeTicks Shell::kInitialTicks =
base::TimeTicks::HighResolutionNow();
-Persistent<Context> Shell::utility_context_;
+Global<Context> Shell::utility_context_;
base::LazyMutex Shell::workers_mutex_;
bool Shell::allow_new_workers_ = true;
i::List<Worker*> Shell::workers_;
i::List<SharedArrayBuffer::Contents> Shell::externalized_shared_contents_;
#endif // !V8_SHARED
-Persistent<Context> Shell::evaluation_context_;
+Global<Context> Shell::evaluation_context_;
ArrayBuffer::Allocator* Shell::array_buffer_allocator;
ShellOptions Shell::options;
const char* Shell::kPrompt = "d8> ";
Isolate::Scope isolate_scope(temp_isolate);
HandleScope handle_scope(temp_isolate);
Context::Scope context_scope(Context::New(temp_isolate));
- Local<String> source_copy = v8::String::NewFromTwoByte(
- temp_isolate, source_buffer, v8::String::kNormalString, source_length);
+ Local<String> source_copy =
+ v8::String::NewFromTwoByte(temp_isolate, source_buffer,
+ v8::NewStringType::kNormal,
+ source_length).ToLocalChecked();
Local<Value> name_copy;
if (name_buffer) {
- name_copy = v8::String::NewFromTwoByte(
- temp_isolate, name_buffer, v8::String::kNormalString, name_length);
+ name_copy = v8::String::NewFromTwoByte(temp_isolate, name_buffer,
+ v8::NewStringType::kNormal,
+ name_length).ToLocalChecked();
} else {
name_copy = v8::Undefined(temp_isolate);
}
ScriptCompiler::Source script_source(source_copy, ScriptOrigin(name_copy));
- ScriptCompiler::CompileUnbound(temp_isolate, &script_source,
- compile_options);
+ ScriptCompiler::CompileUnboundScript(temp_isolate, &script_source,
+ compile_options).ToLocalChecked();
if (script_source.GetCachedData()) {
int length = script_source.GetCachedData()->length;
uint8_t* cache = new uint8_t[length];
// Compile a string within the current v8 context.
-Local<Script> Shell::CompileString(
+MaybeLocal<Script> Shell::CompileString(
Isolate* isolate, Local<String> source, Local<Value> name,
ScriptCompiler::CompileOptions compile_options, SourceType source_type) {
+ Local<Context> context(isolate->GetCurrentContext());
ScriptOrigin origin(name);
if (compile_options == ScriptCompiler::kNoCompileOptions) {
ScriptCompiler::Source script_source(source, origin);
return source_type == SCRIPT
- ? ScriptCompiler::Compile(isolate, &script_source,
+ ? ScriptCompiler::Compile(context, &script_source,
compile_options)
- : ScriptCompiler::CompileModule(isolate, &script_source,
+ : ScriptCompiler::CompileModule(context, &script_source,
compile_options);
}
DCHECK(false); // A new compile option?
}
if (data == NULL) compile_options = ScriptCompiler::kNoCompileOptions;
- Local<Script> result =
+ MaybeLocal<Script> result =
source_type == SCRIPT
- ? ScriptCompiler::Compile(isolate, &cached_source, compile_options)
- : ScriptCompiler::CompileModule(isolate, &cached_source,
+ ? ScriptCompiler::Compile(context, &cached_source, compile_options)
+ : ScriptCompiler::CompileModule(context, &cached_source,
compile_options);
CHECK(data == NULL || !data->rejected);
return result;
// Executes a string within the current v8 context.
-bool Shell::ExecuteString(Isolate* isolate, Handle<String> source,
- Handle<Value> name, bool print_result,
+bool Shell::ExecuteString(Isolate* isolate, Local<String> source,
+ Local<Value> name, bool print_result,
bool report_exceptions, SourceType source_type) {
#ifndef V8_SHARED
bool FLAG_debugger = i::FLAG_debugger;
try_catch.SetVerbose(true);
}
- Handle<Value> result;
+ MaybeLocal<Value> maybe_result;
{
PerIsolateData* data = PerIsolateData::Get(isolate);
Local<Context> realm =
Local<Context>::New(isolate, data->realms_[data->realm_current_]);
Context::Scope context_scope(realm);
- Handle<Script> script = Shell::CompileString(
- isolate, source, name, options.compile_options, source_type);
- if (script.IsEmpty()) {
+ Local<Script> script;
+ if (!Shell::CompileString(isolate, source, name, options.compile_options,
+ source_type).ToLocal(&script)) {
// Print errors that happened during compilation.
if (report_exceptions && !FLAG_debugger)
ReportException(isolate, &try_catch);
return false;
}
- result = script->Run();
+ maybe_result = script->Run(realm);
EmptyMessageQueues(isolate);
data->realm_current_ = data->realm_switch_;
}
- if (result.IsEmpty()) {
+ Local<Value> result;
+ if (!maybe_result.ToLocal(&result)) {
DCHECK(try_catch.HasCaught());
// Print errors that happened during execution.
if (report_exceptions && !FLAG_debugger)
v8::Local<v8::Context> context =
v8::Local<v8::Context>::New(isolate, utility_context_);
v8::Context::Scope context_scope(context);
- Handle<Object> global = context->Global();
- Handle<Value> fun =
- global->Get(String::NewFromUtf8(isolate, "Stringify"));
- Handle<Value> argv[1] = {result};
- Handle<Value> s = Handle<Function>::Cast(fun)->Call(global, 1, argv);
- if (try_catch.HasCaught()) return true;
+ Local<Object> global = context->Global();
+ Local<Value> fun =
+ global->Get(context, String::NewFromUtf8(isolate, "Stringify",
+ v8::NewStringType::kNormal)
+ .ToLocalChecked()).ToLocalChecked();
+ Local<Value> argv[1] = {result};
+ Local<Value> s;
+ if (!Local<Function>::Cast(fun)
+ ->Call(context, global, 1, argv)
+ .ToLocal(&s)) {
+ return true;
+ }
+ DCHECK(!try_catch.HasCaught());
v8::String::Utf8Value str(s);
fwrite(*str, sizeof(**str), str.length(), stdout);
printf("\n");
data_->realm_count_ = 1;
data_->realm_current_ = 0;
data_->realm_switch_ = 0;
- data_->realms_ = new Persistent<Context>[1];
+ data_->realms_ = new Global<Context>[1];
data_->realms_[0].Reset(data_->isolate_,
data_->isolate_->GetEnteredContext());
}
}
-int PerIsolateData::RealmFind(Handle<Context> context) {
+int PerIsolateData::RealmFind(Local<Context> context) {
for (int i = 0; i < realm_count_; ++i) {
if (realms_[i] == context) return i;
}
Throw(args.GetIsolate(), "Invalid argument");
return -1;
}
- int index = args[arg_offset]->Int32Value();
- if (index < 0 ||
- index >= realm_count_ ||
- realms_[index].IsEmpty()) {
+ int index = args[arg_offset]
+ ->Int32Value(args.GetIsolate()->GetCurrentContext())
+ .FromMaybe(-1);
+ if (index < 0 || index >= realm_count_ || realms_[index].IsEmpty()) {
Throw(args.GetIsolate(), "Invalid realm index");
return -1;
}
Throw(args.GetIsolate(), "Invalid argument");
return;
}
- int index = data->RealmFind(args[0]->ToObject(isolate)->CreationContext());
+ int index = data->RealmFind(args[0]
+ ->ToObject(isolate->GetCurrentContext())
+ .ToLocalChecked()
+ ->CreationContext());
if (index == -1) return;
args.GetReturnValue().Set(index);
}
Isolate* isolate = args.GetIsolate();
TryCatch try_catch(isolate);
PerIsolateData* data = PerIsolateData::Get(isolate);
- Persistent<Context>* old_realms = data->realms_;
+ Global<Context>* old_realms = data->realms_;
int index = data->realm_count_;
- data->realms_ = new Persistent<Context>[++data->realm_count_];
+ data->realms_ = new Global<Context>[++data->realm_count_];
for (int i = 0; i < index; ++i) {
data->realms_[i].Reset(isolate, old_realms[i]);
old_realms[i].Reset();
}
delete[] old_realms;
- Handle<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
+ Local<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
Local<Context> context = Context::New(isolate, NULL, global_template);
if (context.IsEmpty()) {
DCHECK(try_catch.HasCaught());
Throw(args.GetIsolate(), "Invalid argument");
return;
}
- ScriptCompiler::Source script_source(args[1]->ToString(isolate));
- Handle<UnboundScript> script = ScriptCompiler::CompileUnbound(
- isolate, &script_source);
- if (script.IsEmpty()) return;
+ ScriptCompiler::Source script_source(
+ args[1]->ToString(isolate->GetCurrentContext()).ToLocalChecked());
+ Local<UnboundScript> script;
+ if (!ScriptCompiler::CompileUnboundScript(isolate, &script_source)
+ .ToLocal(&script)) {
+ return;
+ }
Local<Context> realm = Local<Context>::New(isolate, data->realms_[index]);
realm->Enter();
- Handle<Value> result = script->BindToCurrentContext()->Run();
+ Local<Value> result;
+ if (!script->BindToCurrentContext()->Run(realm).ToLocal(&result)) {
+ realm->Exit();
+ return;
+ }
realm->Exit();
args.GetReturnValue().Set(result);
}
// Explicitly catch potential exceptions in toString().
v8::TryCatch try_catch(args.GetIsolate());
- Handle<String> str_obj = args[i]->ToString(args.GetIsolate());
- if (try_catch.HasCaught()) {
+ Local<String> str_obj;
+ if (!args[i]
+ ->ToString(args.GetIsolate()->GetCurrentContext())
+ .ToLocal(&str_obj)) {
try_catch.ReThrow();
return;
}
Throw(args.GetIsolate(), "Error loading file");
return;
}
- Handle<String> source = ReadFile(args.GetIsolate(), *file);
+ Local<String> source = ReadFile(args.GetIsolate(), *file);
if (source.IsEmpty()) {
Throw(args.GetIsolate(), "Error loading file");
return;
}
-Handle<String> Shell::ReadFromStdin(Isolate* isolate) {
+Local<String> Shell::ReadFromStdin(Isolate* isolate) {
static const int kBufferSize = 256;
char buffer[kBufferSize];
- Handle<String> accumulator = String::NewFromUtf8(isolate, "");
+ Local<String> accumulator =
+ String::NewFromUtf8(isolate, "", NewStringType::kNormal).ToLocalChecked();
int length;
while (true) {
// Continue reading if the line ends with an escape '\\' or the line has
// If fgets gets an error, just give up.
char* input = NULL;
input = fgets(buffer, kBufferSize, stdin);
- if (input == NULL) return Handle<String>();
+ if (input == NULL) return Local<String>();
length = static_cast<int>(strlen(buffer));
if (length == 0) {
return accumulator;
} else if (buffer[length-1] != '\n') {
accumulator = String::Concat(
accumulator,
- String::NewFromUtf8(isolate, buffer, String::kNormalString, length));
+ String::NewFromUtf8(isolate, buffer, NewStringType::kNormal, length)
+ .ToLocalChecked());
} else if (length > 1 && buffer[length-2] == '\\') {
buffer[length-2] = '\n';
accumulator = String::Concat(
- accumulator, String::NewFromUtf8(isolate, buffer,
- String::kNormalString, length - 1));
+ accumulator,
+ String::NewFromUtf8(isolate, buffer, NewStringType::kNormal,
+ length - 1).ToLocalChecked());
} else {
return String::Concat(
- accumulator, String::NewFromUtf8(isolate, buffer,
- String::kNormalString, length - 1));
+ accumulator,
+ String::NewFromUtf8(isolate, buffer, NewStringType::kNormal,
+ length - 1).ToLocalChecked());
}
}
}
Throw(args.GetIsolate(), "Error loading file");
return;
}
- Handle<String> source = ReadFile(args.GetIsolate(), *file);
+ Local<String> source = ReadFile(args.GetIsolate(), *file);
if (source.IsEmpty()) {
Throw(args.GetIsolate(), "Error loading file");
return;
}
- if (!ExecuteString(args.GetIsolate(),
- source,
- String::NewFromUtf8(args.GetIsolate(), *file),
- false,
- true)) {
+ if (!ExecuteString(
+ args.GetIsolate(), source,
+ String::NewFromUtf8(args.GetIsolate(), *file,
+ NewStringType::kNormal).ToLocalChecked(),
+ false, true)) {
Throw(args.GetIsolate(), "Error executing file");
return;
}
Worker* worker =
static_cast<Worker*>(Local<External>::Cast(this_value)->Value());
- Handle<Value> message = args[0];
+ Local<Value> message = args[0];
ObjectList to_transfer;
if (args.Length() >= 2) {
if (!args[1]->IsArray()) {
return;
}
-
Handle<Array> transfer = Handle<Array>::Cast(args[1]);
+
Local<Array> transfer = Local<Array>::Cast(args[1]);
uint32_t length = transfer->Length();
for (uint32_t i = 0; i < length; ++i) {
- Handle<Value> element;
+ Local<Value> element;
if (transfer->Get(context, i).ToLocal(&element)) {
if (!element->IsArrayBuffer() && !element->IsSharedArrayBuffer()) {
Throw(isolate,
break;
}
- to_transfer.Add(Handle<Object>::Cast(element));
+ to_transfer.Add(Local<Object>::Cast(element));
}
}
}
void Shell::QuitOnce(v8::FunctionCallbackInfo<v8::Value>* args) {
- int exit_code = (*args)[0]->Int32Value();
+ int exit_code = (*args)[0]
+ ->Int32Value(args->GetIsolate()->GetCurrentContext())
+ .FromMaybe(0);
#ifndef V8_SHARED
CleanupWorkers();
#endif // !V8_SHARED
void Shell::Version(const v8::FunctionCallbackInfo<v8::Value>& args) {
args.GetReturnValue().Set(
- String::NewFromUtf8(args.GetIsolate(), V8::GetVersion()));
+ String::NewFromUtf8(args.GetIsolate(), V8::GetVersion(),
+ NewStringType::kNormal).ToLocalChecked());
}
void Shell::ReportException(Isolate* isolate, v8::TryCatch* try_catch) {
HandleScope handle_scope(isolate);
#ifndef V8_SHARED
- Handle<Context> utility_context;
+ Local<Context> utility_context;
bool enter_context = !isolate->InContext();
if (enter_context) {
utility_context = Local<Context>::New(isolate, utility_context_);
#endif // !V8_SHARED
v8::String::Utf8Value exception(try_catch->Exception());
const char* exception_string = ToCString(exception);
- Handle<Message> message = try_catch->Message();
+ Local<Message> message = try_catch->Message();
if (message.IsEmpty()) {
// V8 didn't provide any extra information about this error; just
// print the exception.
// Print (filename):(line number): (message).
v8::String::Utf8Value filename(message->GetScriptOrigin().ResourceName());
const char* filename_string = ToCString(filename);
- int linenum = message->GetLineNumber();
+ int linenum =
+ message->GetLineNumber(isolate->GetCurrentContext()).FromJust();
printf("%s:%i: %s\n", filename_string, linenum, exception_string);
// Print line of source code.
- v8::String::Utf8Value sourceline(message->GetSourceLine());
+ v8::String::Utf8Value sourceline(
+ message->GetSourceLine(isolate->GetCurrentContext()).ToLocalChecked());
const char* sourceline_string = ToCString(sourceline);
printf("%s\n", sourceline_string);
// Print wavy underline (GetUnderline is deprecated).
- int start = message->GetStartColumn();
+ int start =
+ message->GetStartColumn(isolate->GetCurrentContext()).FromJust();
for (int i = 0; i < start; i++) {
printf(" ");
}
- int end = message->GetEndColumn();
+ int end = message->GetEndColumn(isolate->GetCurrentContext()).FromJust();
for (int i = start; i < end; i++) {
printf("^");
}
printf("\n");
- v8::String::Utf8Value stack_trace(try_catch->StackTrace());
- if (stack_trace.length() > 0) {
- const char* stack_trace_string = ToCString(stack_trace);
- printf("%s\n", stack_trace_string);
+ Local<Value> stack_trace_string;
+ if (try_catch->StackTrace(isolate->GetCurrentContext())
+ .ToLocal(&stack_trace_string)) {
+ v8::String::Utf8Value stack_trace(
+ Local<String>::Cast(stack_trace_string));
+ printf("%s\n", ToCString(stack_trace));
}
}
printf("\n");
#ifndef V8_SHARED
-Handle<Array> Shell::GetCompletions(Isolate* isolate,
- Handle<String> text,
- Handle<String> full) {
+Local<Array> Shell::GetCompletions(Isolate* isolate, Local<String> text,
+ Local<String> full) {
EscapableHandleScope handle_scope(isolate);
v8::Local<v8::Context> utility_context =
v8::Local<v8::Context>::New(isolate, utility_context_);
v8::Context::Scope context_scope(utility_context);
- Handle<Object> global = utility_context->Global();
- Local<Value> fun =
- global->Get(String::NewFromUtf8(isolate, "GetCompletions"));
+ Local<Object> global = utility_context->Global();
+ Local<Value> fun = global->Get(utility_context,
+ String::NewFromUtf8(isolate, "GetCompletions",
+ NewStringType::kNormal)
+ .ToLocalChecked()).ToLocalChecked();
static const int kArgc = 3;
v8::Local<v8::Context> evaluation_context =
v8::Local<v8::Context>::New(isolate, evaluation_context_);
- Handle<Value> argv[kArgc] = { evaluation_context->Global(), text, full };
- Local<Value> val = Local<Function>::Cast(fun)->Call(global, kArgc, argv);
+ Local<Value> argv[kArgc] = {evaluation_context->Global(), text, full};
+ Local<Value> val = Local<Function>::Cast(fun)
+ ->Call(utility_context, global, kArgc, argv)
+ .ToLocalChecked();
return handle_scope.Escape(Local<Array>::Cast(val));
}
Local<Object> Shell::DebugMessageDetails(Isolate* isolate,
- Handle<String> message) {
+ Local<String> message) {
EscapableHandleScope handle_scope(isolate);
v8::Local<v8::Context> context =
v8::Local<v8::Context>::New(isolate, utility_context_);
v8::Context::Scope context_scope(context);
- Handle<Object> global = context->Global();
- Handle<Value> fun =
- global->Get(String::NewFromUtf8(isolate, "DebugMessageDetails"));
+ Local<Object> global = context->Global();
+ Local<Value> fun =
+ global->Get(context, String::NewFromUtf8(isolate, "DebugMessageDetails",
+ NewStringType::kNormal)
+ .ToLocalChecked()).ToLocalChecked();
static const int kArgc = 1;
- Handle<Value> argv[kArgc] = { message };
- Handle<Value> val = Handle<Function>::Cast(fun)->Call(global, kArgc, argv);
- return handle_scope.Escape(Local<Object>(Handle<Object>::Cast(val)));
+ Local<Value> argv[kArgc] = {message};
+ Local<Value> val = Local<Function>::Cast(fun)
+ ->Call(context, global, kArgc, argv)
+ .ToLocalChecked();
+ return handle_scope.Escape(Local<Object>(Local<Object>::Cast(val)));
}
Local<Value> Shell::DebugCommandToJSONRequest(Isolate* isolate,
- Handle<String> command) {
+ Local<String> command) {
EscapableHandleScope handle_scope(isolate);
v8::Local<v8::Context> context =
v8::Local<v8::Context>::New(isolate, utility_context_);
v8::Context::Scope context_scope(context);
- Handle<Object> global = context->Global();
- Handle<Value> fun =
- global->Get(String::NewFromUtf8(isolate, "DebugCommandToJSONRequest"));
+ Local<Object> global = context->Global();
+ Local<Value> fun =
+ global->Get(context,
+ String::NewFromUtf8(isolate, "DebugCommandToJSONRequest",
+ NewStringType::kNormal).ToLocalChecked())
+ .ToLocalChecked();
static const int kArgc = 1;
- Handle<Value> argv[kArgc] = { command };
- Handle<Value> val = Handle<Function>::Cast(fun)->Call(global, kArgc, argv);
+ Local<Value> argv[kArgc] = {command};
+ Local<Value> val = Local<Function>::Cast(fun)
+ ->Call(context, global, kArgc, argv)
+ .ToLocalChecked();
return handle_scope.Escape(Local<Value>(val));
}
i::Handle<i::Context> debug_context = debug->debug_context();
i::Handle<i::JSObject> js_debug
= i::Handle<i::JSObject>(debug_context->global_object());
- utility_context->Global()->Set(String::NewFromUtf8(isolate, "$debug"),
- Utils::ToLocal(js_debug));
+ utility_context->Global()
+ ->Set(utility_context,
+ String::NewFromUtf8(isolate, "$debug", NewStringType::kNormal)
+ .ToLocalChecked(),
+ Utils::ToLocal(js_debug))
+ .FromJust();
debug_context->set_security_token(
reinterpret_cast<i::Isolate*>(isolate)->heap()->undefined_value());
i::NativesCollection<i::D8>::GetScriptSource(source_index);
i::Vector<const char> shell_source_name =
i::NativesCollection<i::D8>::GetScriptName(source_index);
- Handle<String> source =
- String::NewFromUtf8(isolate, shell_source.start(), String::kNormalString,
- shell_source.length());
- Handle<String> name =
+ Local<String> source =
+ String::NewFromUtf8(isolate, shell_source.start(), NewStringType::kNormal,
+ shell_source.length()).ToLocalChecked();
+ Local<String> name =
String::NewFromUtf8(isolate, shell_source_name.start(),
- String::kNormalString, shell_source_name.length());
+ NewStringType::kNormal,
+ shell_source_name.length()).ToLocalChecked();
ScriptOrigin origin(name);
- Handle<Script> script = Script::Compile(source, &origin);
- script->Run();
+ Local<Script> script =
+ Script::Compile(utility_context, source, &origin).ToLocalChecked();
+ script->Run(utility_context).ToLocalChecked();
// Mark the d8 shell script as native to avoid it showing up as normal source
// in the debugger.
i::Handle<i::Object> compiled_script = Utils::OpenHandle(*script);
#endif // !V8_SHARED
-Handle<ObjectTemplate> Shell::CreateGlobalTemplate(Isolate* isolate) {
- Handle<ObjectTemplate> global_template = ObjectTemplate::New(isolate);
- global_template->Set(String::NewFromUtf8(isolate, "print"),
- FunctionTemplate::New(isolate, Print));
- global_template->Set(String::NewFromUtf8(isolate, "write"),
- FunctionTemplate::New(isolate, Write));
- global_template->Set(String::NewFromUtf8(isolate, "read"),
- FunctionTemplate::New(isolate, Read));
- global_template->Set(String::NewFromUtf8(isolate, "readbuffer"),
- FunctionTemplate::New(isolate, ReadBuffer));
- global_template->Set(String::NewFromUtf8(isolate, "readline"),
- FunctionTemplate::New(isolate, ReadLine));
- global_template->Set(String::NewFromUtf8(isolate, "load"),
- FunctionTemplate::New(isolate, Load));
+Local<ObjectTemplate> Shell::CreateGlobalTemplate(Isolate* isolate) {
+ Local<ObjectTemplate> global_template = ObjectTemplate::New(isolate);
+ global_template->Set(
+ String::NewFromUtf8(isolate, "print", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, Print));
+ global_template->Set(
+ String::NewFromUtf8(isolate, "write", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, Write));
+ global_template->Set(
+ String::NewFromUtf8(isolate, "read", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, Read));
+ global_template->Set(
+ String::NewFromUtf8(isolate, "readbuffer", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, ReadBuffer));
+ global_template->Set(
+ String::NewFromUtf8(isolate, "readline", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, ReadLine));
+ global_template->Set(
+ String::NewFromUtf8(isolate, "load", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, Load));
// Some Emscripten-generated code tries to call 'quit', which in turn would
// call C's exit(). This would lead to memory leaks, because there is no way
// we can terminate cleanly then, so we need a way to hide 'quit'.
if (!options.omit_quit) {
- global_template->Set(String::NewFromUtf8(isolate, "quit"),
- FunctionTemplate::New(isolate, Quit));
+ global_template->Set(
+ String::NewFromUtf8(isolate, "quit", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, Quit));
}
- global_template->Set(String::NewFromUtf8(isolate, "version"),
- FunctionTemplate::New(isolate, Version));
+ global_template->Set(
+ String::NewFromUtf8(isolate, "version", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, Version));
// Bind the Realm object.
- Handle<ObjectTemplate> realm_template = ObjectTemplate::New(isolate);
- realm_template->Set(String::NewFromUtf8(isolate, "current"),
- FunctionTemplate::New(isolate, RealmCurrent));
- realm_template->Set(String::NewFromUtf8(isolate, "owner"),
- FunctionTemplate::New(isolate, RealmOwner));
- realm_template->Set(String::NewFromUtf8(isolate, "global"),
- FunctionTemplate::New(isolate, RealmGlobal));
- realm_template->Set(String::NewFromUtf8(isolate, "create"),
- FunctionTemplate::New(isolate, RealmCreate));
- realm_template->Set(String::NewFromUtf8(isolate, "dispose"),
- FunctionTemplate::New(isolate, RealmDispose));
- realm_template->Set(String::NewFromUtf8(isolate, "switch"),
- FunctionTemplate::New(isolate, RealmSwitch));
- realm_template->Set(String::NewFromUtf8(isolate, "eval"),
- FunctionTemplate::New(isolate, RealmEval));
- realm_template->SetAccessor(String::NewFromUtf8(isolate, "shared"),
- RealmSharedGet, RealmSharedSet);
- global_template->Set(String::NewFromUtf8(isolate, "Realm"), realm_template);
+ Local<ObjectTemplate> realm_template = ObjectTemplate::New(isolate);
+ realm_template->Set(
+ String::NewFromUtf8(isolate, "current", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, RealmCurrent));
+ realm_template->Set(
+ String::NewFromUtf8(isolate, "owner", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, RealmOwner));
+ realm_template->Set(
+ String::NewFromUtf8(isolate, "global", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, RealmGlobal));
+ realm_template->Set(
+ String::NewFromUtf8(isolate, "create", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, RealmCreate));
+ realm_template->Set(
+ String::NewFromUtf8(isolate, "dispose", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, RealmDispose));
+ realm_template->Set(
+ String::NewFromUtf8(isolate, "switch", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, RealmSwitch));
+ realm_template->Set(
+ String::NewFromUtf8(isolate, "eval", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, RealmEval));
+ realm_template->SetAccessor(
+ String::NewFromUtf8(isolate, "shared", NewStringType::kNormal)
+ .ToLocalChecked(),
+ RealmSharedGet, RealmSharedSet);
+ global_template->Set(
+ String::NewFromUtf8(isolate, "Realm", NewStringType::kNormal)
+ .ToLocalChecked(),
+ realm_template);
#ifndef V8_SHARED
- Handle<ObjectTemplate> performance_template = ObjectTemplate::New(isolate);
- performance_template->Set(String::NewFromUtf8(isolate, "now"),
- FunctionTemplate::New(isolate, PerformanceNow));
- global_template->Set(String::NewFromUtf8(isolate, "performance"),
- performance_template);
-
- Handle<FunctionTemplate> worker_fun_template =
+ Local<ObjectTemplate> performance_template = ObjectTemplate::New(isolate);
+ performance_template->Set(
+ String::NewFromUtf8(isolate, "now", NewStringType::kNormal)
+ .ToLocalChecked(),
+ FunctionTemplate::New(isolate, PerformanceNow));
+ global_template->Set(
+ String::NewFromUtf8(isolate, "performance", NewStringType::kNormal)
+ .ToLocalChecked(),
+ performance_template);
+
+ Local<FunctionTemplate> worker_fun_template =
FunctionTemplate::New(isolate, WorkerNew);
worker_fun_template->PrototypeTemplate()->Set(
- String::NewFromUtf8(isolate, "terminate"),
+ String::NewFromUtf8(isolate, "terminate", NewStringType::kNormal)
+ .ToLocalChecked(),
FunctionTemplate::New(isolate, WorkerTerminate));
worker_fun_template->PrototypeTemplate()->Set(
- String::NewFromUtf8(isolate, "postMessage"),
+ String::NewFromUtf8(isolate, "postMessage", NewStringType::kNormal)
+ .ToLocalChecked(),
FunctionTemplate::New(isolate, WorkerPostMessage));
worker_fun_template->PrototypeTemplate()->Set(
- String::NewFromUtf8(isolate, "getMessage"),
+ String::NewFromUtf8(isolate, "getMessage", NewStringType::kNormal)
+ .ToLocalChecked(),
FunctionTemplate::New(isolate, WorkerGetMessage));
worker_fun_template->InstanceTemplate()->SetInternalFieldCount(1);
- global_template->Set(String::NewFromUtf8(isolate, "Worker"),
- worker_fun_template);
+ global_template->Set(
+ String::NewFromUtf8(isolate, "Worker", NewStringType::kNormal)
+ .ToLocalChecked(),
+ worker_fun_template);
#endif // !V8_SHARED
- Handle<ObjectTemplate> os_templ = ObjectTemplate::New(isolate);
+ Local<ObjectTemplate> os_templ = ObjectTemplate::New(isolate);
AddOSMethods(isolate, os_templ);
- global_template->Set(String::NewFromUtf8(isolate, "os"), os_templ);
+ global_template->Set(
+ String::NewFromUtf8(isolate, "os", NewStringType::kNormal)
+ .ToLocalChecked(),
+ os_templ);
return global_template;
}
if (options.test_shell) return;
#ifndef V8_SHARED
HandleScope scope(isolate);
- Handle<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
+ Local<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
utility_context_.Reset(isolate,
Context::New(isolate, NULL, global_template));
if (utility_context_.IsEmpty()) {
base::LockGuard<base::Mutex> lock_guard(context_mutex_.Pointer());
#endif // !V8_SHARED
// Initialize the global objects
- Handle<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
+ Local<ObjectTemplate> global_template = CreateGlobalTemplate(isolate);
EscapableHandleScope handle_scope(isolate);
Local<Context> context = Context::New(isolate, NULL, global_template);
DCHECK(!context.IsEmpty());
}
i::Handle<i::JSArray> arguments_jsarray =
factory->NewJSArrayWithElements(arguments_array);
- context->Global()->Set(String::NewFromUtf8(isolate, "arguments"),
- Utils::ToLocal(arguments_jsarray));
+ context->Global()
+ ->Set(context,
+ String::NewFromUtf8(isolate, "arguments", NewStringType::kNormal)
+ .ToLocalChecked(),
+ Utils::ToLocal(arguments_jsarray))
+ .FromJust();
#endif // !V8_SHARED
return handle_scope.Escape(context);
}
return;
}
data->byte_length = length;
- Handle<v8::ArrayBuffer> buffer =
- ArrayBuffer::New(isolate, data->data, length);
+ Local<v8::ArrayBuffer> buffer = ArrayBuffer::New(isolate, data->data, length);
data->handle.Reset(isolate, buffer);
data->handle.SetWeak(data, ReadBufferWeakCallback,
v8::WeakCallbackType::kParameter);
// Reads a file into a v8 string.
-Handle<String> Shell::ReadFile(Isolate* isolate, const char* name) {
+Local<String> Shell::ReadFile(Isolate* isolate, const char* name) {
int size = 0;
char* chars = ReadChars(isolate, name, &size);
- if (chars == NULL) return Handle<String>();
- Handle<String> result =
- String::NewFromUtf8(isolate, chars, String::kNormalString, size);
+ if (chars == NULL) return Local<String>();
+ Local<String> result =
+ String::NewFromUtf8(isolate, chars, NewStringType::kNormal, size)
+ .ToLocalChecked();
delete[] chars;
return result;
}
v8::Local<v8::Context>::New(isolate, evaluation_context_);
v8::Context::Scope context_scope(context);
PerIsolateData::RealmScope realm_scope(PerIsolateData::Get(isolate));
- Handle<String> name = String::NewFromUtf8(isolate, "(d8)");
+ Local<String> name =
+ String::NewFromUtf8(isolate, "(d8)", NewStringType::kNormal)
+ .ToLocalChecked();
LineEditor* console = LineEditor::Get();
printf("V8 version %s [console: %s]\n", V8::GetVersion(), console->name());
console->Open(isolate);
while (true) {
HandleScope inner_scope(isolate);
- Handle<String> input = console->Prompt(Shell::kPrompt);
+ Local<String> input = console->Prompt(Shell::kPrompt);
if (input.IsEmpty()) break;
ExecuteString(isolate, input, name, true, true);
}
if (strcmp(arg, "-e") == 0 && i + 1 < end_offset_) {
// Execute argument given to -e option directly.
HandleScope handle_scope(isolate);
- Handle<String> file_name = String::NewFromUtf8(isolate, "unnamed");
- Handle<String> source = String::NewFromUtf8(isolate, argv_[i + 1]);
+ Local<String> file_name =
+ String::NewFromUtf8(isolate, "unnamed", NewStringType::kNormal)
+ .ToLocalChecked();
+ Local<String> source =
+ String::NewFromUtf8(isolate, argv_[i + 1], NewStringType::kNormal)
+ .ToLocalChecked();
if (!Shell::ExecuteString(isolate, source, file_name, false, true)) {
exception_was_thrown = true;
break;
// Use all other arguments as names of files to load and run.
HandleScope handle_scope(isolate);
- Handle<String> file_name = String::NewFromUtf8(isolate, arg);
- Handle<String> source = ReadFile(isolate, arg);
+ Local<String> file_name =
+ String::NewFromUtf8(isolate, arg, NewStringType::kNormal)
+ .ToLocalChecked();
+ Local<String> source = ReadFile(isolate, arg);
if (source.IsEmpty()) {
printf("Error reading '%s'\n", arg);
Shell::Exit(1);
}
-Handle<String> SourceGroup::ReadFile(Isolate* isolate, const char* name) {
+Local<String> SourceGroup::ReadFile(Isolate* isolate, const char* name) {
int size;
char* chars = ReadChars(isolate, name, &size);
- if (chars == NULL) return Handle<String>();
- Handle<String> result =
- String::NewFromUtf8(isolate, chars, String::kNormalString, size);
+ if (chars == NULL) return Local<String>();
+ Local<String> result =
+ String::NewFromUtf8(isolate, chars, NewStringType::kNormal, size)
+ .ToLocalChecked();
delete[] chars;
return result;
}
Context::Scope cscope(context);
PerIsolateData::RealmScope realm_scope(PerIsolateData::Get(isolate));
- Handle<Object> global = context->Global();
- Handle<Value> this_value = External::New(isolate, this);
- Handle<FunctionTemplate> postmessage_fun_template =
+ Local<Object> global = context->Global();
+ Local<Value> this_value = External::New(isolate, this);
+ Local<FunctionTemplate> postmessage_fun_template =
FunctionTemplate::New(isolate, PostMessageOut, this_value);
- Handle<Function> postmessage_fun;
+ Local<Function> postmessage_fun;
if (postmessage_fun_template->GetFunction(context)
.ToLocal(&postmessage_fun)) {
- global->Set(String::NewFromUtf8(isolate, "postMessage"),
- postmessage_fun);
+ global->Set(context, String::NewFromUtf8(isolate, "postMessage",
+ NewStringType::kNormal)
+ .ToLocalChecked(),
+ postmessage_fun).FromJust();
}
// First run the script
- Handle<String> file_name = String::NewFromUtf8(isolate, "unnamed");
- Handle<String> source = String::NewFromUtf8(isolate, script_);
+ Local<String> file_name =
+ String::NewFromUtf8(isolate, "unnamed", NewStringType::kNormal)
+ .ToLocalChecked();
+ Local<String> source =
+ String::NewFromUtf8(isolate, script_, NewStringType::kNormal)
+ .ToLocalChecked();
if (Shell::ExecuteString(isolate, source, file_name, false, true)) {
// Get the message handler
- Handle<Value> onmessage =
- global->Get(String::NewFromUtf8(isolate, "onmessage"));
+ Local<Value> onmessage =
+ global->Get(context, String::NewFromUtf8(isolate, "onmessage",
+ NewStringType::kNormal)
+ .ToLocalChecked()).ToLocalChecked();
if (onmessage->IsFunction()) {
- Handle<Function> onmessage_fun = Handle<Function>::Cast(onmessage);
+ Local<Function> onmessage_fun = Local<Function>::Cast(onmessage);
// Now wait for messages
while (true) {
in_semaphore_.Wait();
Local<Value> data_value;
if (Shell::DeserializeValue(isolate, *data, &offset)
.ToLocal(&data_value)) {
- Handle<Value> argv[] = {data_value};
+ Local<Value> argv[] = {data_value};
(void)onmessage_fun->Call(context, global, 1, argv);
}
delete data;
return;
}
- Handle<Value> message = args[0];
+ Local<Value> message = args[0];
// TODO(binji): Allow transferring from worker to main thread?
Shell::ObjectList to_transfer;
if (Shell::SerializeValue(isolate, message, to_transfer, &seen_objects,
data)) {
DCHECK(args.Data()->IsExternal());
- Handle<External> this_value = Handle<External>::Cast(args.Data());
+ Local<External> this_value = Local<External>::Cast(args.Data());
Worker* worker = static_cast<Worker*>(this_value->Value());
worker->out_queue_.Enqueue(data);
worker->out_semaphore_.Signal();
#ifndef V8_SHARED
-bool Shell::SerializeValue(Isolate* isolate, Handle<Value> value,
+bool Shell::SerializeValue(Isolate* isolate, Local<Value> value,
const ObjectList& to_transfer,
ObjectList* seen_objects,
SerializationData* out_data) {
} else if (value->IsFalse()) {
out_data->WriteTag(kSerializationTagFalse);
} else if (value->IsNumber()) {
- Handle<Number> num = Handle<Number>::Cast(value);
+ Local<Number> num = Local<Number>::Cast(value);
double value = num->Value();
out_data->WriteTag(kSerializationTagNumber);
out_data->Write(value);
out_data->Write(str.length());
out_data->WriteMemory(*str, str.length());
} else if (value->IsArray()) {
-
Handle<Array> array = Handle<Array>::Cast(value);
+
Local<Array> array = Local<Array>::Cast(value);
if (FindInObjectList(array, *seen_objects)) {
Throw(isolate, "Duplicated arrays not supported");
return false;
}
}
} else if (value->IsArrayBuffer()) {
-
Handle<ArrayBuffer> array_buffer = Handle<ArrayBuffer>::Cast(value);
+
Local<ArrayBuffer> array_buffer = Local<ArrayBuffer>::Cast(value);
if (FindInObjectList(array_buffer, *seen_objects)) {
Throw(isolate, "Duplicated array buffers not supported");
return false;
static_cast<int>(contents.ByteLength()));
}
} else if (value->IsSharedArrayBuffer()) {
- Handle<SharedArrayBuffer> sab = Handle<SharedArrayBuffer>::Cast(value);
+ Local<SharedArrayBuffer> sab = Local<SharedArrayBuffer>::Cast(value);
if (FindInObjectList(sab, *seen_objects)) {
Throw(isolate, "Duplicated shared array buffers not supported");
return false;
}
out_data->WriteSharedArrayBufferContents(contents);
} else if (value->IsObject()) {
- Handle<Object> object = Handle<Object>::Cast(value);
+ Local<Object> object = Local<Object>::Cast(value);
if (FindInObjectList(object, *seen_objects)) {
Throw(isolate, "Duplicated objects not supported");
return false;
out_data->WriteTag(kSerializationTagObject);
out_data->Write(length);
for (uint32_t i = 0; i < length; ++i) {
- Handle<Value> name;
- Handle<Value> property_value;
+ Local<Value> name;
+ Local<Value> property_value;
if (property_names->Get(context, i).ToLocal(&name) &&
object->Get(context, name).ToLocal(&property_value)) {
if (!SerializeValue(isolate, name, to_transfer, seen_objects, out_data))
CHECK(length >= 0);
std::vector<char> buffer(length + 1); // + 1 so it is never empty.
data.ReadMemory(&buffer[0], length, offset);
- MaybeLocal<String> str = String::NewFromUtf8(
- isolate, &buffer[0], String::kNormalString, length);
+ MaybeLocal<String> str =
+ String::NewFromUtf8(isolate, &buffer[0], NewStringType::kNormal,
+ length).ToLocalChecked();
if (!str.IsEmpty()) result = str.ToLocalChecked();
break;
}
case kSerializationTagArray: {
uint32_t length = data.Read<uint32_t>(offset);
-
Handle<Array> array = Array::New(isolate, length);
+
Local<Array> array = Array::New(isolate, length);
for (uint32_t i = 0; i < length; ++i) {
Local<Value> element_value;
CHECK(DeserializeValue(isolate, data, offset).ToLocal(&element_value));
- array->Set(i, element_value);
+ array->Set(isolate->GetCurrentContext(), i, element_value).FromJust();
}
result = array;
break;
}
case kSerializationTagObject: {
int length = data.Read<int>(offset);
- Handle<Object> object = Object::New(isolate);
+ Local<Object> object = Object::New(isolate);
for (int i = 0; i < length; ++i) {
Local<Value> property_name;
CHECK(DeserializeValue(isolate, data, offset).ToLocal(&property_name));
Local<Value> property_value;
CHECK(DeserializeValue(isolate, data, offset).ToLocal(&property_value));
- object->Set(property_name, property_value);
+ object->Set(isolate->GetCurrentContext(), property_name, property_value)
+ .FromJust();
}
result = object;
break;
}
case kSerializationTagArrayBuffer: {
int byte_length = data.Read<int>(offset);
-
Handle<ArrayBuffer> array_buffer = ArrayBuffer::New(isolate, byte_length);
+
Local<ArrayBuffer> array_buffer = ArrayBuffer::New(isolate, byte_length);
ArrayBuffer::Contents contents = array_buffer->GetContents();
DCHECK(static_cast<size_t>(byte_length) == contents.ByteLength());
data.ReadMemory(contents.Data(), byte_length, offset);
projects / platform / upstream / v8.git / commitdiff