Merge lp:~marcustomlinson/v8-cpp/v8runner into lp:v8-cpp

[Marcus Tomlinson]

Added v8runner executable that runs a JS script and supports the "require()" keyword to load in V8 (incl. Node) modules.

[lp:~marcustomlinson/v8-cpp/v8runner]

33. By Marcus Tomlinson on 2015-07-02

Retrieve dependencies on build rather than cmake

34. By Marcus Tomlinson on 2015-07-02

Oops, fixed v8cpp_script_path_

=== modified file '.bzrignore'
--- .bzrignore	2015-06-10 05:57:04 +0000
+++ .bzrignore	2015-07-02 11:58:46 +0000
@@ -1,1 +1,5 @@
 ./CMakeLists.txt.user
+./deps/.gclient
+./deps/.gclient_entries
+./deps/depot_tools
+./deps/v8
 
=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-06-10 06:20:49 +0000
+++ CMakeLists.txt	2015-07-02 11:58:46 +0000
@@ -13,12 +13,14 @@
     -fPIC
 )
 
-find_package(Node REQUIRED)
-
 include_directories(
-    ${NODE_INCLUDE_DIRS}
     ${CMAKE_CURRENT_SOURCE_DIR}/src
+    ${CMAKE_CURRENT_SOURCE_DIR}/deps/v8/include
+)
+link_directories(
+    ${CMAKE_CURRENT_SOURCE_DIR}/deps/v8/out/native/obj.target/tools/gyp
 )
 
 add_subdirectory(src)
 add_subdirectory(test)
+add_subdirectory(v8runner)
 
=== added directory 'deps'
=== added file 'deps/build-deps.sh'
--- deps/build-deps.sh	1970-01-01 00:00:00 +0000
+++ deps/build-deps.sh	2015-07-02 11:58:46 +0000
@@ -0,0 +1,30 @@
+#!/bin/bash
+
+DIR=$(readlink -f $(dirname ${BASH_SOURCE[0]}))
+
+cd $DIR
+
+if ! [ -d "depot_tools" ]; then
+    git clone --depth 1 https://chromium.googlesource.com/chromium/tools/depot_tools.git
+fi
+
+if ! [ -d "v8" ]; then
+    git clone --depth 1 --branch 3.28.73 https://chromium.googlesource.com/v8/v8.git
+fi
+
+export PATH=./depot_tools:"$PATH"
+gclient config --spec 'solutions = [
+  { "name"        : "v8",
+    "url"         : "https://chromium.googlesource.com/v8/v8.git",
+    "deps_file"   : "DEPS",
+    "managed"     : False,
+    "custom_deps" : {
+    },
+    "safesync_url": "",
+  },
+]
+cache_dir = None'
+gclient sync
+
+cd v8
+make -j3 native i18nsupport=off
 
=== modified file 'src/CMakeLists.txt'
--- src/CMakeLists.txt	2015-06-10 05:57:04 +0000
+++ src/CMakeLists.txt	2015-07-02 11:58:46 +0000
@@ -4,7 +4,28 @@
     *.h
 )
 
-add_custom_target(
-  source_files
-  SOURCES ${SRC_FILES}
+add_library(
+    v8-cpp SHARED
+    ${SRC_FILES}
+)
+
+set_target_properties(
+    v8-cpp PROPERTIES
+    LINKER_LANGUAGE CXX
+)
+
+target_link_libraries(
+    v8-cpp
+
+    v8_base
+    v8_libbase
+    v8_snapshot
+
+    dl
+    pthread
+)
+
+add_custom_command(
+    TARGET v8-cpp PRE_LINK
+    COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/../deps/build-deps.sh
 )
 
=== added file 'src/internal/require.h'
--- src/internal/require.h	1970-01-01 00:00:00 +0000
+++ src/internal/require.h	2015-07-02 11:58:46 +0000
@@ -0,0 +1,137 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marcus Tomlinson <[e-mail]>
+ */
+
+#pragma once
+
+#include <dlfcn.h>
+#include <iostream>
+
+namespace v8cpp
+{
+namespace internal
+{
+
+using ModuleInitFunc = void(v8::Handle<v8::Object> exports);
+ModuleInitFunc* node_init_func_;
+std::string v8cpp_script_path_;
+
+struct NodeModule
+{
+    int nm_version;
+    unsigned int nm_flags;
+    void* nm_dso_handle;
+    const char* nm_filename;
+    ModuleInitFunc* nm_register_func;
+    //...
+};
+
+extern "C" void node_module_register(void* m)
+{
+    auto mp = static_cast<NodeModule*>(m);
+
+    // For now we only know that version 14 works here
+    if (mp->nm_version == 14)
+    {
+        node_init_func_ = mp->nm_register_func;
+    }
+    else
+    {
+        std::cerr << "node_module_register(): ignoring node module. nm_version " << mp->nm_version << " not supported"
+                  << std::endl;
+    }
+}
+
+class Console
+{
+public:
+    inline static void log(v8::FunctionCallbackInfo<v8::Value> const& args)
+    {
+        for (int i = 0; i < args.Length(); ++i)
+        {
+            if (args[i]->IsInt32())
+            {
+                std::cout << v8cpp::from_v8<int>(v8::Isolate::GetCurrent(), args[i]) << std::endl;
+            }
+            if (args[i]->IsUint32())
+            {
+                std::cout << v8cpp::from_v8<unsigned int>(v8::Isolate::GetCurrent(), args[i]) << std::endl;
+            }
+            else if (args[i]->IsNumber())
+            {
+                std::cout << v8cpp::from_v8<float>(v8::Isolate::GetCurrent(), args[i]) << std::endl;
+            }
+            else if (args[i]->IsBoolean())
+            {
+                std::cout << v8cpp::from_v8<bool>(v8::Isolate::GetCurrent(), args[i]) << std::endl;
+            }
+            else if (args[i]->IsString())
+            {
+                std::cout << v8cpp::from_v8<std::string>(v8::Isolate::GetCurrent(), args[i]) << std::endl;
+            }
+        }
+        std::cout.flush();
+    }
+};
+
+inline v8::Local<v8::Object> require(std::string const& module_path)
+{
+    node_init_func_ = nullptr;
+    v8::Local<v8::Object> exports = v8::Object::New(v8::Isolate::GetCurrent());
+
+    // Try append ".node" to module_path
+    std::string suffixed_module_path = v8cpp_script_path_ + module_path + ".node";
+    auto module = dlopen(suffixed_module_path.c_str(), RTLD_LAZY);
+    if (!module)
+    {
+        // Didn't work, now try append ".so" to module_path
+        suffixed_module_path = v8cpp_script_path_ + module_path + ".so";
+        module = dlopen(suffixed_module_path.c_str(), RTLD_LAZY);
+        if (!module)
+        {
+            // Still didn't work, just try module_path as is
+            suffixed_module_path = v8cpp_script_path_ + module_path;
+            module = dlopen(suffixed_module_path.c_str(), RTLD_LAZY);
+            if (!module)
+            {
+                std::cerr << "dlopen failed: " << dlerror() << std::endl;
+                return exports;
+            }
+        }
+    }
+
+    if (node_init_func_)
+    {
+        node_init_func_(exports);
+    }
+    else
+    {
+        auto v8cpp_init_func = (ModuleInitFunc*)dlsym(module, "init_module");
+        if (!v8cpp_init_func)
+        {
+            std::cerr << "dlsym failed: " << dlerror() << std::endl;
+            return exports;
+        }
+
+        v8cpp_init_func(exports);
+    }
+
+    return exports;
+}
+
+}  // namespace internal
+}  // namespace v8cpp
 
=== modified file 'src/module.h'
--- src/module.h	2015-06-11 05:51:30 +0000
+++ src/module.h	2015-07-02 11:58:46 +0000
@@ -32,7 +32,7 @@
 public:
     explicit Module(v8::Isolate* isolate)
         : isolate_(isolate)
-        , object_(v8::ObjectTemplate::New(isolate))
+        , object_template_(v8::ObjectTemplate::New(isolate))
     {
     }
 
@@ -40,7 +40,7 @@
     template <typename T>
     Module& add_class(char const* name, Class<T>& cl)
     {
-        object_->Set(to_v8(isolate_, name), cl.class_.proto_template()->GetFunction());
+        object_template_->Set(to_v8(isolate_, name), cl.class_.proto_template()->GetFunction());
         return *this;
     }
 
@@ -48,19 +48,37 @@
     template <typename F>
     Module& add_function(char const* name, F func)
     {
-        object_->Set(to_v8(isolate_, name), internal::export_function(isolate_, func));
+        object_template_->Set(to_v8(isolate_, name), internal::export_function(isolate_, func));
         return *this;
     }
 
     // Create an instance of this module in V8
     v8::Local<v8::Object> create_prototype()
     {
-        return object_->NewInstance();
+        return object_template_->NewInstance();
+    }
+
+    v8::Handle<v8::ObjectTemplate> object_template()
+    {
+        return object_template_;
     }
 
 private:
     v8::Isolate* isolate_;
-    v8::Handle<v8::ObjectTemplate> object_;
+    v8::Handle<v8::ObjectTemplate> object_template_;
 };
 
+// Create a V8-cpp module by exposing it's init function
+#define V8CPP_MODULE(module_name, init_func)\
+extern "C"\
+{\
+    namespace v8cpp\
+    {\
+        void init_module(Handle<Object> exports)\
+        {\
+            init_func(exports);\
+        }\
+    }\
+}
+
 }  // namespace v8cpp
 
=== added file 'src/run.h'
--- src/run.h	1970-01-01 00:00:00 +0000
+++ src/run.h	2015-07-02 11:58:46 +0000
@@ -0,0 +1,95 @@
+/*
+ * Copyright (C) 2015 Canonical Ltd
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License version 3 as
+ * published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ * Authored by: Marcus Tomlinson <[e-mail]>
+ */
+
+#pragma once
+
+#include <internal/require.h>
+
+#include <fstream>
+
+namespace v8cpp
+{
+
+template <typename T = v8::Handle<v8::Value>>
+T run_script(v8::Isolate* isolate, std::string const& source, std::string const& filename = "")
+{
+    // Create an isolate scope.
+    v8::Isolate::Scope isolate_scope(isolate);
+
+    // Create a stack-allocated handle scope.
+    v8::HandleScope handle_scope(isolate);
+
+    // Prepare console class
+    v8cpp::Class<internal::Console> console(isolate);
+    console
+            .set_constructor()
+            .add_method("log", &internal::Console::log);
+
+    // Create a new context that supports "require()" and "console".
+    v8cpp::Module module(isolate);
+    {
+        v8::Context::Scope context_scope(v8::Context::New(isolate));
+
+        // Store the script filename for use in require() later
+        internal::v8cpp_script_path_.clear();
+        std::size_t found = filename.find_last_of("/");
+        if (found != std::string::npos)
+        {
+            internal::v8cpp_script_path_ = filename.substr(0, found) + "/";
+        }
+
+        module.add_function("require", &internal::require);
+        module.add_class("console", console);
+    }
+    v8::Local<v8::Context> context = v8::Context::New(isolate, nullptr, module.object_template());
+
+    // Enter the context for compiling and running the script.
+    v8::Context::Scope context_scope(context);
+
+    // Compile the script.
+    v8::Local<v8::Script> script = v8::Script::Compile(v8cpp::to_v8(isolate, source), v8cpp::to_v8(isolate, filename));
+
+    // Run the script.
+    if (script.IsEmpty())
+    {
+        if (!filename.empty())
+        {
+            throw std::runtime_error("run_script(): Failed to compile script file: \"" + filename + "\"");
+        }
+        else
+        {
+            throw std::runtime_error("run_script(): Failed to compile script.");
+        }
+    }
+
+    return v8cpp::from_v8<T>(isolate, script->Run());
+}
+
+template <typename T = v8::Handle<v8::Value>>
+T run_script_file(v8::Isolate* isolate, std::string const& filename)
+{
+    std::ifstream stream(filename.c_str());
+    if (!stream)
+    {
+        throw std::runtime_error("run_script_file(): Failed to locate script file: \"" + filename + "\"");
+    }
+
+    std::istreambuf_iterator<char> begin(stream), end;
+    return run_script<T>(isolate, std::string(begin, end), filename);
+}
+}
 
=== modified file 'src/v8-cpp.h'
--- src/v8-cpp.h	2015-06-10 05:57:04 +0000
+++ src/v8-cpp.h	2015-07-02 11:58:46 +0000
@@ -20,3 +20,4 @@
 #include <class.h>
 #include <convert.h>
 #include <module.h>
+#include <run.h>
 
=== modified file 'test/CMakeLists.txt'
--- test/CMakeLists.txt	2015-06-10 05:57:04 +0000
+++ test/CMakeLists.txt	2015-07-02 11:58:46 +0000
@@ -1,9 +1,13 @@
+find_package(Node REQUIRED)
+
+include_directories(
+    ${NODE_INCLUDE_DIRS}
+)
+
 file(
     GLOB
     TEST_FILES
-    *.h
-    *.cpp
-    *.js
+    *.h *.cpp *.js
 )
 
 configure_file(test.js test.js)
 
=== modified file 'test/addon.cpp'
--- test/addon.cpp	2015-06-22 16:40:30 +0000
+++ test/addon.cpp	2015-07-02 11:58:46 +0000
@@ -119,3 +119,4 @@
 }
 
 NODE_MODULE(addon, InitAll)
+V8CPP_MODULE(addon, InitAll)
 
=== added directory 'v8runner'
=== added file 'v8runner/CMakeLists.txt'
--- v8runner/CMakeLists.txt	1970-01-01 00:00:00 +0000
+++ v8runner/CMakeLists.txt	2015-07-02 11:58:46 +0000
@@ -0,0 +1,9 @@
+add_executable(
+    v8runner
+    v8runner.cpp
+)
+
+target_link_libraries(
+    v8runner
+    v8-cpp
+)
 
=== added file 'v8runner/v8runner.cpp'
--- v8runner/v8runner.cpp	1970-01-01 00:00:00 +0000
+++ v8runner/v8runner.cpp	2015-07-02 11:58:46 +0000
@@ -0,0 +1,24 @@
+#include <v8-cpp.h>
+
+using namespace v8;
+
+int main(int argc, char* argv[])
+{
+    // Check args.
+    if (argc != 2)
+    {
+        std::cerr << "usage: v8runner script.js" << std::endl;
+        return -1;
+    }
+
+    // Create a new isolate to run our script in.
+    Isolate* isolate = Isolate::New();
+
+    // Run script.
+    v8cpp::run_script_file(isolate, argv[1]);
+
+    // Clean up.
+    isolate->Dispose();
+
+    return 0;
+}