2012-04-16 09:23:56 +00:00
|
|
|
// Copyright 2012 the V8 project authors. All rights reserved.
|
2010-01-18 16:45:13 +00:00
|
|
|
// Redistribution and use in source and binary forms, with or without
|
|
|
|
// modification, are permitted provided that the following conditions are
|
|
|
|
// met:
|
|
|
|
//
|
|
|
|
// * Redistributions of source code must retain the above copyright
|
|
|
|
// notice, this list of conditions and the following disclaimer.
|
|
|
|
// * Redistributions in binary form must reproduce the above
|
|
|
|
// copyright notice, this list of conditions and the following
|
|
|
|
// disclaimer in the documentation and/or other materials provided
|
|
|
|
// with the distribution.
|
|
|
|
// * Neither the name of Google Inc. nor the names of its
|
|
|
|
// contributors may be used to endorse or promote products derived
|
|
|
|
// from this software without specific prior written permission.
|
|
|
|
//
|
|
|
|
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
|
|
|
|
// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
|
|
|
|
// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
|
|
|
|
// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
|
|
|
|
// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
|
|
|
|
// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
|
|
|
|
// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
|
|
|
|
// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
|
|
|
|
// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
|
|
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
|
|
|
|
#include <v8.h>
|
2010-04-09 13:02:25 +00:00
|
|
|
|
2012-07-05 16:23:14 +00:00
|
|
|
#ifdef ENABLE_DEBUGGER_SUPPORT
|
2010-01-18 16:45:13 +00:00
|
|
|
#include <v8-debug.h>
|
2012-07-05 16:23:14 +00:00
|
|
|
#endif // ENABLE_DEBUGGER_SUPPORT
|
2010-04-09 13:02:25 +00:00
|
|
|
|
2010-01-18 16:45:13 +00:00
|
|
|
#include <fcntl.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdio.h>
|
|
|
|
#include <stdlib.h>
|
|
|
|
|
|
|
|
/**
|
|
|
|
* This sample program should demonstrate certain aspects of debugging
|
|
|
|
* standalone V8-based application.
|
|
|
|
*
|
|
|
|
* The program reads input stream, processes it line by line and print
|
|
|
|
* the result to output. The actual processing is done by custom JavaScript
|
|
|
|
* script. The script is specified with command line parameters.
|
|
|
|
*
|
|
|
|
* The main cycle of the program will sequentially read lines from standard
|
|
|
|
* input, process them and print to standard output until input closes.
|
|
|
|
* There are 2 possible configuration in regard to main cycle.
|
|
|
|
*
|
|
|
|
* 1. The main cycle is on C++ side. Program should be run with
|
|
|
|
* --main-cycle-in-cpp option. Script must declare a function named
|
|
|
|
* "ProcessLine". The main cycle in C++ reads lines and calls this function
|
|
|
|
* for processing every time. This is a sample script:
|
|
|
|
|
|
|
|
function ProcessLine(input_line) {
|
|
|
|
return ">>>" + input_line + "<<<";
|
|
|
|
}
|
|
|
|
|
|
|
|
*
|
|
|
|
* 2. The main cycle is in JavaScript. Program should be run with
|
|
|
|
* --main-cycle-in-js option. Script gets run one time at all and gets
|
|
|
|
* API of 2 global functions: "read_line" and "print". It should read input
|
|
|
|
* and print converted lines to output itself. This a sample script:
|
|
|
|
|
|
|
|
while (true) {
|
|
|
|
var line = read_line();
|
|
|
|
if (!line) {
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
var res = line + " | " + line;
|
|
|
|
print(res);
|
|
|
|
}
|
|
|
|
|
|
|
|
*
|
|
|
|
* When run with "-p" argument, the program starts V8 Debugger Agent and
|
|
|
|
* allows remote debugger to attach and debug JavaScript code.
|
|
|
|
*
|
|
|
|
* Interesting aspects:
|
|
|
|
* 1. Wait for remote debugger to attach
|
|
|
|
* Normally the program compiles custom script and immediately runs it.
|
|
|
|
* If programmer needs to debug script from the very beginning, he should
|
|
|
|
* run this sample program with "--wait-for-connection" command line parameter.
|
|
|
|
* This way V8 will suspend on the first statement and wait for
|
|
|
|
* debugger to attach.
|
|
|
|
*
|
|
|
|
* 2. Unresponsive V8
|
|
|
|
* V8 Debugger Agent holds a connection with remote debugger, but it does
|
|
|
|
* respond only when V8 is running some script. In particular, when this program
|
|
|
|
* is waiting for input, all requests from debugger get deferred until V8
|
|
|
|
* is called again. See how "--callback" command-line parameter in this sample
|
|
|
|
* fixes this issue.
|
|
|
|
*/
|
|
|
|
|
|
|
|
enum MainCycleType {
|
|
|
|
CycleInCpp,
|
|
|
|
CycleInJs
|
|
|
|
};
|
|
|
|
|
|
|
|
const char* ToCString(const v8::String::Utf8Value& value);
|
2013-03-15 12:06:53 +00:00
|
|
|
void ReportException(v8::Isolate* isolate, v8::TryCatch* handler);
|
2010-01-18 16:45:13 +00:00
|
|
|
v8::Handle<v8::String> ReadFile(const char* name);
|
|
|
|
v8::Handle<v8::String> ReadLine();
|
|
|
|
|
2013-06-05 12:36:33 +00:00
|
|
|
void Print(const v8::FunctionCallbackInfo<v8::Value>& args);
|
|
|
|
void ReadLine(const v8::FunctionCallbackInfo<v8::Value>& args);
|
2013-03-15 12:06:53 +00:00
|
|
|
bool RunCppCycle(v8::Handle<v8::Script> script,
|
|
|
|
v8::Local<v8::Context> context,
|
2010-01-18 16:45:13 +00:00
|
|
|
bool report_exceptions);
|
|
|
|
|
|
|
|
|
2012-07-05 16:23:14 +00:00
|
|
|
#ifdef ENABLE_DEBUGGER_SUPPORT
|
2010-04-09 13:02:25 +00:00
|
|
|
v8::Persistent<v8::Context> debug_message_context;
|
2010-01-18 16:45:13 +00:00
|
|
|
|
|
|
|
void DispatchDebugMessages() {
|
|
|
|
// We are in some random thread. We should already have v8::Locker acquired
|
|
|
|
// (we requested this when registered this callback). We was called
|
|
|
|
// because new debug messages arrived; they may have already been processed,
|
|
|
|
// but we shouldn't worry about this.
|
|
|
|
//
|
|
|
|
// All we have to do is to set context and call ProcessDebugMessages.
|
|
|
|
//
|
|
|
|
// We should decide which V8 context to use here. This is important for
|
|
|
|
// "evaluate" command, because it must be executed some context.
|
|
|
|
// In our sample we have only one context, so there is nothing really to
|
|
|
|
// think about.
|
2013-05-02 20:18:42 +00:00
|
|
|
v8::Isolate* isolate = v8::Isolate::GetCurrent();
|
|
|
|
v8::HandleScope handle_scope(isolate);
|
2013-05-28 10:36:21 +00:00
|
|
|
v8::Local<v8::Context> context =
|
|
|
|
v8::Local<v8::Context>::New(isolate, debug_message_context);
|
|
|
|
v8::Context::Scope scope(context);
|
2010-01-18 16:45:13 +00:00
|
|
|
|
|
|
|
v8::Debug::ProcessDebugMessages();
|
|
|
|
}
|
2012-07-05 16:23:14 +00:00
|
|
|
#endif // ENABLE_DEBUGGER_SUPPORT
|
2010-01-18 16:45:13 +00:00
|
|
|
|
|
|
|
|
|
|
|
int RunMain(int argc, char* argv[]) {
|
|
|
|
v8::V8::SetFlagsFromCommandLine(&argc, argv, true);
|
2013-03-15 12:06:53 +00:00
|
|
|
v8::Isolate* isolate = v8::Isolate::GetCurrent();
|
|
|
|
v8::HandleScope handle_scope(isolate);
|
2010-01-18 16:45:13 +00:00
|
|
|
|
2013-05-02 20:18:42 +00:00
|
|
|
v8::Handle<v8::String> script_source;
|
|
|
|
v8::Handle<v8::Value> script_name;
|
2010-01-18 16:45:13 +00:00
|
|
|
int script_param_counter = 0;
|
|
|
|
|
2012-07-05 16:23:14 +00:00
|
|
|
#ifdef ENABLE_DEBUGGER_SUPPORT
|
2010-01-18 16:45:13 +00:00
|
|
|
int port_number = -1;
|
|
|
|
bool wait_for_connection = false;
|
2010-01-20 17:06:23 +00:00
|
|
|
bool support_callback = false;
|
2012-07-05 16:23:14 +00:00
|
|
|
#endif // ENABLE_DEBUGGER_SUPPORT
|
2010-04-09 13:02:25 +00:00
|
|
|
|
2010-01-18 16:45:13 +00:00
|
|
|
MainCycleType cycle_type = CycleInCpp;
|
|
|
|
|
|
|
|
for (int i = 1; i < argc; i++) {
|
|
|
|
const char* str = argv[i];
|
|
|
|
if (strcmp(str, "-f") == 0) {
|
|
|
|
// Ignore any -f flags for compatibility with the other stand-
|
|
|
|
// alone JavaScript engines.
|
|
|
|
continue;
|
|
|
|
} else if (strcmp(str, "--main-cycle-in-cpp") == 0) {
|
|
|
|
cycle_type = CycleInCpp;
|
|
|
|
} else if (strcmp(str, "--main-cycle-in-js") == 0) {
|
|
|
|
cycle_type = CycleInJs;
|
2012-07-05 16:23:14 +00:00
|
|
|
#ifdef ENABLE_DEBUGGER_SUPPORT
|
2010-04-09 13:02:25 +00:00
|
|
|
} else if (strcmp(str, "--callback") == 0) {
|
|
|
|
support_callback = true;
|
|
|
|
} else if (strcmp(str, "--wait-for-connection") == 0) {
|
|
|
|
wait_for_connection = true;
|
2010-01-18 16:45:13 +00:00
|
|
|
} else if (strcmp(str, "-p") == 0 && i + 1 < argc) {
|
2010-02-10 11:48:53 +00:00
|
|
|
port_number = atoi(argv[i + 1]); // NOLINT
|
2010-01-18 16:45:13 +00:00
|
|
|
i++;
|
2012-07-05 16:23:14 +00:00
|
|
|
#endif // ENABLE_DEBUGGER_SUPPORT
|
2010-01-18 16:45:13 +00:00
|
|
|
} else if (strncmp(str, "--", 2) == 0) {
|
|
|
|
printf("Warning: unknown flag %s.\nTry --help for options\n", str);
|
|
|
|
} else if (strcmp(str, "-e") == 0 && i + 1 < argc) {
|
|
|
|
script_source = v8::String::New(argv[i + 1]);
|
|
|
|
script_name = v8::String::New("unnamed");
|
|
|
|
i++;
|
|
|
|
script_param_counter++;
|
|
|
|
} else {
|
|
|
|
// Use argument as a name of file to load.
|
|
|
|
script_source = ReadFile(str);
|
|
|
|
script_name = v8::String::New(str);
|
|
|
|
if (script_source.IsEmpty()) {
|
|
|
|
printf("Error reading '%s'\n", str);
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
script_param_counter++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (script_param_counter == 0) {
|
|
|
|
printf("Script is not specified\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (script_param_counter != 1) {
|
|
|
|
printf("Only one script may be specified\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a template for the global object.
|
|
|
|
v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
|
|
|
|
|
|
|
|
// Bind the global 'print' function to the C++ Print callback.
|
|
|
|
global->Set(v8::String::New("print"), v8::FunctionTemplate::New(Print));
|
|
|
|
|
|
|
|
if (cycle_type == CycleInJs) {
|
|
|
|
// Bind the global 'read_line' function to the C++ Print callback.
|
|
|
|
global->Set(v8::String::New("read_line"),
|
|
|
|
v8::FunctionTemplate::New(ReadLine));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a new execution environment containing the built-in
|
|
|
|
// functions
|
2013-05-02 20:18:42 +00:00
|
|
|
v8::Handle<v8::Context> context = v8::Context::New(isolate, NULL, global);
|
2010-01-18 16:45:13 +00:00
|
|
|
// Enter the newly created execution environment.
|
|
|
|
v8::Context::Scope context_scope(context);
|
|
|
|
|
2012-07-05 16:23:14 +00:00
|
|
|
#ifdef ENABLE_DEBUGGER_SUPPORT
|
2013-05-29 08:39:37 +00:00
|
|
|
debug_message_context.Reset(isolate, context);
|
2010-04-09 13:02:25 +00:00
|
|
|
|
2013-03-15 12:06:53 +00:00
|
|
|
v8::Locker locker(isolate);
|
2010-01-18 16:45:13 +00:00
|
|
|
|
|
|
|
if (support_callback) {
|
|
|
|
v8::Debug::SetDebugMessageDispatchHandler(DispatchDebugMessages, true);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (port_number != -1) {
|
|
|
|
v8::Debug::EnableAgent("lineprocessor", port_number, wait_for_connection);
|
|
|
|
}
|
2012-07-05 16:23:14 +00:00
|
|
|
#endif // ENABLE_DEBUGGER_SUPPORT
|
2010-01-18 16:45:13 +00:00
|
|
|
|
|
|
|
bool report_exceptions = true;
|
|
|
|
|
|
|
|
v8::Handle<v8::Script> script;
|
|
|
|
{
|
|
|
|
// Compile script in try/catch context.
|
|
|
|
v8::TryCatch try_catch;
|
|
|
|
script = v8::Script::Compile(script_source, script_name);
|
|
|
|
if (script.IsEmpty()) {
|
|
|
|
// Print errors that happened during compilation.
|
|
|
|
if (report_exceptions)
|
2013-03-15 12:06:53 +00:00
|
|
|
ReportException(isolate, &try_catch);
|
2010-01-18 16:45:13 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
{
|
|
|
|
v8::TryCatch try_catch;
|
|
|
|
|
|
|
|
script->Run();
|
|
|
|
if (try_catch.HasCaught()) {
|
|
|
|
if (report_exceptions)
|
2013-03-15 12:06:53 +00:00
|
|
|
ReportException(isolate, &try_catch);
|
2010-01-18 16:45:13 +00:00
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (cycle_type == CycleInCpp) {
|
2013-03-15 12:06:53 +00:00
|
|
|
bool res = RunCppCycle(script,
|
2013-09-23 11:25:52 +00:00
|
|
|
isolate->GetCurrentContext(),
|
2010-01-18 16:45:13 +00:00
|
|
|
report_exceptions);
|
|
|
|
return !res;
|
|
|
|
} else {
|
|
|
|
// All is already done.
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-03-15 12:06:53 +00:00
|
|
|
bool RunCppCycle(v8::Handle<v8::Script> script,
|
|
|
|
v8::Local<v8::Context> context,
|
2010-01-18 16:45:13 +00:00
|
|
|
bool report_exceptions) {
|
2013-03-15 12:06:53 +00:00
|
|
|
v8::Isolate* isolate = context->GetIsolate();
|
2012-07-05 16:23:14 +00:00
|
|
|
#ifdef ENABLE_DEBUGGER_SUPPORT
|
2013-03-15 12:06:53 +00:00
|
|
|
v8::Locker lock(isolate);
|
2012-07-05 16:23:14 +00:00
|
|
|
#endif // ENABLE_DEBUGGER_SUPPORT
|
2010-01-18 16:45:13 +00:00
|
|
|
|
|
|
|
v8::Handle<v8::String> fun_name = v8::String::New("ProcessLine");
|
2013-03-15 12:06:53 +00:00
|
|
|
v8::Handle<v8::Value> process_val = context->Global()->Get(fun_name);
|
2010-01-18 16:45:13 +00:00
|
|
|
|
|
|
|
// If there is no Process function, or if it is not a function,
|
|
|
|
// bail out
|
|
|
|
if (!process_val->IsFunction()) {
|
|
|
|
printf("Error: Script does not declare 'ProcessLine' global function.\n");
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
|
|
|
|
// It is a function; cast it to a Function
|
|
|
|
v8::Handle<v8::Function> process_fun =
|
|
|
|
v8::Handle<v8::Function>::Cast(process_val);
|
|
|
|
|
|
|
|
|
|
|
|
while (!feof(stdin)) {
|
2013-03-15 12:06:53 +00:00
|
|
|
v8::HandleScope handle_scope(isolate);
|
2010-01-18 16:45:13 +00:00
|
|
|
|
|
|
|
v8::Handle<v8::String> input_line = ReadLine();
|
2013-09-26 08:21:48 +00:00
|
|
|
if (input_line == v8::Undefined(isolate)) {
|
2010-01-18 16:45:13 +00:00
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
const int argc = 1;
|
|
|
|
v8::Handle<v8::Value> argv[argc] = { input_line };
|
|
|
|
|
|
|
|
v8::Handle<v8::Value> result;
|
|
|
|
{
|
|
|
|
v8::TryCatch try_catch;
|
2013-09-23 11:25:52 +00:00
|
|
|
result = process_fun->Call(isolate->GetCurrentContext()->Global(),
|
2010-01-18 16:45:13 +00:00
|
|
|
argc, argv);
|
|
|
|
if (try_catch.HasCaught()) {
|
|
|
|
if (report_exceptions)
|
2013-03-15 12:06:53 +00:00
|
|
|
ReportException(isolate, &try_catch);
|
2010-01-18 16:45:13 +00:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
v8::String::Utf8Value str(result);
|
|
|
|
const char* cstr = ToCString(str);
|
|
|
|
printf("%s\n", cstr);
|
|
|
|
}
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2013-07-05 09:52:11 +00:00
|
|
|
|
2010-01-18 16:45:13 +00:00
|
|
|
int main(int argc, char* argv[]) {
|
2013-07-11 09:58:54 +00:00
|
|
|
v8::V8::InitializeICU();
|
2010-01-18 16:45:13 +00:00
|
|
|
int result = RunMain(argc, argv);
|
|
|
|
v8::V8::Dispose();
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Extracts a C string from a V8 Utf8Value.
|
|
|
|
const char* ToCString(const v8::String::Utf8Value& value) {
|
|
|
|
return *value ? *value : "<string conversion failed>";
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Reads a file into a v8 string.
|
|
|
|
v8::Handle<v8::String> ReadFile(const char* name) {
|
|
|
|
FILE* file = fopen(name, "rb");
|
|
|
|
if (file == NULL) return v8::Handle<v8::String>();
|
|
|
|
|
|
|
|
fseek(file, 0, SEEK_END);
|
|
|
|
int size = ftell(file);
|
|
|
|
rewind(file);
|
|
|
|
|
|
|
|
char* chars = new char[size + 1];
|
|
|
|
chars[size] = '\0';
|
|
|
|
for (int i = 0; i < size;) {
|
2012-06-19 13:45:30 +00:00
|
|
|
int read = static_cast<int>(fread(&chars[i], 1, size - i, file));
|
2010-01-18 16:45:13 +00:00
|
|
|
i += read;
|
|
|
|
}
|
|
|
|
fclose(file);
|
|
|
|
v8::Handle<v8::String> result = v8::String::New(chars, size);
|
|
|
|
delete[] chars;
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2013-03-15 12:06:53 +00:00
|
|
|
void ReportException(v8::Isolate* isolate, v8::TryCatch* try_catch) {
|
|
|
|
v8::HandleScope handle_scope(isolate);
|
2010-01-18 16:45:13 +00:00
|
|
|
v8::String::Utf8Value exception(try_catch->Exception());
|
|
|
|
const char* exception_string = ToCString(exception);
|
|
|
|
v8::Handle<v8::Message> message = try_catch->Message();
|
|
|
|
if (message.IsEmpty()) {
|
|
|
|
// V8 didn't provide any extra information about this error; just
|
|
|
|
// print the exception.
|
|
|
|
printf("%s\n", exception_string);
|
|
|
|
} else {
|
|
|
|
// Print (filename):(line number): (message).
|
|
|
|
v8::String::Utf8Value filename(message->GetScriptResourceName());
|
|
|
|
const char* filename_string = ToCString(filename);
|
|
|
|
int linenum = message->GetLineNumber();
|
|
|
|
printf("%s:%i: %s\n", filename_string, linenum, exception_string);
|
|
|
|
// Print line of source code.
|
|
|
|
v8::String::Utf8Value sourceline(message->GetSourceLine());
|
|
|
|
const char* sourceline_string = ToCString(sourceline);
|
|
|
|
printf("%s\n", sourceline_string);
|
|
|
|
// Print wavy underline (GetUnderline is deprecated).
|
|
|
|
int start = message->GetStartColumn();
|
|
|
|
for (int i = 0; i < start; i++) {
|
|
|
|
printf(" ");
|
|
|
|
}
|
|
|
|
int end = message->GetEndColumn();
|
|
|
|
for (int i = start; i < end; i++) {
|
|
|
|
printf("^");
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// The callback that is invoked by v8 whenever the JavaScript 'print'
|
|
|
|
// function is called. Prints its arguments on stdout separated by
|
|
|
|
// spaces and ending with a newline.
|
2013-06-05 12:36:33 +00:00
|
|
|
void Print(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
2010-01-18 16:45:13 +00:00
|
|
|
bool first = true;
|
|
|
|
for (int i = 0; i < args.Length(); i++) {
|
2013-03-15 12:06:53 +00:00
|
|
|
v8::HandleScope handle_scope(args.GetIsolate());
|
2010-01-18 16:45:13 +00:00
|
|
|
if (first) {
|
|
|
|
first = false;
|
|
|
|
} else {
|
|
|
|
printf(" ");
|
|
|
|
}
|
|
|
|
v8::String::Utf8Value str(args[i]);
|
|
|
|
const char* cstr = ToCString(str);
|
|
|
|
printf("%s", cstr);
|
|
|
|
}
|
|
|
|
printf("\n");
|
|
|
|
fflush(stdout);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// The callback that is invoked by v8 whenever the JavaScript 'read_line'
|
|
|
|
// function is called. Reads a string from standard input and returns.
|
2013-06-05 12:36:33 +00:00
|
|
|
void ReadLine(const v8::FunctionCallbackInfo<v8::Value>& args) {
|
2010-01-18 16:45:13 +00:00
|
|
|
if (args.Length() > 0) {
|
2013-09-26 07:37:59 +00:00
|
|
|
args.GetIsolate()->ThrowException(v8::String::New("Unexpected arguments"));
|
2013-06-05 12:36:33 +00:00
|
|
|
return;
|
2010-01-18 16:45:13 +00:00
|
|
|
}
|
2013-06-05 12:36:33 +00:00
|
|
|
args.GetReturnValue().Set(ReadLine());
|
2010-01-18 16:45:13 +00:00
|
|
|
}
|
|
|
|
|
2013-07-05 09:52:11 +00:00
|
|
|
|
2010-01-18 16:45:13 +00:00
|
|
|
v8::Handle<v8::String> ReadLine() {
|
2010-01-19 08:03:26 +00:00
|
|
|
const int kBufferSize = 1024 + 1;
|
|
|
|
char buffer[kBufferSize];
|
2010-01-18 16:45:13 +00:00
|
|
|
|
|
|
|
char* res;
|
|
|
|
{
|
2012-07-05 16:23:14 +00:00
|
|
|
#ifdef ENABLE_DEBUGGER_SUPPORT
|
2013-01-18 07:20:17 +00:00
|
|
|
v8::Unlocker unlocker(v8::Isolate::GetCurrent());
|
2012-07-05 16:23:14 +00:00
|
|
|
#endif // ENABLE_DEBUGGER_SUPPORT
|
2010-01-19 18:36:51 +00:00
|
|
|
res = fgets(buffer, kBufferSize, stdin);
|
2010-01-18 16:45:13 +00:00
|
|
|
}
|
|
|
|
if (res == NULL) {
|
2013-09-26 08:21:48 +00:00
|
|
|
v8::Handle<v8::Primitive> t = v8::Undefined(v8::Isolate::GetCurrent());
|
2013-05-29 08:39:37 +00:00
|
|
|
return v8::Handle<v8::String>::Cast(t);
|
2010-01-18 16:45:13 +00:00
|
|
|
}
|
2012-04-16 09:23:56 +00:00
|
|
|
// Remove newline char
|
2010-01-18 16:45:13 +00:00
|
|
|
for (char* pos = buffer; *pos != '\0'; pos++) {
|
|
|
|
if (*pos == '\n') {
|
|
|
|
*pos = '\0';
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return v8::String::New(buffer);
|
|
|
|
}
|