@kungfu-tech/libnode-win32-x64 0.0.0-bootstrap.0 → 22.22.3-kf.1

package/dist/node/include/node_stat_watcher.h

@@ -0,0 +1,73 @@
+// Copyright Joyent, Inc. and other Node contributors.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a
+// copy of this software and associated documentation files (the
+// "Software"), to deal in the Software without restriction, including
+// without limitation the rights to use, copy, modify, merge, publish,
+// distribute, sublicense, and/or sell copies of the Software, and to permit
+// persons to whom the Software is furnished to do so, subject to the
+// following conditions:
+//
+// The above copyright notice and this permission notice shall be included
+// in all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
+// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN
+// NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
+// DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+// OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE
+// USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+#ifndef SRC_NODE_STAT_WATCHER_H_
+#define SRC_NODE_STAT_WATCHER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node.h"
+#include "handle_wrap.h"
+#include "uv.h"
+#include "v8.h"
+
+namespace node {
+namespace fs {
+class BindingData;
+}
+
+class Environment;
+class ExternalReferenceRegistry;
+
+class StatWatcher : public HandleWrap {
+ public:
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> ctor);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+ protected:
+  StatWatcher(fs::BindingData* binding_data,
+              v8::Local<v8::Object> wrap,
+              bool use_bigint);
+
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(StatWatcher)
+  SET_SELF_SIZE(StatWatcher)
+
+ private:
+  static void Callback(uv_fs_poll_t* handle,
+                       int status,
+                       const uv_stat_t* prev,
+                       const uv_stat_t* curr);
+
+  uv_fs_poll_t watcher_;
+  const bool use_bigint_;
+  BaseObjectPtr<fs::BindingData> binding_data_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_STAT_WATCHER_H_

package/dist/node/include/node_task_runner.h

@@ -0,0 +1,92 @@
+#ifndef SRC_NODE_TASK_RUNNER_H_
+#define SRC_NODE_TASK_RUNNER_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node_internals.h"
+#include "simdjson.h"
+#include "spawn_sync.h"
+#include "uv.h"
+
+#include <filesystem>
+#include <optional>
+#include <string_view>
+#include <tuple>
+
+namespace node::task_runner {
+
+using PositionalArgs = std::vector<std::string_view>;
+
+// ProcessRunner is the class responsible for running a process.
+// A class instance is created for each process to be run.
+// The class is responsible for spawning the process and handling its exit.
+// The class also handles the environment variables and arguments.
+class ProcessRunner {
+ public:
+  ProcessRunner(std::shared_ptr<InitializationResultImpl> result,
+                const std::filesystem::path& package_json_path,
+                std::string_view script_name,
+                std::string_view command,
+                std::string_view path_env_var,
+                const PositionalArgs& positional_args);
+  void Run();
+  static void ExitCallback(uv_process_t* req,
+                           int64_t exit_status,
+                           int term_signal);
+
+ private:
+  uv_loop_t* loop_ = uv_default_loop();
+  uv_process_t process_{};
+  uv_process_options_t options_{};
+  uv_stdio_container_t child_stdio_[3]{};
+  std::shared_ptr<InitializationResultImpl> init_result_;
+  std::vector<std::string> command_args_{};
+  std::vector<std::string> env_vars_{};
+  std::unique_ptr<char* []> env_ {};  // memory for options_.env
+  std::unique_ptr<char* []> arg_ {};  // memory for options_.args
+  std::string cwd_;
+
+  // OnExit is the callback function that is called when the process exits.
+  void OnExit(int64_t exit_status, int term_signal);
+  void SetEnvironmentVariables();
+
+#ifdef _WIN32
+  std::string file_ = "cmd.exe";
+#else
+  std::string file_ = "/bin/sh";
+#endif  // _WIN32
+
+  // Represents the absolute path to the package.json file.
+  std::filesystem::path package_json_path_;
+  // Represents the name of the script that is being run.
+  std::string script_name_;
+  // Represents PATH environment variable that contains
+  // all subdirectory paths appended with node_modules/.bin suffix.
+  std::string path_env_var_;
+};
+
+// This function traverses up to the root directory.
+// While traversing up, if it finds a package.json file, it reads its content.
+// If it cannot find a package.json file, it returns std::nullopt.
+// Otherwise, it returns a tuple of:
+// - the path to the package.json file
+// - package.json file content
+// - `path_env_var` variable
+//
+// For example, on POSIX, it returns the following for `path_env_var`,
+// if the current directory is `/anonrig`:
+// `/anonrig/node_modules/.bin:/node_modules/.bin`
+std::optional<std::tuple<std::filesystem::path, std::string, std::string>>
+FindPackageJson(const std::filesystem::path& cwd);
+
+void RunTask(const std::shared_ptr<InitializationResultImpl>& result,
+             std::string_view command_id,
+             const PositionalArgs& positional_args);
+PositionalArgs GetPositionalArgs(const std::vector<std::string>& args);
+std::string EscapeShell(std::string_view command);
+
+}  // namespace node::task_runner
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_TASK_RUNNER_H_

package/dist/node/include/node_threadsafe_cow-inl.h

@@ -0,0 +1,54 @@
+#ifndef SRC_NODE_THREADSAFE_COW_INL_H_
+#define SRC_NODE_THREADSAFE_COW_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+namespace node {
+
+template <typename T>
+T* CopyOnWrite<T>::write() {
+  if (data_.use_count() > 1l) {
+    data_ = std::make_shared<T>(*data_);
+  }
+  return data_.get();
+}
+
+template <typename T>
+ThreadsafeCopyOnWrite<T>::Read::Read(const ThreadsafeCopyOnWrite<T>* cow)
+    : cow_(cow), lock_(cow->impl_->mutex) {}
+
+template <typename T>
+const T& ThreadsafeCopyOnWrite<T>::Read::operator*() const {
+  return cow_->impl_->data;
+}
+
+template <typename T>
+const T* ThreadsafeCopyOnWrite<T>::Read::operator->() const {
+  return &cow_->impl_->data;
+}
+
+template <typename T>
+ThreadsafeCopyOnWrite<T>::Write::Write(ThreadsafeCopyOnWrite<T>* cow)
+    : cow_(cow), impl_(cow->impl_.write()), lock_(impl_->mutex) {}
+
+template <typename T>
+T& ThreadsafeCopyOnWrite<T>::Write::operator*() {
+  return impl_->data;
+}
+
+template <typename T>
+T* ThreadsafeCopyOnWrite<T>::Write::operator->() {
+  return &impl_->data;
+}
+
+template <typename T>
+ThreadsafeCopyOnWrite<T>::Impl::Impl(const Impl& other) {
+  RwLock::ScopedReadLock lock(other.mutex);
+  data = other.data;
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_THREADSAFE_COW_INL_H_

package/dist/node/include/node_threadsafe_cow.h

@@ -0,0 +1,105 @@
+#ifndef SRC_NODE_THREADSAFE_COW_H_
+#define SRC_NODE_THREADSAFE_COW_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "util.h"
+#include "uv.h"
+
+#include <memory>   // std::shared_ptr<T>
+#include <utility>  // std::forward<T>
+
+namespace node {
+
+// Copy-on-write utility. Not threadsafe, i.e. there is no synchronization
+// of the copy operation with other operations.
+template <typename T>
+class CopyOnWrite final {
+ public:
+  template <typename... Args>
+  explicit CopyOnWrite(Args&&... args)
+      : data_(std::make_shared<T>(std::forward<Args>(args)...)) {}
+
+  CopyOnWrite(const CopyOnWrite<T>& other) = default;
+  CopyOnWrite& operator=(const CopyOnWrite<T>& other) = default;
+  CopyOnWrite(CopyOnWrite<T>&& other) = default;
+  CopyOnWrite& operator=(CopyOnWrite<T>&& other) = default;
+
+  const T* read() const { return data_.get(); }
+  T* write();
+
+  const T& operator*() const { return *read(); }
+  const T* operator->() const { return read(); }
+
+ private:
+  std::shared_ptr<T> data_;
+};
+
+// Threadsafe copy-on-write utility. Consumers need to use the Read and
+// Write helpers to access the target data structure.
+template <typename T>
+class ThreadsafeCopyOnWrite final {
+ private:
+  // Define this early since some of the public members depend on it
+  // and some compilers need it to be defined first in that case.
+  struct Impl {
+    explicit Impl(const T& data) : data(data) {}
+    explicit Impl(T&& data) : data(std::move(data)) {}
+
+    Impl(const Impl& other);
+    Impl& operator=(const Impl& other) = delete;
+    Impl(Impl&& other) = delete;
+    Impl& operator=(Impl&& other) = delete;
+
+    RwLock mutex;
+    T data;
+  };
+
+ public:
+  template <typename... Args>
+  ThreadsafeCopyOnWrite(Args&&... args)
+      : impl_(T(std::forward<Args>(args)...)) {}
+
+  ThreadsafeCopyOnWrite(const ThreadsafeCopyOnWrite<T>& other) = default;
+  ThreadsafeCopyOnWrite& operator=(const ThreadsafeCopyOnWrite<T>& other) =
+      default;
+  ThreadsafeCopyOnWrite(ThreadsafeCopyOnWrite<T>&& other) = default;
+  ThreadsafeCopyOnWrite& operator=(ThreadsafeCopyOnWrite<T>&& other) = default;
+
+  class Read {
+   public:
+    explicit Read(const ThreadsafeCopyOnWrite<T>* cow);
+
+    const T& operator*() const;
+    const T* operator->() const;
+
+   private:
+    const ThreadsafeCopyOnWrite<T>* cow_;
+    RwLock::ScopedReadLock lock_;
+  };
+
+  class Write {
+   public:
+    explicit Write(ThreadsafeCopyOnWrite<T>* cow);
+
+    T& operator*();
+    T* operator->();
+
+   private:
+    ThreadsafeCopyOnWrite<T>* cow_;
+    typename ThreadsafeCopyOnWrite<T>::Impl* impl_;
+    RwLock::ScopedLock lock_;
+  };
+
+  Read read() const { return Read(this); }
+  Write write() { return Write(this); }
+
+ private:
+  CopyOnWrite<Impl> impl_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_THREADSAFE_COW_H_

package/dist/node/include/node_union_bytes.h

@@ -0,0 +1,81 @@
+
+#ifndef SRC_NODE_UNION_BYTES_H_
+#define SRC_NODE_UNION_BYTES_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "v8.h"
+
+namespace node {
+
+// An external resource intended to be used with static lifetime.
+template <typename Char, typename IChar, typename Base>
+class StaticExternalByteResource : public Base {
+  static_assert(sizeof(IChar) == sizeof(Char),
+                "incompatible interface and internal pointers");
+
+ public:
+  explicit StaticExternalByteResource(const Char* data,
+                                      size_t length,
+                                      std::shared_ptr<void> owning_ptr)
+      : data_(data), length_(length), owning_ptr_(owning_ptr) {}
+
+  const IChar* data() const override {
+    return reinterpret_cast<const IChar*>(data_);
+  }
+  size_t length() const override { return length_; }
+
+  void Dispose() override {
+    // We ignore Dispose calls from V8, even if we "own" a resource via
+    // owning_ptr_. All instantiations of this class are static or owned by a
+    // static map, and will be destructed when static variables are destructed.
+  }
+
+  StaticExternalByteResource(const StaticExternalByteResource&) = delete;
+  StaticExternalByteResource& operator=(const StaticExternalByteResource&) =
+      delete;
+
+ private:
+  const Char* data_;
+  const size_t length_;
+  std::shared_ptr<void> owning_ptr_;
+};
+
+using StaticExternalOneByteResource =
+    StaticExternalByteResource<uint8_t,
+                               char,
+                               v8::String::ExternalOneByteStringResource>;
+using StaticExternalTwoByteResource =
+    StaticExternalByteResource<uint16_t,
+                               uint16_t,
+                               v8::String::ExternalStringResource>;
+
+// Similar to a v8::String, but it's independent from Isolates
+// and can be materialized in Isolates as external Strings
+// via ToStringChecked.
+class UnionBytes {
+ public:
+  explicit UnionBytes(StaticExternalOneByteResource* one_byte_resource)
+      : one_byte_resource_(one_byte_resource), two_byte_resource_(nullptr) {}
+  explicit UnionBytes(StaticExternalTwoByteResource* two_byte_resource)
+      : one_byte_resource_(nullptr), two_byte_resource_(two_byte_resource) {}
+
+  UnionBytes(const UnionBytes&) = default;
+  UnionBytes& operator=(const UnionBytes&) = default;
+  UnionBytes(UnionBytes&&) = default;
+  UnionBytes& operator=(UnionBytes&&) = default;
+
+  bool is_one_byte() const { return one_byte_resource_ != nullptr; }
+
+  v8::Local<v8::String> ToStringChecked(v8::Isolate* isolate) const;
+
+ private:
+  StaticExternalOneByteResource* one_byte_resource_;
+  StaticExternalTwoByteResource* two_byte_resource_;
+};
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_UNION_BYTES_H_

package/dist/node/include/node_url.h

@@ -0,0 +1,96 @@
+#ifndef SRC_NODE_URL_H_
+#define SRC_NODE_URL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <cinttypes>
+#include "ada.h"
+#include "aliased_buffer.h"
+#include "node.h"
+#include "node_snapshotable.h"
+#include "util.h"
+#include "v8-fast-api-calls.h"
+#include "v8.h"
+
+#include <optional>
+#include <string>
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace url {
+
+enum url_update_action {
+  kProtocol = 0,
+  kHost = 1,
+  kHostname = 2,
+  kPort = 3,
+  kUsername = 4,
+  kPassword = 5,
+  kPathname = 6,
+  kSearch = 7,
+  kHash = 8,
+  kHref = 9,
+};
+
+class BindingData : public SnapshotableObject {
+ public:
+  BindingData(Realm* realm, v8::Local<v8::Object> obj);
+
+  using InternalFieldInfo = InternalFieldInfoBase;
+
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(url_binding_data)
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void DomainToASCII(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void DomainToUnicode(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void CanParse(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static bool FastCanParse(v8::Local<v8::Value> receiver,
+                           const v8::FastOneByteString& input);
+  static bool FastCanParseWithBase(v8::Local<v8::Value> receiver,
+                                   const v8::FastOneByteString& input,
+                                   const v8::FastOneByteString& base);
+
+  static void Format(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetOrigin(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Parse(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void PathToFileURL(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Update(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  static void CreatePerIsolateProperties(IsolateData* isolate_data,
+                                         v8::Local<v8::ObjectTemplate> ctor);
+  static void CreatePerContextProperties(v8::Local<v8::Object> target,
+                                         v8::Local<v8::Value> unused,
+                                         v8::Local<v8::Context> context,
+                                         void* priv);
+  static void RegisterExternalReferences(ExternalReferenceRegistry* registry);
+
+ private:
+  static constexpr size_t kURLComponentsLength = 9;
+  AliasedUint32Array url_components_buffer_;
+
+  void UpdateComponents(const ada::url_components& components,
+                        const ada::scheme::type type);
+
+  static v8::CFunction fast_can_parse_methods_[];
+};
+
+void ThrowInvalidURL(Environment* env,
+                     std::string_view input,
+                     std::optional<std::string> base);
+std::string FromFilePath(std::string_view file_path);
+std::optional<std::string> FileURLToPath(Environment* env,
+                                         const ada::url_aggregator& file_url);
+
+}  // namespace url
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_URL_H_

package/dist/node/include/node_v8.h

@@ -0,0 +1,77 @@
+#ifndef SRC_NODE_V8_H_
+#define SRC_NODE_V8_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <sstream>
+#include "aliased_buffer.h"
+#include "base_object.h"
+#include "json_utils.h"
+#include "node_snapshotable.h"
+#include "util.h"
+#include "v8.h"
+
+namespace node {
+class Environment;
+struct InternalFieldInfoBase;
+
+namespace v8_utils {
+class BindingData : public SnapshotableObject {
+ public:
+  struct InternalFieldInfo : public node::InternalFieldInfoBase {
+    AliasedBufferIndex heap_statistics_buffer;
+    AliasedBufferIndex heap_space_statistics_buffer;
+    AliasedBufferIndex heap_code_statistics_buffer;
+  };
+  BindingData(Realm* realm,
+              v8::Local<v8::Object> obj,
+              InternalFieldInfo* info = nullptr);
+
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(v8_binding_data)
+
+  AliasedFloat64Array heap_statistics_buffer;
+  AliasedFloat64Array heap_space_statistics_buffer;
+  AliasedFloat64Array heap_code_statistics_buffer;
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+ private:
+  InternalFieldInfo* internal_field_info_ = nullptr;
+};
+
+class GCProfiler : public BaseObject {
+ public:
+  enum class GCProfilerState { kInitialized, kStarted, kStopped };
+  GCProfiler(Environment* env, v8::Local<v8::Object> object);
+  inline ~GCProfiler() override;
+  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Start(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void Stop(const v8::FunctionCallbackInfo<v8::Value>& args);
+
+  JSONWriter* writer();
+
+  std::ostringstream* out_stream();
+
+  SET_NO_MEMORY_INFO()
+  SET_MEMORY_INFO_NAME(GCProfiler)
+  SET_SELF_SIZE(GCProfiler)
+
+  uint64_t start_time;
+  uint8_t current_gc_type;
+  GCProfilerState state;
+
+ private:
+  std::ostringstream out_stream_;
+  JSONWriter writer_;
+};
+
+}  // namespace v8_utils
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_V8_H_