blob: b74dd7d2b0486d22e98b16608908f31d32987baf [file] [log] [blame]
#include <assert.h>
#include <fcntl.h>
#include <string.h>
#include <stdio.h>
#include <stdlib.h>
#include <v8.h>
#include <vector>
#include "js_shell.h"
typedef int (*V8ExtensionInitializer) (v8::Handle<v8::Object> module);
// Note: these typedefs and defines are used to deal with v8 API changes since version 3.19.00
typedef void SwigV8ReturnValue;
typedef v8::FunctionCallbackInfo<v8::Value> SwigV8Arguments;
typedef v8::PropertyCallbackInfo<v8::Value> SwigV8PropertyCallbackInfo;
#define SWIGV8_RETURN(val) args.GetReturnValue().Set(val); return
#define SWIGV8_RETURN_INFO(val, info) info.GetReturnValue().Set(val); return
#define SWIGV8_HANDLESCOPE() v8::HandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_HANDLESCOPE_ESC() v8::EscapableHandleScope scope(v8::Isolate::GetCurrent());
#define SWIGV8_ESCAPE(val) return scope.Escape(val)
#define SWIGV8_CURRENT_CONTEXT() v8::Isolate::GetCurrent()->GetCurrentContext()
#define SWIGV8_STRING_NEW(str) v8::String::NewFromUtf8(v8::Isolate::GetCurrent(), str)
#define SWIGV8_FUNCTEMPLATE_NEW(func) v8::FunctionTemplate::New(v8::Isolate::GetCurrent(), func)
#define SWIGV8_OBJECT_NEW() v8::Object::New(v8::Isolate::GetCurrent())
#define SWIGV8_EXTERNAL_NEW(val) v8::External::New(v8::Isolate::GetCurrent(), val)
#define SWIGV8_UNDEFINED() v8::Undefined(v8::Isolate::GetCurrent())
typedef v8::Local<v8::Context> SwigV8Context;
class V8Shell: public JSShell {
public:
V8Shell();
virtual ~V8Shell();
virtual bool RunScript(const std::string &scriptPath);
virtual bool RunShell();
protected:
virtual bool InitializeEngine();
virtual bool ExecuteScript(const std::string &source, const std::string &scriptPath);
virtual bool DisposeEngine();
private:
v8::Handle<v8::Value> Import(const std::string &moduleName);
SwigV8Context CreateShellContext();
void ReportException(v8::TryCatch *handler);
static SwigV8ReturnValue Print(const SwigV8Arguments &args);
static SwigV8ReturnValue Require(const SwigV8Arguments &args);
static SwigV8ReturnValue Quit(const SwigV8Arguments &args);
static SwigV8ReturnValue Version(const SwigV8Arguments &args);
static const char* ToCString(const v8::String::Utf8Value &value);
};
#ifdef __GNUC__
#include <dlfcn.h>
#define LOAD_SYMBOL(handle, name) dlsym(handle, name)
#else
#error "implement dll loading"
#endif
V8Shell::V8Shell() {}
V8Shell::~V8Shell() {}
bool V8Shell::RunScript(const std::string &scriptPath) {
std::string source = ReadFile(scriptPath);
v8::Isolate *isolate = v8::Isolate::New();
v8::Isolate::Scope isolate_scope(isolate);
SWIGV8_HANDLESCOPE();
SwigV8Context context = CreateShellContext();
if (context.IsEmpty()) {
printf("Could not create context.\n");
return false;
}
context->Enter();
// Store a pointer to this shell for later use
v8::Handle<v8::Object> global = context->Global();
v8::Local<v8::External> __shell__ = SWIGV8_EXTERNAL_NEW((void*) (long) this);
global->SetHiddenValue(SWIGV8_STRING_NEW("__shell__"), __shell__);
// Node.js compatibility: make `print` available as `console.log()`
ExecuteScript("var console = {}; console.log = print;", "<console>");
bool success = ExecuteScript(source, scriptPath);
// Cleanup
context->Exit();
// context.Dispose();
// v8::V8::Dispose();
return success;
}
bool V8Shell::RunShell() {
SWIGV8_HANDLESCOPE();
SwigV8Context context = CreateShellContext();
if (context.IsEmpty()) {
printf("Could not create context.\n");
return false;
}
context->Enter();
v8::Context::Scope context_scope(context);
ExecuteScript("var console = {}; console.log = print;", "<console>");
static const int kBufferSize = 1024;
while (true) {
char buffer[kBufferSize];
printf("> ");
char *str = fgets(buffer, kBufferSize, stdin);
if (str == NULL) break;
std::string source(str);
ExecuteScript(source, "(shell)");
}
printf("\n");
// Cleanup
context->Exit();
// context.Dispose();
// v8::V8::Dispose();
return true;
}
bool V8Shell::InitializeEngine() {
return true;
}
bool V8Shell::ExecuteScript(const std::string &source, const std::string &name) {
SWIGV8_HANDLESCOPE();
v8::TryCatch try_catch;
v8::Handle<v8::Script> script = v8::Script::Compile(SWIGV8_STRING_NEW(source.c_str()), SWIGV8_STRING_NEW(name.c_str()));
// Stop if script is empty
if (script.IsEmpty()) {
// Print errors that happened during compilation.
ReportException(&try_catch);
return false;
}
v8::Handle<v8::Value> result = script->Run();
// Print errors that happened during execution.
if (try_catch.HasCaught()) {
ReportException(&try_catch);
return false;
} else {
return true;
}
}
bool V8Shell::DisposeEngine() {
return true;
}
SwigV8Context V8Shell::CreateShellContext() {
// Create a template for the global object.
v8::Handle<v8::ObjectTemplate> global = v8::ObjectTemplate::New();
// Bind global functions
global->Set(SWIGV8_STRING_NEW("print"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Print));
global->Set(SWIGV8_STRING_NEW("quit"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Quit));
global->Set(SWIGV8_STRING_NEW("require"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Require));
global->Set(SWIGV8_STRING_NEW("version"), SWIGV8_FUNCTEMPLATE_NEW(V8Shell::Version));
SwigV8Context context = v8::Context::New(v8::Isolate::GetCurrent(), NULL, global);
return context;
}
v8::Handle<v8::Value> V8Shell::Import(const std::string &module_path)
{
SWIGV8_HANDLESCOPE_ESC();
HANDLE library;
std::string module_name = LoadModule(module_path, &library);
std::string symname = std::string(module_name).append("_initialize");
V8ExtensionInitializer init_function = reinterpret_cast<V8ExtensionInitializer>((long) LOAD_SYMBOL(library, symname.c_str()));
if(init_function == 0) {
printf("Could not find initializer function.");
return SWIGV8_UNDEFINED();
}
v8::Local<v8::Object> module = SWIGV8_OBJECT_NEW();
init_function(module);
SWIGV8_ESCAPE(module);
}
SwigV8ReturnValue V8Shell::Print(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
bool first = true;
for (int i = 0; i < args.Length(); i++) {
if (first) {
first = false;
} else {
printf(" ");
}
v8::String::Utf8Value str(args[i]);
const char *cstr = V8Shell::ToCString(str);
printf("%s", cstr);
}
printf("\n");
fflush(stdout);
SWIGV8_RETURN(SWIGV8_UNDEFINED());
}
SwigV8ReturnValue V8Shell::Require(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
if (args.Length() != 1) {
printf("Illegal arguments for `require`");
};
v8::String::Utf8Value str(args[0]);
const char *cstr = V8Shell::ToCString(str);
std::string moduleName(cstr);
v8::Local<v8::Object> global = SWIGV8_CURRENT_CONTEXT()->Global();
v8::Local<v8::Value> hidden = global->GetHiddenValue(SWIGV8_STRING_NEW("__shell__"));
v8::Local<v8::External> __shell__ = v8::Local<v8::External>::Cast(hidden);
V8Shell *_this = (V8Shell *) (long) __shell__->Value();
v8::Handle<v8::Value> module = _this->Import(moduleName);
SWIGV8_RETURN(module);
}
SwigV8ReturnValue V8Shell::Quit(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
int exit_code = args[0]->Int32Value();
fflush(stdout);
fflush(stderr);
exit(exit_code);
SWIGV8_RETURN(SWIGV8_UNDEFINED());
}
SwigV8ReturnValue V8Shell::Version(const SwigV8Arguments &args) {
SWIGV8_HANDLESCOPE();
SWIGV8_RETURN(SWIGV8_STRING_NEW(v8::V8::GetVersion()));
}
void V8Shell::ReportException(v8::TryCatch *try_catch) {
SWIGV8_HANDLESCOPE();
v8::String::Utf8Value exception(try_catch->Exception());
const char *exception_string = V8Shell::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 = V8Shell::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 = V8Shell::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");
v8::String::Utf8Value stack_trace(try_catch->StackTrace());
if (stack_trace.length() > 0) {
const char *stack_trace_string = V8Shell::ToCString(stack_trace);
printf("%s\n", stack_trace_string);
}
}
}
// Extracts a C string from a V8 Utf8Value.
const char *V8Shell::ToCString(const v8::String::Utf8Value &value) {
return *value ? *value : "<string conversion failed>";
}
JSShell *V8Shell_Create() {
return new V8Shell();
}