@encharm/cws 4.3.0 → 4.4.0

package/src/headers/20/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/src/headers/20/node_url.h

@@ -0,0 +1,92 @@
+#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 <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 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_[];
+  static void ThrowInvalidURL(Environment* env,
+                              std::string_view input,
+                              std::optional<std::string> base);
+};
+
+std::string FromFilePath(const std::string_view file_path);
+
+}  // namespace url
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_URL_H_

package/src/headers/20/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_

package/src/headers/20/node_v8_platform-inl.h

@@ -0,0 +1,205 @@
+#ifndef SRC_NODE_V8_PLATFORM_INL_H_
+#define SRC_NODE_V8_PLATFORM_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <memory>
+#include <string_view>
+
+#include "env-inl.h"
+#include "node.h"
+#include "node_metadata.h"
+#include "node_platform.h"
+#include "node_options.h"
+#include "tracing/node_trace_writer.h"
+#include "tracing/trace_event.h"
+#include "tracing/traced_value.h"
+#include "util.h"
+
+namespace node {
+
+// Ensures that __metadata trace events are only emitted
+// when tracing is enabled.
+class NodeTraceStateObserver
+    : public v8::TracingController::TraceStateObserver {
+ public:
+  inline void OnTraceEnabled() override {
+    std::string title = GetProcessTitle("");
+    if (!title.empty()) {
+      // Only emit the metadata event if the title can be retrieved
+      // successfully. Ignore it otherwise.
+      TRACE_EVENT_METADATA1(
+          "__metadata", "process_name", "name", TRACE_STR_COPY(title.c_str()));
+    }
+    TRACE_EVENT_METADATA1("__metadata",
+                          "version",
+                          "node",
+                          per_process::metadata.versions.node.c_str());
+    TRACE_EVENT_METADATA1(
+        "__metadata", "thread_name", "name", "JavaScriptMainThread");
+
+    auto trace_process = tracing::TracedValue::Create();
+    trace_process->BeginDictionary("versions");
+
+#define V(key)                                                                 \
+  trace_process->SetString(#key, per_process::metadata.versions.key.c_str());
+
+    NODE_VERSIONS_KEYS(V)
+#undef V
+
+    trace_process->EndDictionary();
+
+    trace_process->SetString("arch", per_process::metadata.arch.c_str());
+    trace_process->SetString("platform",
+                             per_process::metadata.platform.c_str());
+
+    trace_process->BeginDictionary("release");
+    trace_process->SetString("name",
+                             per_process::metadata.release.name.c_str());
+#if NODE_VERSION_IS_LTS
+    trace_process->SetString("lts", per_process::metadata.release.lts.c_str());
+#endif
+    trace_process->EndDictionary();
+    TRACE_EVENT_METADATA1(
+        "__metadata", "node", "process", std::move(trace_process));
+
+    // This only runs the first time tracing is enabled
+    controller_->RemoveTraceStateObserver(this);
+  }
+
+  inline void OnTraceDisabled() override {
+    // Do nothing here. This should never be called because the
+    // observer removes itself when OnTraceEnabled() is called.
+    UNREACHABLE();
+  }
+
+  explicit NodeTraceStateObserver(v8::TracingController* controller)
+      : controller_(controller) {}
+  ~NodeTraceStateObserver() override = default;
+
+ private:
+  v8::TracingController* controller_;
+};
+
+struct V8Platform {
+  bool initialized_ = false;
+
+#if NODE_USE_V8_PLATFORM
+  inline void Initialize(int thread_pool_size) {
+    CHECK(!initialized_);
+    initialized_ = true;
+    tracing_agent_ = std::make_unique<tracing::Agent>();
+    node::tracing::TraceEventHelper::SetAgent(tracing_agent_.get());
+    node::tracing::TracingController* controller =
+        tracing_agent_->GetTracingController();
+    trace_state_observer_ =
+        std::make_unique<NodeTraceStateObserver>(controller);
+    controller->AddTraceStateObserver(trace_state_observer_.get());
+    tracing_file_writer_ = tracing_agent_->DefaultHandle();
+    // Only start the tracing agent if we enabled any tracing categories.
+    if (!per_process::cli_options->trace_event_categories.empty()) {
+      StartTracingAgent();
+    }
+    // Tracing must be initialized before platform threads are created.
+    platform_ = new NodePlatform(thread_pool_size, controller);
+    v8::V8::InitializePlatform(platform_);
+  }
+  // Make sure V8Platform don not call into Libuv threadpool,
+  // see DefaultProcessExitHandlerInternal in environment.cc
+  inline void Dispose() {
+    if (!initialized_)
+      return;
+    initialized_ = false;
+    node::tracing::TraceEventHelper::SetAgent(nullptr);
+    StopTracingAgent();
+    platform_->Shutdown();
+    delete platform_;
+    platform_ = nullptr;
+    // Destroy tracing after the platform (and platform threads) have been
+    // stopped.
+    tracing_agent_.reset(nullptr);
+    // The observer remove itself in OnTraceEnabled
+    trace_state_observer_.reset(nullptr);
+  }
+
+  inline void DrainVMTasks(v8::Isolate* isolate) {
+    platform_->DrainTasks(isolate);
+  }
+
+  inline void StartTracingAgent() {
+    constexpr auto convert_to_set =
+        [](std::vector<std::string_view> categories) -> std::set<std::string> {
+      std::set<std::string> out;
+      for (const auto& s : categories) {
+        out.emplace(s);
+      }
+      return out;
+    };
+    // Attach a new NodeTraceWriter only if this function hasn't been called
+    // before.
+    if (tracing_file_writer_.IsDefaultHandle()) {
+      using std::string_view_literals::operator""sv;
+      const std::vector<std::string_view> categories =
+          SplitString(per_process::cli_options->trace_event_categories, ","sv);
+
+      tracing_file_writer_ = tracing_agent_->AddClient(
+          convert_to_set(categories),
+          std::unique_ptr<tracing::AsyncTraceWriter>(
+              new tracing::NodeTraceWriter(
+                  per_process::cli_options->trace_event_file_pattern)),
+          tracing::Agent::kUseDefaultCategories);
+    }
+  }
+
+  inline void StopTracingAgent() { tracing_file_writer_.reset(); }
+
+  inline tracing::AgentWriterHandle* GetTracingAgentWriter() {
+    return &tracing_file_writer_;
+  }
+
+  inline NodePlatform* Platform() { return platform_; }
+
+  std::unique_ptr<NodeTraceStateObserver> trace_state_observer_;
+  std::unique_ptr<tracing::Agent> tracing_agent_;
+  tracing::AgentWriterHandle tracing_file_writer_;
+  NodePlatform* platform_;
+#else   // !NODE_USE_V8_PLATFORM
+  inline void Initialize(int thread_pool_size) {}
+  inline void Dispose() {}
+  inline void DrainVMTasks(v8::Isolate* isolate) {}
+  inline void StartTracingAgent() {
+    if (!per_process::cli_options->trace_event_categories.empty()) {
+      fprintf(stderr,
+              "Node compiled with NODE_USE_V8_PLATFORM=0, "
+              "so event tracing is not available.\n");
+    }
+  }
+  inline void StopTracingAgent() {}
+
+  inline tracing::AgentWriterHandle* GetTracingAgentWriter() { return nullptr; }
+
+  inline NodePlatform* Platform() { return nullptr; }
+#endif  // !NODE_USE_V8_PLATFORM
+};
+
+namespace per_process {
+extern struct V8Platform v8_platform;
+}
+
+inline void StartTracingAgent() {
+  return per_process::v8_platform.StartTracingAgent();
+}
+
+inline tracing::AgentWriterHandle* GetTracingAgentWriter() {
+  return per_process::v8_platform.GetTracingAgentWriter();
+}
+
+inline void DisposePlatform() {
+  per_process::v8_platform.Dispose();
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_V8_PLATFORM_INL_H_

package/src/headers/20/node_version.h

@@ -0,0 +1,109 @@
+// 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_VERSION_H_
+#define SRC_NODE_VERSION_H_
+
+#define NODE_MAJOR_VERSION 20
+#define NODE_MINOR_VERSION 9
+#define NODE_PATCH_VERSION 0
+
+#define NODE_VERSION_IS_LTS 1
+#define NODE_VERSION_LTS_CODENAME "Iron"
+
+#define NODE_VERSION_IS_RELEASE 1
+
+#ifndef NODE_STRINGIFY
+#define NODE_STRINGIFY(n) NODE_STRINGIFY_HELPER(n)
+#define NODE_STRINGIFY_HELPER(n) #n
+#endif
+
+#ifndef NODE_RELEASE
+#define NODE_RELEASE "node"
+#endif
+
+#ifndef NODE_TAG
+# if NODE_VERSION_IS_RELEASE
+#  define NODE_TAG ""
+# else
+#  define NODE_TAG "-pre"
+# endif
+#else
+// NODE_TAG is passed without quotes when rc.exe is run from msbuild
+# define NODE_EXE_VERSION NODE_STRINGIFY(NODE_MAJOR_VERSION) "." \
+                          NODE_STRINGIFY(NODE_MINOR_VERSION) "." \
+                          NODE_STRINGIFY(NODE_PATCH_VERSION)     \
+                          NODE_STRINGIFY(NODE_TAG)
+#endif
+
+# define NODE_VERSION_STRING  NODE_STRINGIFY(NODE_MAJOR_VERSION) "." \
+                              NODE_STRINGIFY(NODE_MINOR_VERSION) "." \
+                              NODE_STRINGIFY(NODE_PATCH_VERSION)     \
+                              NODE_TAG
+#ifndef NODE_EXE_VERSION
+# define NODE_EXE_VERSION NODE_VERSION_STRING
+#endif
+
+#define NODE_VERSION "v" NODE_VERSION_STRING
+
+
+#define NODE_VERSION_AT_LEAST(major, minor, patch) \
+  (( (major) < NODE_MAJOR_VERSION) \
+  || ((major) == NODE_MAJOR_VERSION && (minor) < NODE_MINOR_VERSION) \
+  || ((major) == NODE_MAJOR_VERSION && \
+      (minor) == NODE_MINOR_VERSION && (patch) <= NODE_PATCH_VERSION))
+
+/**
+ * Node.js will refuse to load modules that weren't compiled against its own
+ * module ABI number, exposed as the process.versions.modules property.
+ *
+ * Node.js will refuse to load modules with a non-matching ABI version. The
+ * version number here should be changed whenever an ABI-incompatible API change
+ * is made in the C++ side, including in V8 or other dependencies.
+ *
+ * Node.js will not change the module version during a Major release line
+ * We will, at times update the version of V8 shipped in the release line
+ * if it can be made ABI compatible with the previous version.
+ *
+ * Embedders building Node.js can define NODE_EMBEDDER_MODULE_VERSION to
+ * override the default value of NODE_MODULE_VERSION.
+ *
+ * The registry of used NODE_MODULE_VERSION numbers is located at
+ *   https://github.com/nodejs/node/blob/HEAD/doc/abi_version_registry.json
+ * Extenders, embedders and other consumers of Node.js that require ABI
+ * version matching should open a pull request to reserve a number in this
+ * registry.
+ */
+#if defined(NODE_EMBEDDER_MODULE_VERSION)
+#define NODE_MODULE_VERSION NODE_EMBEDDER_MODULE_VERSION
+#else
+#define NODE_MODULE_VERSION 115
+#endif
+
+// The NAPI_VERSION provided by this version of the runtime. This is the version
+// which the Node binary being built supports.
+#define NAPI_VERSION 9
+
+// Node API modules use NAPI_VERSION 8 by default if it is not explicitly
+// specified. It must be always 8.
+#define NODE_API_DEFAULT_MODULE_API_VERSION 8
+
+#endif  // SRC_NODE_VERSION_H_