@encharm/cws 4.1.0 → 4.2.0

package/src/headers/13/node_metadata.h

@@ -1,109 +0,0 @@
-#ifndef SRC_NODE_METADATA_H_
-#define SRC_NODE_METADATA_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <string>
-#include "node_version.h"
-
-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
-
-#define NODE_VERSIONS_KEYS_BASE(V)                                             \
-  V(node)                                                                      \
-  V(v8)                                                                        \
-  V(uv)                                                                        \
-  V(zlib)                                                                      \
-  V(brotli)                                                                    \
-  V(ares)                                                                      \
-  V(modules)                                                                   \
-  V(nghttp2)                                                                   \
-  V(napi)                                                                      \
-  V(llhttp)                                                                    \
-
-#if HAVE_OPENSSL
-#define NODE_VERSIONS_KEY_CRYPTO(V) V(openssl)
-#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
-
-#define NODE_VERSIONS_KEYS(V)                                                  \
-  NODE_VERSIONS_KEYS_BASE(V)                                                   \
-  NODE_VERSIONS_KEY_CRYPTO(V)                                                  \
-  NODE_VERSIONS_KEY_INTL(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
-  };
-
-  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/13/node_mutex.h

@@ -1,247 +0,0 @@
-#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;
-
-using ConditionVariable = ConditionVariableBase<LibuvMutexTraits>;
-using Mutex = MutexBase<LibuvMutexTraits>;
-
-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 conjuction 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();
-
-  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 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);
-  }
-};
-
-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>
-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>::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_

package/src/headers/13/node_native_module.h

@@ -1,99 +0,0 @@
-#ifndef SRC_NODE_NATIVE_MODULE_H_
-#define SRC_NODE_NATIVE_MODULE_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <map>
-#include <memory>
-#include <set>
-#include <string>
-#include "node_mutex.h"
-#include "node_union_bytes.h"
-#include "v8.h"
-
-// Forward declare test fixture for `friend` declaration.
-class PerProcessTest;
-
-namespace node {
-namespace native_module {
-
-using NativeModuleRecordMap = std::map<std::string, UnionBytes>;
-using NativeModuleCacheMap =
-    std::unordered_map<std::string,
-                       std::unique_ptr<v8::ScriptCompiler::CachedData>>;
-
-// The native (C++) side of the NativeModule in JS land, which
-// handles compilation and caching of builtin modules (NativeModule)
-// and bootstrappers, whose source are bundled into the binary
-// as static data.
-// This class should not depend on any Environment, or depend on access to
-// the its own singleton - that should be encapsulated in NativeModuleEnv
-// instead.
-class NativeModuleLoader {
- public:
-  NativeModuleLoader(const NativeModuleLoader&) = delete;
-  NativeModuleLoader& operator=(const NativeModuleLoader&) = delete;
-
- private:
-  // Only allow access from friends.
-  friend class NativeModuleEnv;
-  friend class CodeCacheBuilder;
-
-  NativeModuleLoader();
-  static NativeModuleLoader* GetInstance();
-
-  // Generated by tools/js2c.py as node_javascript.cc
-  void LoadJavaScriptSource();  // Loads data into source_
-  UnionBytes GetConfig();       // Return data for config.gypi
-
-  bool Exists(const char* id);
-  v8::Local<v8::Object> GetSourceObject(v8::Local<v8::Context> context);
-  v8::Local<v8::String> GetConfigString(v8::Isolate* isolate);
-  std::vector<std::string> GetModuleIds();
-
-  struct ModuleCategories {
-    bool is_initialized = false;
-    std::set<std::string> can_be_required;
-    std::set<std::string> cannot_be_required;
-  };
-  void InitializeModuleCategories();
-  const std::set<std::string>& GetCannotBeRequired();
-  const std::set<std::string>& GetCanBeRequired();
-
-  bool CanBeRequired(const char* id);
-  bool CannotBeRequired(const char* id);
-
-  NativeModuleCacheMap* code_cache();
-  v8::ScriptCompiler::CachedData* GetCodeCache(const char* id) const;
-  enum class Result { kWithCache, kWithoutCache };
-  v8::MaybeLocal<v8::String> LoadBuiltinModuleSource(v8::Isolate* isolate,
-                                                     const char* id);
-  // If an exception is encountered (e.g. source code contains
-  // syntax error), the returned value is empty.
-  v8::MaybeLocal<v8::Function> LookupAndCompile(
-      v8::Local<v8::Context> context,
-      const char* id,
-      std::vector<v8::Local<v8::String>>* parameters,
-      Result* result);
-  v8::MaybeLocal<v8::Function> CompileAsModule(v8::Local<v8::Context> context,
-                                               const char* id,
-                                               Result* result);
-
-  static NativeModuleLoader instance_;
-  ModuleCategories module_categories_;
-  NativeModuleRecordMap source_;
-  NativeModuleCacheMap code_cache_;
-  UnionBytes config_;
-
-  // Used to synchronize access to the code cache map
-  Mutex code_cache_mutex_;
-
-  friend class ::PerProcessTest;
-};
-}  // namespace native_module
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_NATIVE_MODULE_H_

package/src/headers/13/node_object_wrap.h

@@ -1,132 +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_OBJECT_WRAP_H_
-#define SRC_NODE_OBJECT_WRAP_H_
-
-#include "v8.h"
-#include <cassert>
-
-
-namespace node {
-
-class ObjectWrap {
- public:
-  ObjectWrap() {
-    refs_ = 0;
-  }
-
-
-  virtual ~ObjectWrap() {
-    if (persistent().IsEmpty())
-      return;
-    persistent().ClearWeak();
-    persistent().Reset();
-  }
-
-
-  template <class T>
-  static inline T* Unwrap(v8::Local<v8::Object> handle) {
-    assert(!handle.IsEmpty());
-    assert(handle->InternalFieldCount() > 0);
-    // Cast to ObjectWrap before casting to T.  A direct cast from void
-    // to T won't work right when T has more than one base class.
-    void* ptr = handle->GetAlignedPointerFromInternalField(0);
-    ObjectWrap* wrap = static_cast<ObjectWrap*>(ptr);
-    return static_cast<T*>(wrap);
-  }
-
-
-  inline v8::Local<v8::Object> handle() {
-    return handle(v8::Isolate::GetCurrent());
-  }
-
-
-  inline v8::Local<v8::Object> handle(v8::Isolate* isolate) {
-    return v8::Local<v8::Object>::New(isolate, persistent());
-  }
-
-
-  // NOLINTNEXTLINE(runtime/v8_persistent)
-  inline v8::Persistent<v8::Object>& persistent() {
-    return handle_;
-  }
-
-
- protected:
-  inline void Wrap(v8::Local<v8::Object> handle) {
-    assert(persistent().IsEmpty());
-    assert(handle->InternalFieldCount() > 0);
-    handle->SetAlignedPointerInInternalField(0, this);
-    persistent().Reset(v8::Isolate::GetCurrent(), handle);
-    MakeWeak();
-  }
-
-
-  inline void MakeWeak() {
-    persistent().SetWeak(this, WeakCallback, v8::WeakCallbackType::kParameter);
-  }
-
-  /* Ref() marks the object as being attached to an event loop.
-   * Refed objects will not be garbage collected, even if
-   * all references are lost.
-   */
-  virtual void Ref() {
-    assert(!persistent().IsEmpty());
-    persistent().ClearWeak();
-    refs_++;
-  }
-
-  /* Unref() marks an object as detached from the event loop.  This is its
-   * default state.  When an object with a "weak" reference changes from
-   * attached to detached state it will be freed. Be careful not to access
-   * the object after making this call as it might be gone!
-   * (A "weak reference" means an object that only has a
-   * persistent handle.)
-   *
-   * DO NOT CALL THIS FROM DESTRUCTOR
-   */
-  virtual void Unref() {
-    assert(!persistent().IsEmpty());
-    assert(!persistent().IsWeak());
-    assert(refs_ > 0);
-    if (--refs_ == 0)
-      MakeWeak();
-  }
-
-  int refs_;  // ro
-
- private:
-  static void WeakCallback(
-      const v8::WeakCallbackInfo<ObjectWrap>& data) {
-    ObjectWrap* wrap = data.GetParameter();
-    assert(wrap->refs_ == 0);
-    wrap->handle_.Reset();
-    delete wrap;
-  }
-
-  // NOLINTNEXTLINE(runtime/v8_persistent)
-  v8::Persistent<v8::Object> handle_;
-};
-
-}  // namespace node
-
-#endif  // SRC_NODE_OBJECT_WRAP_H_