@encharm/cws 4.5.3 → 4.8.0

package/src/headers/26/node_metadata.h

@@ -0,0 +1,172 @@
+#ifndef SRC_NODE_METADATA_H_
+#define SRC_NODE_METADATA_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include <array>
+#include <string>
+#include <utility>
+#include "node_version.h"
+
+#if HAVE_OPENSSL
+#include <openssl/crypto.h>
+#include <quic/guard.h>
+#ifndef OPENSSL_NO_QUIC
+#include <openssl/quic.h>
+#endif
+#endif  // HAVE_OPENSSL
+
+namespace node {
+
+// if this is a release build and no explicit base has been set
+// substitute the standard release download URL
+#ifndef NODE_RELEASE_URLBASE
+#if NODE_VERSION_IS_RELEASE
+#define NODE_RELEASE_URLBASE "https://nodejs.org/download/release/"
+#endif  // NODE_VERSION_IS_RELEASE
+#endif  // NODE_RELEASE_URLBASE
+
+#if defined(NODE_RELEASE_URLBASE)
+#define NODE_HAS_RELEASE_URLS
+#endif
+
+#if HAVE_AMARO && !defined(NODE_SHARED_BUILTIN_AMARO_DIST_INDEX_PATH)
+#define NODE_VERSIONS_KEY_AMARO(V) V(amaro)
+#else
+#define NODE_VERSIONS_KEY_AMARO(V)
+#endif
+
+#ifndef NODE_SHARED_BUILTIN_UNDICI_UNDICI_PATH
+#define NODE_VERSIONS_KEY_UNDICI(V) V(undici)
+#else
+#define NODE_VERSIONS_KEY_UNDICI(V)
+#endif
+
+#define NODE_VERSIONS_KEYS_BASE(V)                                             \
+  V(node)                                                                      \
+  V(v8)                                                                        \
+  V(uv)                                                                        \
+  V(zlib)                                                                      \
+  V(brotli)                                                                    \
+  V(zstd)                                                                      \
+  V(ares)                                                                      \
+  V(modules)                                                                   \
+  V(nghttp2)                                                                   \
+  V(napi)                                                                      \
+  V(llhttp)                                                                    \
+  V(uvwasi)                                                                    \
+  V(acorn)                                                                     \
+  V(simdjson)                                                                  \
+  V(simdutf)                                                                   \
+  V(ada)                                                                       \
+  V(nbytes)                                                                    \
+  V(ngtcp2)                                                                    \
+  V(nghttp3)                                                                   \
+  NODE_VERSIONS_KEY_AMARO(V)                                                   \
+  NODE_VERSIONS_KEY_UNDICI(V)                                                  \
+  V(merve)
+
+#if HAVE_OPENSSL
+#define NODE_VERSIONS_KEY_CRYPTO(V) V(openssl) V(ncrypto)
+#else
+#define NODE_VERSIONS_KEY_CRYPTO(V)
+#endif
+
+#ifdef NODE_HAVE_I18N_SUPPORT
+#define NODE_VERSIONS_KEY_INTL(V)                                              \
+  V(cldr)                                                                      \
+  V(icu)                                                                       \
+  V(tz)                                                                        \
+  V(unicode)
+#else
+#define NODE_VERSIONS_KEY_INTL(V)
+#endif  // NODE_HAVE_I18N_SUPPORT
+
+#if HAVE_SQLITE
+#define NODE_VERSIONS_KEY_SQLITE(V) V(sqlite)
+#else
+#define NODE_VERSIONS_KEY_SQLITE(V)
+#endif
+
+#if HAVE_FFI
+#define NODE_VERSIONS_KEY_LIBFFI(V) V(libffi)
+#else
+#define NODE_VERSIONS_KEY_LIBFFI(V)
+#endif
+
+#if HAVE_LIEF
+#define NODE_VERSIONS_KEY_LIEF(V) V(lief)
+#else
+#define NODE_VERSIONS_KEY_LIEF(V)
+#endif
+
+#define NODE_VERSIONS_KEYS(V)                                                  \
+  NODE_VERSIONS_KEYS_BASE(V)                                                   \
+  NODE_VERSIONS_KEY_CRYPTO(V)                                                  \
+  NODE_VERSIONS_KEY_INTL(V)                                                    \
+  NODE_VERSIONS_KEY_SQLITE(V)                                                  \
+  NODE_VERSIONS_KEY_LIBFFI(V)                                                  \
+  NODE_VERSIONS_KEY_LIEF(V)
+
+#define V(key) +1
+constexpr int NODE_VERSIONS_KEY_COUNT = NODE_VERSIONS_KEYS(V);
+#undef V
+
+class Metadata {
+ public:
+  Metadata();
+  Metadata(Metadata&) = delete;
+  Metadata(Metadata&&) = delete;
+  Metadata operator=(Metadata&) = delete;
+  Metadata operator=(Metadata&&) = delete;
+
+  struct Versions {
+    Versions();
+
+#ifdef NODE_HAVE_I18N_SUPPORT
+    // Must be called on the main thread after
+    // i18n::InitializeICUDirectory()
+    void InitializeIntlVersions();
+#endif  // NODE_HAVE_I18N_SUPPORT
+
+#define V(key) std::string key;
+    NODE_VERSIONS_KEYS(V)
+#undef V
+
+    std::array<std::pair<std::string_view, std::string_view>,
+               NODE_VERSIONS_KEY_COUNT>
+    pairs() const;
+  };
+
+  struct Release {
+    Release();
+
+    std::string name;
+#if NODE_VERSION_IS_LTS
+    std::string lts;
+#endif  // NODE_VERSION_IS_LTS
+
+#ifdef NODE_HAS_RELEASE_URLS
+    std::string source_url;
+    std::string headers_url;
+#ifdef _WIN32
+    std::string lib_url;
+#endif  // _WIN32
+#endif  // NODE_HAS_RELEASE_URLS
+  };
+
+  Versions versions;
+  const Release release;
+  const std::string arch;
+  const std::string platform;
+};
+
+// Per-process global
+namespace per_process {
+extern Metadata metadata;
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+#endif  // SRC_NODE_METADATA_H_

package/src/headers/26/node_modules.h

@@ -0,0 +1,102 @@
+#ifndef SRC_NODE_MODULES_H_
+#define SRC_NODE_MODULES_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "node.h"
+#include "node_snapshotable.h"
+#include "simdjson.h"
+#include "util.h"
+#include "v8-fast-api-calls.h"
+#include "v8.h"
+
+#include <filesystem>
+#include <optional>
+#include <string>
+#include <string_view>
+#include <unordered_map>
+
+namespace node {
+class ExternalReferenceRegistry;
+
+namespace modules {
+
+class BindingData : public SnapshotableObject {
+ public:
+  using InternalFieldInfo = InternalFieldInfoBase;
+
+  struct PackageConfig {
+    std::string file_path;
+    std::optional<std::string> name;
+    std::optional<std::string> main;
+    std::string type = "none";
+    std::optional<std::string> exports;
+    std::optional<std::string> imports;
+    std::optional<std::string> scripts;
+    std::string raw_json;
+
+    v8::Local<v8::Array> Serialize(Realm* realm) const;
+  };
+
+  struct ErrorContext {
+    std::optional<std::string> base;
+    std::string specifier;
+    bool is_esm;
+  };
+
+  BindingData(Realm* realm,
+              v8::Local<v8::Object> obj,
+              InternalFieldInfo* info = nullptr);
+  SERIALIZABLE_OBJECT_METHODS()
+  SET_BINDING_ID(modules_binding_data)
+
+  void MemoryInfo(MemoryTracker* tracker) const override;
+  SET_SELF_SIZE(BindingData)
+  SET_MEMORY_INFO_NAME(BindingData)
+
+  static void ReadPackageJSON(const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetNearestParentPackageJSON(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetNearestParentPackageJSONType(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  template <bool return_only_type>
+  static void GetPackageScopeConfig(
+      const v8::FunctionCallbackInfo<v8::Value>& args);
+  static void GetPackageJSONScripts(
+      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:
+  /*
+   * This map caches `PackageConfig` values by `package.json` path.
+   * An empty optional value indicates that no `package.json` file
+   * at the given path exists, which we cache to avoid repeated
+   * attempts to open the same non-existent paths.
+   */
+  std::unordered_map<std::string, std::optional<PackageConfig> >
+      package_configs_;
+  simdjson::ondemand::parser json_parser;
+  static const std::filesystem::path NormalizePath(Realm* realm,
+                                                   BufferValue* path_value);
+  // returns null on error
+  static const PackageConfig* GetPackageJSON(
+      Realm* realm,
+      std::string_view path,
+      ErrorContext* error_context = nullptr);
+  static const PackageConfig* TraverseParent(
+      Realm* realm, const std::filesystem::path& check_path);
+};
+
+}  // namespace modules
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_MODULES_H_

package/src/headers/26/node_mutex.h

@@ -0,0 +1,323 @@
+#ifndef SRC_NODE_MUTEX_H_
+#define SRC_NODE_MUTEX_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 {
+
+template <typename Traits> class ConditionVariableBase;
+template <typename Traits> class MutexBase;
+struct LibuvMutexTraits;
+struct LibuvRwlockTraits;
+
+using ConditionVariable = ConditionVariableBase<LibuvMutexTraits>;
+using Mutex = MutexBase<LibuvMutexTraits>;
+using RwLock = MutexBase<LibuvRwlockTraits>;
+
+template <typename T, typename MutexT = Mutex>
+class ExclusiveAccess {
+ public:
+  ExclusiveAccess() = default;
+
+  template <typename... Args>
+  explicit ExclusiveAccess(Args&&... args)
+      : item_(std::forward<Args>(args)...) {}
+
+  ExclusiveAccess(const ExclusiveAccess&) = delete;
+  ExclusiveAccess& operator=(const ExclusiveAccess&) = delete;
+
+  class Scoped {
+   public:
+    // ExclusiveAccess will commonly be used in conjunction with std::shared_ptr
+    // and without this constructor it's too easy to forget to keep a reference
+    // around to the shared_ptr while operating on the ExclusiveAccess object.
+    explicit Scoped(const std::shared_ptr<ExclusiveAccess>& shared)
+        : shared_(shared)
+        , scoped_lock_(shared->mutex_)
+        , pointer_(&shared->item_) {}
+
+    explicit Scoped(ExclusiveAccess* exclusive_access)
+        : shared_()
+        , scoped_lock_(exclusive_access->mutex_)
+        , pointer_(&exclusive_access->item_) {}
+
+    T& operator*() const { return *pointer_; }
+    T* operator->() const { return pointer_; }
+
+    Scoped(const Scoped&) = delete;
+    Scoped& operator=(const Scoped&) = delete;
+
+   private:
+    std::shared_ptr<ExclusiveAccess> shared_;
+    typename MutexT::ScopedLock scoped_lock_;
+    T* const pointer_;
+  };
+
+ private:
+  friend class ScopedLock;
+  MutexT mutex_;
+  T item_;
+};
+
+template <typename Traits>
+class MutexBase {
+ public:
+  inline MutexBase();
+  inline ~MutexBase();
+  inline void Lock();
+  inline void Unlock();
+  inline void RdLock();
+  inline void RdUnlock();
+
+  MutexBase(const MutexBase&) = delete;
+  MutexBase& operator=(const MutexBase&) = delete;
+
+  class ScopedLock;
+  class ScopedUnlock;
+
+  class ScopedLock {
+   public:
+    inline explicit ScopedLock(const MutexBase& mutex);
+    inline explicit ScopedLock(const ScopedUnlock& scoped_unlock);
+    inline ~ScopedLock();
+
+    ScopedLock(const ScopedLock&) = delete;
+    ScopedLock& operator=(const ScopedLock&) = delete;
+
+   private:
+    template <typename> friend class ConditionVariableBase;
+    friend class ScopedUnlock;
+    const MutexBase& mutex_;
+  };
+
+  class ScopedReadLock {
+   public:
+    inline explicit ScopedReadLock(const MutexBase& mutex);
+    inline ~ScopedReadLock();
+
+    ScopedReadLock(const ScopedReadLock&) = delete;
+    ScopedReadLock& operator=(const ScopedReadLock&) = delete;
+
+   private:
+    template <typename> friend class ConditionVariableBase;
+    const MutexBase& mutex_;
+  };
+
+  using ScopedWriteLock = ScopedLock;
+
+  class ScopedUnlock {
+   public:
+    inline explicit ScopedUnlock(const ScopedLock& scoped_lock);
+    inline ~ScopedUnlock();
+
+    ScopedUnlock(const ScopedUnlock&) = delete;
+    ScopedUnlock& operator=(const ScopedUnlock&) = delete;
+
+   private:
+    friend class ScopedLock;
+    const MutexBase& mutex_;
+  };
+
+ private:
+  template <typename> friend class ConditionVariableBase;
+  mutable typename Traits::MutexT mutex_;
+};
+
+template <typename Traits>
+class ConditionVariableBase {
+ public:
+  using ScopedLock = typename MutexBase<Traits>::ScopedLock;
+
+  inline ConditionVariableBase();
+  inline ~ConditionVariableBase();
+  inline void Broadcast(const ScopedLock&);
+  inline void Signal(const ScopedLock&);
+  inline void Wait(const ScopedLock& scoped_lock);
+
+  ConditionVariableBase(const ConditionVariableBase&) = delete;
+  ConditionVariableBase& operator=(const ConditionVariableBase&) = delete;
+
+ private:
+  typename Traits::CondT cond_;
+};
+
+struct LibuvMutexTraits {
+  using CondT = uv_cond_t;
+  using MutexT = uv_mutex_t;
+
+  static inline int cond_init(CondT* cond) {
+    return uv_cond_init(cond);
+  }
+
+  static inline int mutex_init(MutexT* mutex) {
+    return uv_mutex_init(mutex);
+  }
+
+  static inline void cond_broadcast(CondT* cond) {
+    uv_cond_broadcast(cond);
+  }
+
+  static inline void cond_destroy(CondT* cond) {
+    uv_cond_destroy(cond);
+  }
+
+  static inline void cond_signal(CondT* cond) {
+    uv_cond_signal(cond);
+  }
+
+  static inline void cond_wait(CondT* cond, MutexT* mutex) {
+    uv_cond_wait(cond, mutex);
+  }
+
+  static inline void mutex_destroy(MutexT* mutex) {
+    uv_mutex_destroy(mutex);
+  }
+
+  static inline void mutex_lock(MutexT* mutex) {
+    uv_mutex_lock(mutex);
+  }
+
+  static inline void mutex_unlock(MutexT* mutex) {
+    uv_mutex_unlock(mutex);
+  }
+
+  static inline void mutex_rdlock(MutexT* mutex) {
+    uv_mutex_lock(mutex);
+  }
+
+  static inline void mutex_rdunlock(MutexT* mutex) {
+    uv_mutex_unlock(mutex);
+  }
+};
+
+struct LibuvRwlockTraits {
+  using MutexT = uv_rwlock_t;
+
+  static inline int mutex_init(MutexT* mutex) {
+    return uv_rwlock_init(mutex);
+  }
+
+  static inline void mutex_destroy(MutexT* mutex) {
+    uv_rwlock_destroy(mutex);
+  }
+
+  static inline void mutex_lock(MutexT* mutex) {
+    uv_rwlock_wrlock(mutex);
+  }
+
+  static inline void mutex_unlock(MutexT* mutex) {
+    uv_rwlock_wrunlock(mutex);
+  }
+
+  static inline void mutex_rdlock(MutexT* mutex) {
+    uv_rwlock_rdlock(mutex);
+  }
+
+  static inline void mutex_rdunlock(MutexT* mutex) {
+    uv_rwlock_rdunlock(mutex);
+  }
+};
+
+template <typename Traits>
+ConditionVariableBase<Traits>::ConditionVariableBase() {
+  CHECK_EQ(0, Traits::cond_init(&cond_));
+}
+
+template <typename Traits>
+ConditionVariableBase<Traits>::~ConditionVariableBase() {
+  Traits::cond_destroy(&cond_);
+}
+
+template <typename Traits>
+void ConditionVariableBase<Traits>::Broadcast(const ScopedLock&) {
+  Traits::cond_broadcast(&cond_);
+}
+
+template <typename Traits>
+void ConditionVariableBase<Traits>::Signal(const ScopedLock&) {
+  Traits::cond_signal(&cond_);
+}
+
+template <typename Traits>
+void ConditionVariableBase<Traits>::Wait(const ScopedLock& scoped_lock) {
+  Traits::cond_wait(&cond_, &scoped_lock.mutex_.mutex_);
+}
+
+template <typename Traits>
+MutexBase<Traits>::MutexBase() {
+  CHECK_EQ(0, Traits::mutex_init(&mutex_));
+}
+
+template <typename Traits>
+MutexBase<Traits>::~MutexBase() {
+  Traits::mutex_destroy(&mutex_);
+}
+
+template <typename Traits>
+void MutexBase<Traits>::Lock() {
+  Traits::mutex_lock(&mutex_);
+}
+
+template <typename Traits>
+void MutexBase<Traits>::Unlock() {
+  Traits::mutex_unlock(&mutex_);
+}
+
+template <typename Traits>
+void MutexBase<Traits>::RdLock() {
+  Traits::mutex_rdlock(&mutex_);
+}
+
+template <typename Traits>
+void MutexBase<Traits>::RdUnlock() {
+  Traits::mutex_rdunlock(&mutex_);
+}
+
+template <typename Traits>
+MutexBase<Traits>::ScopedLock::ScopedLock(const MutexBase& mutex)
+    : mutex_(mutex) {
+  Traits::mutex_lock(&mutex_.mutex_);
+}
+
+template <typename Traits>
+MutexBase<Traits>::ScopedLock::ScopedLock(const ScopedUnlock& scoped_unlock)
+    : MutexBase(scoped_unlock.mutex_) {}
+
+template <typename Traits>
+MutexBase<Traits>::ScopedLock::~ScopedLock() {
+  Traits::mutex_unlock(&mutex_.mutex_);
+}
+
+template <typename Traits>
+MutexBase<Traits>::ScopedReadLock::ScopedReadLock(const MutexBase& mutex)
+    : mutex_(mutex) {
+  Traits::mutex_rdlock(&mutex_.mutex_);
+}
+
+template <typename Traits>
+MutexBase<Traits>::ScopedReadLock::~ScopedReadLock() {
+  Traits::mutex_rdunlock(&mutex_.mutex_);
+}
+
+template <typename Traits>
+MutexBase<Traits>::ScopedUnlock::ScopedUnlock(const ScopedLock& scoped_lock)
+    : mutex_(scoped_lock.mutex_) {
+  Traits::mutex_unlock(&mutex_.mutex_);
+}
+
+template <typename Traits>
+MutexBase<Traits>::ScopedUnlock::~ScopedUnlock() {
+  Traits::mutex_lock(&mutex_.mutex_);
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_NODE_MUTEX_H_