AuroraMiddleware/v8
1
0
Fork 0
Code Issues 2 Pull Requests Releases Wiki Activity

Reland of "Make d8 stop using to-be-deprecated APIs"

Browse Source 
Original issue's description:
> BUG=v8:4134
> LOG=n
> R=yangguo@chromium.org
>
> Review URL: https://codereview.chromium.org/1239053004

BUG=v8:4134
LOG=n
R=yangguo@chromium.org

Review URL: https://codereview.chromium.org/1235603004

Cr-Commit-Position: refs/heads/master@{#29742}
This commit is contained in:
jochen 2015-07-20 00:05:42 -07:00 committed by Commit bot
parent b8a4978110
commit d180390f7f
7 changed files with 555 additions and 340 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

77
src/d8-debug.cc
View File

@ -29,24 +29,30 @@ void HandleDebugEvent(const Debug::EventDetails& event_details) {
// Get the toJSONProtocol function on the event and get the JSON format.
Local<String> to_json_fun_name =
String::NewFromUtf8(isolate, "toJSONProtocol");
Handle<Object> event_data = event_details.GetEventData();
String::NewFromUtf8(isolate, "toJSONProtocol", NewStringType::kNormal)
.ToLocalChecked();
Local<Object> event_data = event_details.GetEventData();
Local<Function> to_json_fun =
Local<Function>::Cast(event_data->Get(to_json_fun_name));
Local<Value> event_json = to_json_fun->Call(event_data, 0, NULL);
if (try_catch.HasCaught()) {
Local<Function>::Cast(event_data->Get(isolate->GetCurrentContext(),
to_json_fun_name).ToLocalChecked());
Local<Value> event_json;
if (!to_json_fun->Call(isolate->GetCurrentContext(), event_data, 0, NULL)
.ToLocal(&event_json)) {
Shell::ReportException(isolate, &try_catch);
return;
}
// Print the event details.
Handle<Object> details =
Shell::DebugMessageDetails(isolate, Handle<String>::Cast(event_json));
Local<Object> details =
Shell::DebugMessageDetails(isolate, Local<String>::Cast(event_json));
if (try_catch.HasCaught()) {
Shell::ReportException(isolate, &try_catch);
return;
}
String::Utf8Value str(details->Get(String::NewFromUtf8(isolate, "text")));
String::Utf8Value str(
details->Get(isolate->GetCurrentContext(),
String::NewFromUtf8(isolate, "text", NewStringType::kNormal)
.ToLocalChecked()).ToLocalChecked());
if (str.length() == 0) {
// Empty string is used to signal not to process this event.
return;
@ -55,15 +61,18 @@ void HandleDebugEvent(const Debug::EventDetails& event_details) {
// Get the debug command processor.
Local<String> fun_name =
String::NewFromUtf8(isolate, "debugCommandProcessor");
Handle<Object> exec_state = event_details.GetExecutionState();
Local<Function> fun = Local<Function>::Cast(exec_state->Get(fun_name));
Local<Object> cmd_processor =
Local<Object>::Cast(fun->Call(exec_state, 0, NULL));
if (try_catch.HasCaught()) {
String::NewFromUtf8(isolate, "debugCommandProcessor",
NewStringType::kNormal).ToLocalChecked();
Local<Object> exec_state = event_details.GetExecutionState();
Local<Function> fun = Local<Function>::Cast(
exec_state->Get(isolate->GetCurrentContext(), fun_name).ToLocalChecked());
Local<Value> cmd_processor_value;
if (!fun->Call(isolate->GetCurrentContext(), exec_state, 0, NULL)
.ToLocal(&cmd_processor_value)) {
Shell::ReportException(isolate, &try_catch);
return;
}
Local<Object> cmd_processor = Local<Object>::Cast(cmd_processor_value);
static const int kBufferSize = 256;
bool running = false;
@ -79,8 +88,9 @@ void HandleDebugEvent(const Debug::EventDetails& event_details) {
TryCatch try_catch(isolate);
// Convert the debugger command to a JSON debugger request.
Handle<Value> request = Shell::DebugCommandToJSONRequest(
isolate, String::NewFromUtf8(isolate, command));
Local<Value> request = Shell::DebugCommandToJSONRequest(
isolate, String::NewFromUtf8(isolate, command, NewStringType::kNormal)
.ToLocalChecked());
if (try_catch.HasCaught()) {
Shell::ReportException(isolate, &try_catch);
continue;
@ -92,39 +102,50 @@ void HandleDebugEvent(const Debug::EventDetails& event_details) {
continue;
}
Handle<String> fun_name;
Handle<Function> fun;
Local<String> fun_name;
Local<Function> fun;
// All the functions used below take one argument.
static const int kArgc = 1;
Handle<Value> args[kArgc];
Local<Value> args[kArgc];
// Invoke the JavaScript to convert the debug command line to a JSON
// request, invoke the JSON request and convert the JSON respose to a text
// representation.
fun_name = String::NewFromUtf8(isolate, "processDebugRequest");
fun = Handle<Function>::Cast(cmd_processor->Get(fun_name));
fun_name = String::NewFromUtf8(isolate, "processDebugRequest",
NewStringType::kNormal).ToLocalChecked();
fun = Local<Function>::Cast(cmd_processor->Get(isolate->GetCurrentContext(),
fun_name).ToLocalChecked());
args[0] = request;
Handle<Value> response_val = fun->Call(cmd_processor, kArgc, args);
if (try_catch.HasCaught()) {
Local<Value> response_val;
if (!fun->Call(isolate->GetCurrentContext(), cmd_processor, kArgc, args)
.ToLocal(&response_val)) {
Shell::ReportException(isolate, &try_catch);
continue;
}
Handle<String> response = Handle<String>::Cast(response_val);
Local<String> response = Local<String>::Cast(response_val);
// Convert the debugger response into text details and the running state.
Handle<Object> response_details =
Local<Object> response_details =
Shell::DebugMessageDetails(isolate, response);
if (try_catch.HasCaught()) {
Shell::ReportException(isolate, &try_catch);
continue;
}
String::Utf8Value text_str(
response_details->Get(String::NewFromUtf8(isolate, "text")));
response_details->Get(isolate->GetCurrentContext(),
String::NewFromUtf8(isolate, "text",
NewStringType::kNormal)
.ToLocalChecked()).ToLocalChecked());
if (text_str.length() > 0) {
printf("%s\n", *text_str);
}
running = response_details->Get(String::NewFromUtf8(isolate, "running"))
->ToBoolean(isolate)
running = response_details->Get(isolate->GetCurrentContext(),
String::NewFromUtf8(isolate, "running",
NewStringType::kNormal)
.ToLocalChecked())
.ToLocalChecked()
->ToBoolean(isolate->GetCurrentContext())
.ToLocalChecked()
->Value();
}
}

209
src/d8-posix.cc
View File

@ -170,12 +170,14 @@ class ExecArgs {
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;
@ -184,13 +186,17 @@ class ExecArgs {
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;
@ -225,19 +231,27 @@ static bool GetTimeouts(const v8::FunctionCallbackInfo<v8::Value>& args,
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;
}
}
@ -282,7 +296,9 @@ static bool ChildLaunchedOK(Isolate* isolate, int* exec_error_fds) {
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;
@ -291,12 +307,10 @@ static bool ChildLaunchedOK(Isolate* isolate, int* exec_error_fds) {
// 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;
@ -304,7 +318,8 @@ static Handle<Value> GetStdout(Isolate* isolate,
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;
@ -319,7 +334,8 @@ static Handle<Value> GetStdout(Isolate* isolate,
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) {
@ -332,8 +348,9 @@ static Handle<Value> GetStdout(Isolate* isolate,
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);
@ -380,8 +397,10 @@ static bool WaitForChild(Isolate* isolate,
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;
}
@ -392,7 +411,9 @@ static bool WaitForChild(Isolate* isolate,
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) {
@ -401,7 +422,9 @@ static bool WaitForChild(Isolate* isolate,
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;
}
@ -416,7 +439,9 @@ static bool WaitForChild(Isolate* isolate,
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) {
@ -426,7 +451,9 @@ static bool WaitForChild(Isolate* isolate,
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;
}
@ -442,25 +469,29 @@ void Shell::System(const v8::FunctionCallbackInfo<v8::Value>& args) {
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;
}
@ -476,12 +507,14 @@ void Shell::System(const v8::FunctionCallbackInfo<v8::Value>& args) {
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;
}
@ -500,11 +533,8 @@ void Shell::System(const v8::FunctionCallbackInfo<v8::Value>& args) {
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);
@ -528,19 +558,22 @@ void Shell::ChangeDirectory(const v8::FunctionCallbackInfo<v8::Value>& args) {
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;
}
}
@ -550,7 +583,8 @@ void Shell::SetUMask(const v8::FunctionCallbackInfo<v8::Value>& args) {
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()) {
@ -558,14 +592,16 @@ void Shell::SetUMask(const v8::FunctionCallbackInfo<v8::Value>& args) {
// 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;
}
}
@ -575,11 +611,15 @@ static bool CheckItsADirectory(Isolate* isolate, char* directory) {
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;
}
@ -594,7 +634,9 @@ static bool mkdirp(Isolate* isolate, char* directory, mode_t mask) {
} 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;
@ -605,10 +647,14 @@ static bool mkdirp(Isolate* isolate, char* directory, mode_t mask) {
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;
}
}
@ -618,24 +664,29 @@ void Shell::MakeDirectory(const v8::FunctionCallbackInfo<v8::Value>& args) {
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);
@ -646,14 +697,16 @@ void Shell::RemoveDirectory(const v8::FunctionCallbackInfo<v8::Value>& args) {
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);
@ -664,7 +717,8 @@ void Shell::SetEnvironment(const v8::FunctionCallbackInfo<v8::Value>& args) {
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]);
@ -673,14 +727,16 @@ void Shell::SetEnvironment(const v8::FunctionCallbackInfo<v8::Value>& args) {
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);
@ -691,7 +747,8 @@ void Shell::UnsetEnvironment(const v8::FunctionCallbackInfo<v8::Value>& args) {
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]);
@ -699,27 +756,35 @@ void Shell::UnsetEnvironment(const v8::FunctionCallbackInfo<v8::Value>& args) {
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));
}

14
src/d8-readline.cc
View File

@ -25,7 +25,7 @@ namespace v8 {
class ReadLineEditor: public LineEditor {
public:
ReadLineEditor() : LineEditor(LineEditor::READLINE, "readline") { }
virtual Handle<String> Prompt(const char* prompt);
virtual Local<String> Prompt(const char* prompt);
virtual bool Open(Isolate* isolate);
virtual bool Close();
virtual void AddHistory(const char* str);
@ -80,10 +80,10 @@ bool ReadLineEditor::Close() {
}
Handle<String> ReadLineEditor::Prompt(const char* prompt) {
Local<String> ReadLineEditor::Prompt(const char* prompt) {
char* result = NULL;
result = readline(prompt);
if (result == NULL) return Handle<String>();
if (result == NULL) return Local<String>();
AddHistory(result);
return String::NewFromUtf8(isolate_, result);
}
@ -118,10 +118,10 @@ char** ReadLineEditor::AttemptedCompletion(const char* text,
char* ReadLineEditor::CompletionGenerator(const char* text, int state) {
static unsigned current_index;
static Persistent<Array> current_completions;
static Global<Array> current_completions;
Isolate* isolate = read_line_editor.isolate_;
HandleScope scope(isolate);
Handle<Array> completions;
Local<Array> completions;
if (state == 0) {
Local<String> full_text = String::NewFromUtf8(isolate,
rl_line_buffer,
@ -136,8 +136,8 @@ char* ReadLineEditor::CompletionGenerator(const char* text, int state) {
completions = Local<Array>::New(isolate, current_completions);
}
if (current_index < completions->Length()) {
Handle<Integer> index = Integer::New(isolate, current_index);
Handle<Value> str_obj = completions->Get(index);
Local<Integer> index = Integer::New(isolate, current_index);
Local<Value> str_obj = completions->Get(index);
current_index++;
String::Utf8Value str(str_obj);
return strdup(*str);

3
src/d8-windows.cc
View File

@ -8,8 +8,7 @@
namespace v8 {
void Shell::AddOSMethods(Isolate* isolate, Handle<ObjectTemplate> os_templ) {
}
void Shell::AddOSMethods(Isolate* isolate, Local<ObjectTemplate> os_templ) {}
} // namespace v8

553
src/d8.cc
View File

File diff suppressed because it is too large Load Diff

4
src/d8.gyp
View File

@ -53,6 +53,10 @@
'startup-data-util.h',
'startup-data-util.cc'
],
'defines': [
# TODO(jochen): Remove again after this is globally turned on.
'V8_IMMINENT_DEPRECATION_WARNINGS',
],
'conditions': [
[ 'want_separate_host_toolset==1', {
'toolsets': [ '<(v8_toolset_for_d8)', ],

35
src/d8.h
View File

@ -99,7 +99,7 @@ class LineEditor {
LineEditor(Type type, const char* name);
virtual ~LineEditor() { }
virtual Handle<String> Prompt(const char* prompt) = 0;
virtual Local<String> Prompt(const char* prompt) = 0;
virtual bool Open(Isolate* isolate) { return true; }
virtual bool Close() { return true; }
virtual void AddHistory(const char* str) { }
@ -163,7 +163,7 @@ class SourceGroup {
#endif // !V8_SHARED
void ExitShell(int exit_code);
Handle<String> ReadFile(Isolate* isolate, const char* name);
Local<String> ReadFile(Isolate* isolate, const char* name);
const char** argv_;
int begin_offset_;
@ -349,17 +349,17 @@ class Shell : public i::AllStatic {
public:
enum SourceType { SCRIPT, MODULE };
static Local<Script> CompileString(
static MaybeLocal<Script> CompileString(
Isolate* isolate, Local<String> source, Local<Value> name,
v8::ScriptCompiler::CompileOptions compile_options,
SourceType source_type);
static bool ExecuteString(Isolate* isolate, Handle<String> source,
Handle<Value> name, bool print_result,
static bool ExecuteString(Isolate* isolate, Local<String> source,
Local<Value> name, bool print_result,
bool report_exceptions,
SourceType source_type = SCRIPT);
static const char* ToCString(const v8::String::Utf8Value& value);
static void ReportException(Isolate* isolate, TryCatch* try_catch);
static Handle<String> ReadFile(Isolate* isolate, const char* name);
static Local<String> ReadFile(Isolate* isolate, const char* name);
static Local<Context> CreateEvaluationContext(Isolate* isolate);
static int RunMain(Isolate* isolate, int argc, char* argv[]);
static int Main(int argc, char* argv[]);
@ -371,8 +371,8 @@ class Shell : public i::AllStatic {
#ifndef V8_SHARED
// TODO(binji): stupid implementation for now. Is there an easy way to hash an
// object for use in i::HashMap? By pointer?
typedef i::List<Handle<Object>> ObjectList;
static bool SerializeValue(Isolate* isolate, Handle<Value> value,
typedef i::List<Local<Object>> ObjectList;
static bool SerializeValue(Isolate* isolate, Local<Value> value,
const ObjectList& to_transfer,
ObjectList* seen_objects,
SerializationData* out_data);
@ -380,9 +380,8 @@ class Shell : public i::AllStatic {
const SerializationData& data,
int* offset);
static void CleanupWorkers();
static Handle<Array> GetCompletions(Isolate* isolate,
Handle<String> text,
Handle<String> full);
static Local<Array> GetCompletions(Isolate* isolate, Local<String> text,
Local<String> full);
static int* LookupCounter(const char* name);
static void* CreateHistogram(const char* name,
int min,
@ -392,9 +391,9 @@ class Shell : public i::AllStatic {
static void MapCounters(v8::Isolate* isolate, const char* name);
static Local<Object> DebugMessageDetails(Isolate* isolate,
Handle<String> message);
Local<String> message);
static Local<Value> DebugCommandToJSONRequest(Isolate* isolate,
Handle<String> command);
Local<String> command);
static void PerformanceNow(const v8::FunctionCallbackInfo<v8::Value>& args);
#endif // !V8_SHARED
@ -419,7 +418,7 @@ class Shell : public i::AllStatic {
static void Version(const v8::FunctionCallbackInfo<v8::Value>& args);
static void Read(const v8::FunctionCallbackInfo<v8::Value>& args);
static void ReadBuffer(const v8::FunctionCallbackInfo<v8::Value>& args);
static Handle<String> ReadFromStdin(Isolate* isolate);
static Local<String> ReadFromStdin(Isolate* isolate);
static void ReadLine(const v8::FunctionCallbackInfo<v8::Value>& args) {
args.GetReturnValue().Set(ReadFromStdin(args.GetIsolate()));
}
@ -464,17 +463,17 @@ class Shell : public i::AllStatic {
static void RemoveDirectory(const v8::FunctionCallbackInfo<v8::Value>& args);
static void AddOSMethods(v8::Isolate* isolate,
Handle<ObjectTemplate> os_template);
Local<ObjectTemplate> os_template);
static const char* kPrompt;
static ShellOptions options;
static ArrayBuffer::Allocator* array_buffer_allocator;
private:
static Persistent<Context> evaluation_context_;
static Global<Context> evaluation_context_;
static base::OnceType quit_once_;
#ifndef V8_SHARED
static Persistent<Context> utility_context_;
static Global<Context> utility_context_;
static CounterMap* counter_map_;
// We statically allocate a set of local counters to be used if we
// don't want to store the stats in a memory-mapped file
@ -496,7 +495,7 @@ class Shell : public i::AllStatic {
static void InitializeDebugger(Isolate* isolate);
static void RunShell(Isolate* isolate);
static bool SetOptions(int argc, char* argv[]);
static Handle<ObjectTemplate> CreateGlobalTemplate(Isolate* isolate);
static Local<ObjectTemplate> CreateGlobalTemplate(Isolate* isolate);
};