@encharm/cws 4.4.1 → 4.5.1

package/src/headers/16/node_union_bytes.h

@@ -1,103 +0,0 @@
-
-#ifndef SRC_NODE_UNION_BYTES_H_
-#define SRC_NODE_UNION_BYTES_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-// A union of const uint8_t* or const uint16_t* data that can be
-// turned into external v8::String when given an isolate.
-
-#include "v8.h"
-
-namespace node {
-
-class NonOwningExternalOneByteResource
-    : public v8::String::ExternalOneByteStringResource {
- public:
-  explicit NonOwningExternalOneByteResource(const uint8_t* data, size_t length)
-      : data_(data), length_(length) {}
-  ~NonOwningExternalOneByteResource() override = default;
-
-  const char* data() const override {
-    return reinterpret_cast<const char*>(data_);
-  }
-  size_t length() const override { return length_; }
-
-  NonOwningExternalOneByteResource(const NonOwningExternalOneByteResource&) =
-      delete;
-  NonOwningExternalOneByteResource& operator=(
-      const NonOwningExternalOneByteResource&) = delete;
-
- private:
-  const uint8_t* data_;
-  size_t length_;
-};
-
-class NonOwningExternalTwoByteResource
-    : public v8::String::ExternalStringResource {
- public:
-  explicit NonOwningExternalTwoByteResource(const uint16_t* data, size_t length)
-      : data_(data), length_(length) {}
-  ~NonOwningExternalTwoByteResource() override = default;
-
-  const uint16_t* data() const override { return data_; }
-  size_t length() const override { return length_; }
-
-  NonOwningExternalTwoByteResource(const NonOwningExternalTwoByteResource&) =
-      delete;
-  NonOwningExternalTwoByteResource& operator=(
-      const NonOwningExternalTwoByteResource&) = delete;
-
- private:
-  const uint16_t* data_;
-  size_t length_;
-};
-
-// Similar to a v8::String, but it's independent from Isolates
-// and can be materialized in Isolates as external Strings
-// via ToStringChecked. The data pointers are owned by the caller.
-class UnionBytes {
- public:
-  UnionBytes(const uint16_t* data, size_t length)
-      : one_bytes_(nullptr), two_bytes_(data), length_(length) {}
-  UnionBytes(const uint8_t* data, size_t length)
-      : one_bytes_(data), two_bytes_(nullptr), length_(length) {}
-
-  UnionBytes(const UnionBytes&) = default;
-  UnionBytes& operator=(const UnionBytes&) = default;
-  UnionBytes(UnionBytes&&) = default;
-  UnionBytes& operator=(UnionBytes&&) = default;
-
-  bool is_one_byte() const { return one_bytes_ != nullptr; }
-  const uint16_t* two_bytes_data() const {
-    CHECK_NOT_NULL(two_bytes_);
-    return two_bytes_;
-  }
-  const uint8_t* one_bytes_data() const {
-    CHECK_NOT_NULL(one_bytes_);
-    return one_bytes_;
-  }
-  v8::Local<v8::String> ToStringChecked(v8::Isolate* isolate) const {
-    if (is_one_byte()) {
-      NonOwningExternalOneByteResource* source =
-          new NonOwningExternalOneByteResource(one_bytes_data(), length_);
-      return v8::String::NewExternalOneByte(isolate, source).ToLocalChecked();
-    } else {
-      NonOwningExternalTwoByteResource* source =
-          new NonOwningExternalTwoByteResource(two_bytes_data(), length_);
-      return v8::String::NewExternalTwoByte(isolate, source).ToLocalChecked();
-    }
-  }
-  size_t length() { return length_; }
-
- private:
-  const uint8_t* one_bytes_;
-  const uint16_t* two_bytes_;
-  size_t length_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_UNION_BYTES_H_

package/src/headers/16/node_url.h

@@ -1,205 +0,0 @@
-#ifndef SRC_NODE_URL_H_
-#define SRC_NODE_URL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node.h"
-
-#include <string>
-
-namespace node {
-namespace url {
-
-#define PARSESTATES(XX)                                                       \
-  XX(kSchemeStart)                                                            \
-  XX(kScheme)                                                                 \
-  XX(kNoScheme)                                                               \
-  XX(kSpecialRelativeOrAuthority)                                             \
-  XX(kPathOrAuthority)                                                        \
-  XX(kRelative)                                                               \
-  XX(kRelativeSlash)                                                          \
-  XX(kSpecialAuthoritySlashes)                                                \
-  XX(kSpecialAuthorityIgnoreSlashes)                                          \
-  XX(kAuthority)                                                              \
-  XX(kHost)                                                                   \
-  XX(kHostname)                                                               \
-  XX(kPort)                                                                   \
-  XX(kFile)                                                                   \
-  XX(kFileSlash)                                                              \
-  XX(kFileHost)                                                               \
-  XX(kPathStart)                                                              \
-  XX(kPath)                                                                   \
-  XX(kCannotBeBase)                                                           \
-  XX(kQuery)                                                                  \
-  XX(kFragment)
-
-#define FLAGS(XX)                                                             \
-  XX(URL_FLAGS_NONE, 0)                                                       \
-  XX(URL_FLAGS_FAILED, 0x01)                                                  \
-  XX(URL_FLAGS_CANNOT_BE_BASE, 0x02)                                          \
-  XX(URL_FLAGS_INVALID_PARSE_STATE, 0x04)                                     \
-  XX(URL_FLAGS_TERMINATED, 0x08)                                              \
-  XX(URL_FLAGS_SPECIAL, 0x10)                                                 \
-  XX(URL_FLAGS_HAS_USERNAME, 0x20)                                            \
-  XX(URL_FLAGS_HAS_PASSWORD, 0x40)                                            \
-  XX(URL_FLAGS_HAS_HOST, 0x80)                                                \
-  XX(URL_FLAGS_HAS_PATH, 0x100)                                               \
-  XX(URL_FLAGS_HAS_QUERY, 0x200)                                              \
-  XX(URL_FLAGS_HAS_FRAGMENT, 0x400)                                           \
-  XX(URL_FLAGS_IS_DEFAULT_SCHEME_PORT, 0x800)                                 \
-
-enum url_parse_state {
-  kUnknownState = -1,
-#define XX(name) name,
-  PARSESTATES(XX)
-#undef XX
-};
-
-enum url_flags {
-#define XX(name, val) name = val,
-  FLAGS(XX)
-#undef XX
-};
-
-struct url_data {
-  int32_t flags = URL_FLAGS_NONE;
-  int port = -1;
-  std::string scheme;
-  std::string username;
-  std::string password;
-  std::string host;
-  std::string query;
-  std::string fragment;
-  std::vector<std::string> path;
-  std::string href;
-};
-
-namespace table_data {
-extern const char hex[1024];
-extern const uint8_t C0_CONTROL_ENCODE_SET[32];
-extern const uint8_t FRAGMENT_ENCODE_SET[32];
-extern const uint8_t PATH_ENCODE_SET[32];
-extern const uint8_t USERINFO_ENCODE_SET[32];
-extern const uint8_t QUERY_ENCODE_SET_NONSPECIAL[32];
-extern const uint8_t QUERY_ENCODE_SET_SPECIAL[32];
-}
-
-class URL {
- public:
-  static void Parse(const char* input,
-                    size_t len,
-                    enum url_parse_state state_override,
-                    struct url_data* url,
-                    bool has_url,
-                    const struct url_data* base,
-                    bool has_base);
-
-  static std::string SerializeURL(const struct url_data* url, bool exclude);
-
-  URL(const char* input, const size_t len) {
-    Parse(input, len, kUnknownState, &context_, false, nullptr, false);
-  }
-
-  URL(const char* input, const size_t len, const URL* base) {
-    if (base != nullptr)
-      Parse(input, len, kUnknownState,
-            &context_, false,
-            &(base->context_), true);
-    else
-      Parse(input, len, kUnknownState, &context_, false, nullptr, false);
-  }
-
-  URL(const char* input, const size_t len,
-      const char* base, const size_t baselen) {
-    if (base != nullptr && baselen > 0) {
-      URL _base(base, baselen);
-      Parse(input, len, kUnknownState,
-            &context_, false,
-            &(_base.context_), true);
-    } else {
-      Parse(input, len, kUnknownState, &context_, false, nullptr, false);
-    }
-  }
-
-  explicit URL(const std::string& input) :
-      URL(input.c_str(), input.length()) {}
-
-  URL(const std::string& input, const URL* base) :
-      URL(input.c_str(), input.length(), base) {}
-
-  URL(const std::string& input, const URL& base) :
-      URL(input.c_str(), input.length(), &base) {}
-
-  URL(const std::string& input, const std::string& base) :
-      URL(input.c_str(), input.length(), base.c_str(), base.length()) {}
-
-  int32_t flags() const {
-    return context_.flags;
-  }
-
-  int port() const {
-    return context_.port;
-  }
-
-  const std::string& protocol() const {
-    return context_.scheme;
-  }
-
-  const std::string& username() const {
-    return context_.username;
-  }
-
-  const std::string& password() const {
-    return context_.password;
-  }
-
-  const std::string& host() const {
-    return context_.host;
-  }
-
-  const std::string& query() const {
-    return context_.query;
-  }
-
-  const std::string& fragment() const {
-    return context_.fragment;
-  }
-
-  std::string path() const {
-    std::string ret;
-    for (const std::string& element : context_.path) {
-      ret += '/' + element;
-    }
-    return ret;
-  }
-
-  std::string href() const {
-    return SerializeURL(&context_, false);
-  }
-
-  // Get the path of the file: URL in a format consumable by native file system
-  // APIs. Returns an empty string if something went wrong.
-  std::string ToFilePath() const;
-  // Get the file URL from native file system path.
-  static URL FromFilePath(const std::string& file_path);
-
-  v8::MaybeLocal<v8::Value> ToObject(Environment* env) const;
-
-  URL(const URL&) = default;
-  URL& operator=(const URL&) = default;
-  URL(URL&&) = default;
-  URL& operator=(URL&&) = default;
-
-  URL() : URL("") {}
-
- private:
-  struct url_data context_;
-};
-
-}  // namespace url
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_URL_H_

package/src/headers/16/node_v8.h

@@ -1,41 +0,0 @@
-#ifndef SRC_NODE_V8_H_
-#define SRC_NODE_V8_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "aliased_buffer.h"
-#include "base_object.h"
-#include "node_snapshotable.h"
-#include "util.h"
-#include "v8.h"
-
-namespace node {
-class Environment;
-struct InternalFieldInfo;
-
-namespace v8_utils {
-class BindingData : public SnapshotableObject {
- public:
-  BindingData(Environment* env, v8::Local<v8::Object> obj);
-
-  SERIALIZABLE_OBJECT_METHODS()
-  static constexpr FastStringKey type_name{"node::v8::BindingData"};
-  static constexpr EmbedderObjectType type_int =
-      EmbedderObjectType::k_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)
-};
-
-}  // namespace v8_utils
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_V8_H_

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

@@ -1,194 +0,0 @@
-#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 "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_);
-  }
-
-  inline void Dispose() {
-    if (!initialized_)
-      return;
-    initialized_ = false;
-
-    StopTracingAgent();
-    platform_->Shutdown();
-    delete platform_;
-    platform_ = nullptr;
-    // Destroy tracing after the platform (and platform threads) have been
-    // stopped.
-    tracing_agent_.reset(nullptr);
-    trace_state_observer_.reset(nullptr);
-  }
-
-  inline void DrainVMTasks(v8::Isolate* isolate) {
-    platform_->DrainTasks(isolate);
-  }
-
-  inline void StartTracingAgent() {
-    // Attach a new NodeTraceWriter only if this function hasn't been called
-    // before.
-    if (tracing_file_writer_.IsDefaultHandle()) {
-      std::vector<std::string> categories =
-          SplitString(per_process::cli_options->trace_event_categories, ',');
-
-      tracing_file_writer_ = tracing_agent_->AddClient(
-          std::set<std::string>(std::make_move_iterator(categories.begin()),
-                                std::make_move_iterator(categories.end())),
-          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/16/node_version.h

@@ -1,98 +0,0 @@
-// 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 16
-#define NODE_MINOR_VERSION 11
-#define NODE_PATCH_VERSION 1
-
-#define NODE_VERSION_IS_LTS 0
-#define NODE_VERSION_LTS_CODENAME ""
-
-#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.
- *
- * 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.
- */
-#define NODE_MODULE_VERSION 93
-
-// The NAPI_VERSION provided by this version of the runtime. This is the version
-// which the Node binary being built supports.
-#define NAPI_VERSION  8
-
-#endif  // SRC_NODE_VERSION_H_