nodejs · luminosuslight · Oct 27, 2017 · Oct 27, 2017 · Oct 26, 2017 · Oct 29, 2017
diff --git a/src/node.cc b/src/node.cc
@@ -4992,9 +4992,73 @@ int Start(int argc, char** argv) {
 
 namespace lib {
 
-struct CmdArgs {
+/**
+ * @brief The CmdArgs class is a container for argc and argv.
+ */
+class CmdArgs {
+
+public:
+  /**
+   * @brief CmdArgs creates valid argc and argv variables from a program name and arguments.
+   *
+   * The argv buffer is a contiguous, adjacent char buffer and contains the program name
+   * as its first item followed by the provided arguments. argc is the number of
+   * arguments + 1 (the program name).
+   * The resulting argv buffer should not be modified.
+   *
+   * @param program_name the name of the executable
+   * @param arguments the arguments for the program
+   */
+  CmdArgs(const std::string& program_name, const std::vector<std::string>& arguments)
+    : argc(0)
+    , argv(nullptr)
+  {
+    size_t total_size = 0;
+    total_size += program_name.size() + 1;
+    for (const auto& argument: arguments) {
+      total_size += argument.size() + 1;
+    }
+
+    std::vector<std::size_t> offsets;
+    argument_data.reserve(total_size);
+    offsets.push_back(argument_data.size());
+    argument_data += program_name;
+    argument_data += char(0x0);
+    for (const auto& argument: arguments) {
+      offsets.push_back(argument_data.size());
+      argument_data += argument;
+      argument_data += char(0x0);
+    }
+
+    argument_pointers.resize(offsets.size());
+    for (std::size_t i=0; i<argument_pointers.size(); ++i) {
+      argument_pointers[i] = argument_data.data() + offsets[i];
+    }
+    argc = argument_pointers.size();
+    argv = argument_pointers.data();
+  }
+
+  ~CmdArgs() = default;
+
+  /**
+   * @brief argc is the number of arguments + 1 (the program name)
+   */
   int argc;
-  char** argv;
+  /**
+   * @brief argv is an array containing pointers to the arguments (and the program name),
+   * it should not be modified
+   */
+  const char** argv;
+
+private:
+  /**
+   * @brief argument_data contains the program name and the arguments separated by null bytes
+   */
+  std::string argument_data;
+  /**
+   * @brief argument_pointers contains pointers to the beginnings of the strings in argument_data
+   */
+  std::vector<const char*> argument_pointers;
 };
 
 ArrayBufferAllocator* allocator;
@@ -5013,8 +5077,8 @@ void deleteCmdArgs() {
   if (!cmd_args) {
     return;
   }
-  delete[] cmd_args->argv;
   delete cmd_args;
+  cmd_args = nullptr;
 }
 
 int _StopEnv() {
@@ -5058,15 +5122,6 @@ void deinitV8() {
 
 namespace initialize {
 
-void generateCmdArgsFromProgramName(const std::string& program_name) {
-  deinitialize::deleteCmdArgs();
-  int argc = 1;
-  char* program_name_c_string = new char[program_name.length() + 1];
-  std::strcpy(program_name_c_string, program_name.c_str());
-  char** argv = new char*(program_name_c_string);
-  cmd_args = new CmdArgs{argc, argv};
-}
-
 void initV8() {
   v8_platform.Initialize(v8_thread_pool_size, uv_default_loop());
   // Enable tracing when argv has --trace-events-enabled.
@@ -5180,28 +5235,27 @@ void _StartEnv(int argc,
 
 }  // namespace initialize
 
-void Initialize(const std::string& program_name) {
+void Initialize(const std::string& program_name, const std::vector<std::string>& node_args) {
   //////////
   // Start 1
   //////////
   atexit([] () { uv_tty_reset_mode(); });
   PlatformInit();
   node::performance::performance_node_start = PERFORMANCE_NOW();
 
-  // currently we do not support additional commandline options for node, uv, or v8
-  // we explicitily only set the first argument to the program name
-  initialize::generateCmdArgsFromProgramName(program_name);
+  cmd_args = new CmdArgs(program_name, node_args);
 
-  // Hack around with the argv pointer. Used for process.title = "blah".
-  cmd_args->argv = uv_setup_args(cmd_args->argc, cmd_args->argv);
+  // Hack around with the argv pointer. Used for process.title = "blah --args".
+  // argv won't be modified
+  uv_setup_args(cmd_args->argc, const_cast<char**>(cmd_args->argv));
 
   // This needs to run *before* V8::Initialize().  The const_cast is not
   // optional, in case you're wondering.
   // Init() puts the v8 specific cmd args in exec_argc and exec_argv, but as we
   // don't support these, they are not used.
   int exec_argc = 0;
   const char** exec_argv = nullptr;
-  Init(&cmd_args->argc, const_cast<const char**>(cmd_args->argv), &exec_argc, &exec_argv);
+  Init(&cmd_args->argc, cmd_args->argv, &exec_argc, &exec_argv);
 
   initialize::configureOpenSsl();
 
@@ -5242,7 +5296,7 @@ int Deinitialize() {
   return exit_code;
 }
 
-v8::Local<v8::Value> Run(const std::string& path) {
+v8::MaybeLocal<v8::Value> Run(const std::string& path) {
   // Read entire file into string. There is most certainly a better way ;)
   // https://stackoverflow.com/a/2602258/2560557
   std::ifstream t(path);
@@ -5252,7 +5306,7 @@ v8::Local<v8::Value> Run(const std::string& path) {
   return Evaluate(buffer.str());
 }
 
-v8::Local<v8::Value> Evaluate(const std::string& java_script_code) {
+v8::MaybeLocal<v8::Value> Evaluate(const std::string& java_script_code) {
   EscapableHandleScope scope(_environment->isolate());
   TryCatch try_catch(_environment->isolate());
 
@@ -5264,16 +5318,10 @@ v8::Local<v8::Value> Evaluate(const std::string& java_script_code) {
   MaybeLocal<v8::Script> script = v8::Script::Compile(_environment->context(), v8::String::NewFromUtf8(_isolate, java_script_code.c_str())/*, origin*/);
   if (script.IsEmpty()) {
     ReportException(_environment, try_catch);
-    exit(3); //TODO jh: don't exit process when function breaks. Handle error differently.
+    return MaybeLocal<v8::Value>();
   }
 
-  Local<Value> result = script.ToLocalChecked()->Run();
-  if (result.IsEmpty()) {
-    ReportException(_environment, try_catch);
-    exit(4); //TODO jh: don't exit process when function breaks. Handle error differently.
-  }
-
-  return scope.Escape(result);
+  return MaybeLocal<v8::Value>(scope.Escape(script.ToLocalChecked()->Run()));
 }
 
 void RunEventLoop(const std::function<void()>& callback) {
@@ -5292,66 +5340,112 @@ void RunEventLoop(const std::function<void()>& callback) {
   _event_loop_running = false;
 }
 
-v8::Local<v8::Object> GetRootObject() {
+v8::MaybeLocal<v8::Object> GetRootObject() {
+  if (context.IsEmpty()) {
+    return MaybeLocal<v8::Object>();
+  }
   return context->Global();
 }
 
 
-v8::Local<v8::Value> Call(v8::Local<v8::Object> receiver, v8::Local<v8::Function> function, const std::vector<v8::Local<v8::Value>> & args = {}) {
+v8::MaybeLocal<v8::Value> Call(v8::Local<v8::Object> receiver, v8::Local<v8::Function> function, const std::vector<v8::Local<v8::Value>> & args) {
     return function->Call(receiver, args.size(), const_cast<v8::Local<v8::Value>*>(&args[0]));
 }
 
-v8::Local<v8::Value> Call(v8::Local<v8::Object> receiver, v8::Local<v8::Function> function, std::initializer_list<v8::Local<v8::Value>> args) {
+v8::MaybeLocal<v8::Value> Call(v8::Local<v8::Object> receiver, v8::Local<v8::Function> function, std::initializer_list<v8::Local<v8::Value>> args) {
     return Call(receiver, function, std::vector<v8::Local<v8::Value>>(args));
 }
 
-// TODO: Error handling: Node.js has exceptions disabled.
-v8::Local<v8::Value> Call(v8::Local<v8::Object> object, const std::string& function_name, const std::vector<v8::Local<v8::Value>>& args) {
-  Local<v8::String> v8_function_name = v8::String::NewFromUtf8(_isolate, function_name.c_str());
+v8::MaybeLocal<v8::Value> Call(v8::Local<v8::Object> object, const std::string& function_name, const std::vector<v8::Local<v8::Value>>& args) {
+  MaybeLocal<v8::String> maybe_function_name = v8::String::NewFromUtf8(_isolate, function_name.c_str());
+  Local<v8::String> v8_function_name;
 
-  Local<v8::Value> value = object->Get(v8_function_name);
-  if (!value->IsFunction()) {
-    //throw new Exception(":((");
-    // TODO (js): at least return at this point
+  if (!maybe_function_name.ToLocal(&v8_function_name)) {
+    // cannot create v8 string.
+    return MaybeLocal<v8::Value>();
+  }
+
+  MaybeLocal<v8::Value> maybe_value = object->Get(v8_function_name);
+  Local<v8::Value> value;
+
+  if (!maybe_value.ToLocal(&value)) {
+    // cannot get member of object
+    return MaybeLocal<v8::Value>();
+  } else if (!value->IsFunction()) {
+    // cannot execute non-function
+    return MaybeLocal<v8::Value>();
   }
 
   return Call(object, v8::Local<v8::Function>::Cast(value), args);
 }
 
-v8::Local<v8::Value> Call(v8::Local<v8::Object> object, const std::string & function_name, std::initializer_list<v8::Local<v8::Value>> args) {
+v8::MaybeLocal<v8::Value> Call(v8::Local<v8::Object> object, const std::string & function_name, std::initializer_list<v8::Local<v8::Value>> args) {
     return Call(object, function_name, std::vector<v8::Local<v8::Value>>(args));
 }
 
-// TODO: Node.js has exceptions disabled.
-v8::Local<v8::Object> IncludeModule(const std::string& module_name) {
-  std::vector<v8::Local<v8::Value>> args = {v8::String::NewFromUtf8(_isolate, module_name.c_str())};
+v8::MaybeLocal<v8::Object> IncludeModule(const std::string& module_name) {
+  MaybeLocal<v8::String> maybe_arg = v8::String::NewFromUtf8(_isolate, module_name.c_str());
+  Local<v8::String> arg;
+
+  if (!maybe_arg.ToLocal(&arg)) {
+    // cannot create v8 string
+    return MaybeLocal<v8::Object>();
+  }
+
+  Local<v8::Object> root_object;
+
+  if (!GetRootObject().ToLocal(&root_object)) {
+    // cannot get root object
+    return MaybeLocal<v8::Object>();
+  }
+
+  std::vector<Local<v8::Value>> args = { arg };
+
+  MaybeLocal<v8::Value> maybe_module = Call(root_object, "require", args);
+  Local<v8::Value> module;
+
+  if (!maybe_module.ToLocal(&module)) {
+    // cannot get module
+    return MaybeLocal<v8::Object>();
+  }
+
+  return MaybeLocal<v8::Object>(Local<v8::Object>::Cast(module));
+}
+
+v8::MaybeLocal<v8::Value> GetValue(v8::Local<v8::Object> object, const std::string& value_name) {
+  MaybeLocal<v8::String> maybe_key = v8::String::NewFromUtf8(_isolate, value_name.c_str());
+  Local<v8::String> key;
 
-  auto module = Call(GetRootObject(), "require", args);
-  if (module->IsUndefined()) {
-    //TODO jh: throw new Exception(":(("); // repuire() call failed, but did not throw a JS exception.
-    // TODO (js): at least return at this point
+  if (!maybe_key.ToLocal(&key)) {
+    // cannot create v8::String
+    return MaybeLocal<v8::Value>();
   }
 
-  return v8::Local<v8::Object>::Cast(module);
+  return object->Get(context, key);
 }
 
-void RegisterModule(const std::string & name, const addon_context_register_func & callback, void *priv) {
-    node::node_module* module = new node::node_module();
+void RegisterModule(const std::string & name, const addon_context_register_func & callback, void *priv, const std::string & target) {
+  node::node_module* module = new node::node_module();
 
-    module->nm_version = NODE_MODULE_VERSION;
-    module->nm_flags = NM_F_BUILTIN;
-    module->nm_filename = __FILE__;
-    module->nm_context_register_func = callback;
-    module->nm_modname = name.c_str();
-    module->nm_priv = priv;
+  module->nm_version = NODE_MODULE_VERSION;
+  module->nm_flags = NM_F_BUILTIN;
+  module->nm_filename = __FILE__;
+  module->nm_context_register_func = callback;
+  module->nm_modname = name.c_str();
+  module->nm_priv = priv;
 
-    node_module_register(module);
+  node_module_register(module);
+
+  if(target != "") {
+    Evaluate("const " + target + " = process.binding('" + name + "')");
+  }
 }
 
 void RegisterModule(const std::string & name,
-                    const std::map<std::string, v8::FunctionCallback> & module_functions) {
+                    const std::map<std::string, v8::FunctionCallback> & module_functions,
+                    const std::string & target) {
     auto map_on_heap = new const std::map<std::string, v8::FunctionCallback>(module_functions);
-    RegisterModule(name, node::lib::_RegisterModuleCallback, const_cast<std::map<std::string, v8::FunctionCallback>*>(map_on_heap));
+    RegisterModule(name, node::lib::_RegisterModuleCallback, const_cast<std::map<std::string, v8::FunctionCallback>*>(map_on_heap), target);
 }
 
 void _RegisterModuleCallback(v8::Local<v8::Object> exports,
@@ -5375,7 +5469,6 @@ void StopEventLoop() {
     return;
   }
   request_stop = true;
-  //while (request_stop && _event_loop_running) { }
 }
 
 bool ProcessEvents() {