#include "node_native_module.h"

#include "debug_utils-inl.h"

#include "node_internals.h"

#include "util-inl.h"

namespace node {

namespace native_module {

using v8::Context;

using v8::EscapableHandleScope;

using v8::Function;

using v8::Isolate;

using v8::Local;

using v8::MaybeLocal;

using v8::Object;

using v8::ScriptCompiler;

using v8::ScriptOrigin;

using v8::String;

NativeModuleLoader NativeModuleLoader::instance_;

}

}

  }

}

  }

}

}

  }

}

    DCHECK(!module_categories_.can_be_required.empty());

  }

  std::vector<std::string> prefixes = {

#if !HAVE_OPENSSL

    "internal/crypto/",

    "internal/debugger/",

#endif  // !HAVE_OPENSSL

    "internal/bootstrap/",

    "internal/per_context/",

    "internal/deps/",

    "internal/main/"

  module_categories_.can_be_required.emplace(

#if !HAVE_INSPECTOR

      "inspector",

      "internal/util/inspector",

#endif  // !HAVE_INSPECTOR

#if !NODE_USE_V8_PLATFORM || !defined(NODE_HAVE_I18N_SUPPORT)

      "trace_events",

#endif  // !NODE_USE_V8_PLATFORM || !defined(NODE_HAVE_I18N_SUPPORT)

#if !HAVE_OPENSSL

      "crypto",

      "crypto/promises",

      "https",

      "http2",

      "tls",

      "_tls_common",

      "_tls_wrap",

      "internal/tls/secure-pair",

      "internal/tls/parse-cert-string",

      "internal/tls/secure-context",

      "internal/http2/core",

      "internal/http2/compat",

      "internal/policy/manifest",

      "internal/process/policy",

      "internal/streams/lazy_transform",

#endif  // !HAVE_OPENSSL

      "sys",  // Deprecated.

      "wasi",  // Experimental.

      "internal/test/binding",

      "internal/v8_prof_polyfill",

      "internal/v8_prof_processor",

      }

      }

    }

  }

    }

  }

}

}

}

}

}

}

    const char* id) const {

    // The module has not been compiled before.

  }

}

    Local<Context> context,

    const char* id,

    NativeModuleLoader::Result* result) {

  std::vector<Local<String>> parameters = {

}

#ifdef NODE_BUILTIN_MODULES_PATH

static std::string OnDiskFileName(const char* id) {

  std::string filename = NODE_BUILTIN_MODULES_PATH;

  filename += "/";

  if (strncmp(id, "internal/deps", strlen("internal/deps")) == 0) {

    id += strlen("internal/");

  } else {

    filename += "lib/";

  }

  filename += id;

  filename += ".js";

  return filename;

}

#endif  // NODE_BUILTIN_MODULES_PATH

                                                               const char* id) {

#ifdef NODE_BUILTIN_MODULES_PATH

  if (strncmp(id, "embedder_main_", strlen("embedder_main_")) == 0) {

#endif  // NODE_BUILTIN_MODULES_PATH

    }

#ifdef NODE_BUILTIN_MODULES_PATH

  }

  std::string filename = OnDiskFileName(id);

  std::string contents;

  int r = ReadFileSync(&contents, filename.c_str());

  if (r != 0) {

    const std::string buf = SPrintF("Cannot read local builtin. %s: %s \"%s\"",

                                    uv_err_name(r),

                                    uv_strerror(r),

                                    filename);

    Local<String> message = OneByteString(isolate, buf.c_str());

    isolate->ThrowException(v8::Exception::Error(message));

    return MaybeLocal<String>();

  }

  return String::NewFromUtf8(

      isolate, contents.c_str(), v8::NewStringType::kNormal, contents.length());

#endif  // NODE_BUILTIN_MODULES_PATH

}

// Returns Local<Function> of the compiled module if return_code_cache

// is false (we are only compiling the function).

// Otherwise return a Local<Object> containing the cache.

    Local<Context> context,

    const char* id,

    std::vector<Local<String>>* parameters,

    NativeModuleLoader::Result* result) {

  Local<String> source;

  }

  Local<String> filename =

  {

    // Note: The lock here should not extend into the

    // `CompileFunctionInContext()` call below, because this function may

    // recurse if there is a syntax error during bootstrap (because the fatal

    // exception handler is invoked, which may load built-in modules).

      // Transfer ownership to ScriptCompiler::Source later.

    }

  }

                : ScriptCompiler::kEagerCompile;

  per_process::Debug(DebugCategory::CODE_CACHE,

                     "Compiling %s %s code cache\n",

                     id,

  MaybeLocal<Function> maybe_fun =

      ScriptCompiler::CompileFunctionInContext(context,

                                               &script_source,

                                               parameters->size(),

                                               parameters->data(),

                                               0,

                                               nullptr,

  // This could fail when there are early errors in the native modules,

  // e.g. the syntax errors

  Local<Function> fun;

    // In the case of early errors, v8 is already capable of

    // decorating the stack for us - note that we use CompileFunctionInContext

    // so there is no need to worry about wrappers.

  }

  // XXX(joyeecheung): this bookkeeping is not exactly accurate because

  // it only starts after the Environment is created, so the per_context.js

  // will never be in any of these two sets, but the two sets are only for

  // testing anyway.

                : Result::kWithoutCache;

                       "Code cache of %s (%s) %s\n",

                       id,

                               ScriptCompiler::CachedData::BufferNotOwned

                           : "BufferOwned",

                                                               : "is accepted");

  }

  // Generate new cache for next compilation

  std::unique_ptr<ScriptCompiler::CachedData> new_cached_data(

  {

    // TODO(joyeecheung): it's safer for each thread to have its own

    // copy of the code cache map.

    } else {

    }

  }

}

}  // namespace native_module

}  // namespace node