@encharm/cws 4.4.1 → 4.5.1

package/src/headers/18/node_i18n.h

@@ -1,145 +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_I18N_H_
-#define SRC_NODE_I18N_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#if defined(NODE_HAVE_I18N_SUPPORT)
-
-#include "base_object.h"
-#include "env.h"
-#include "util.h"
-#include "v8.h"
-
-#include <unicode/ucnv.h>
-
-#include <string>
-
-namespace node {
-namespace i18n {
-
-bool InitializeICUDirectory(const std::string& path);
-
-void SetDefaultTimeZone(const char* tzid);
-
-enum idna_mode {
-  // Default mode for maximum compatibility.
-  IDNA_DEFAULT,
-  // Ignore all errors in IDNA conversion, if possible.
-  IDNA_LENIENT,
-  // Enforce STD3 rules (UseSTD3ASCIIRules) and DNS length restrictions
-  // (VerifyDnsLength). Corresponds to `beStrict` flag in the "domain to ASCII"
-  // algorithm.
-  IDNA_STRICT
-};
-
-// Implements the WHATWG URL Standard "domain to ASCII" algorithm.
-// https://url.spec.whatwg.org/#concept-domain-to-ascii
-int32_t ToASCII(MaybeStackBuffer<char>* buf,
-                const char* input,
-                size_t length,
-                enum idna_mode mode = IDNA_DEFAULT);
-
-// Implements the WHATWG URL Standard "domain to Unicode" algorithm.
-// https://url.spec.whatwg.org/#concept-domain-to-unicode
-int32_t ToUnicode(MaybeStackBuffer<char>* buf,
-                  const char* input,
-                  size_t length);
-
-struct ConverterDeleter {
-  void operator()(UConverter* pointer) const { ucnv_close(pointer); }
-};
-using ConverterPointer = std::unique_ptr<UConverter, ConverterDeleter>;
-
-class Converter {
- public:
-  explicit Converter(const char* name, const char* sub = nullptr);
-  explicit Converter(UConverter* converter, const char* sub = nullptr);
-
-  UConverter* conv() const { return conv_.get(); }
-
-  size_t max_char_size() const;
-  size_t min_char_size() const;
-  void reset();
-  void set_subst_chars(const char* sub = nullptr);
-
- private:
-  ConverterPointer conv_;
-};
-
-class ConverterObject : public BaseObject, Converter {
- public:
-  enum ConverterFlags {
-    CONVERTER_FLAGS_FLUSH      = 0x1,
-    CONVERTER_FLAGS_FATAL      = 0x2,
-    CONVERTER_FLAGS_IGNORE_BOM = 0x4,
-    CONVERTER_FLAGS_UNICODE    = 0x8,
-    CONVERTER_FLAGS_BOM_SEEN   = 0x10,
-  };
-
-  static void Create(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Decode(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Has(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  SET_NO_MEMORY_INFO()
-  SET_MEMORY_INFO_NAME(ConverterObject)
-  SET_SELF_SIZE(ConverterObject)
-
- protected:
-  ConverterObject(Environment* env,
-                  v8::Local<v8::Object> wrap,
-                  UConverter* converter,
-                  int flags,
-                  const char* sub = nullptr);
-
-  void set_bom_seen(bool seen) {
-    if (seen)
-      flags_ |= CONVERTER_FLAGS_BOM_SEEN;
-    else
-      flags_ &= ~CONVERTER_FLAGS_BOM_SEEN;
-  }
-
-  bool bom_seen() const {
-    return (flags_ & CONVERTER_FLAGS_BOM_SEEN) == CONVERTER_FLAGS_BOM_SEEN;
-  }
-
-  bool unicode() const {
-    return (flags_ & CONVERTER_FLAGS_UNICODE) == CONVERTER_FLAGS_UNICODE;
-  }
-
-  bool ignore_bom() const {
-    return (flags_ & CONVERTER_FLAGS_IGNORE_BOM) == CONVERTER_FLAGS_IGNORE_BOM;
-  }
-
- private:
-  int flags_ = 0;
-};
-
-}  // namespace i18n
-}  // namespace node
-
-#endif  // NODE_HAVE_I18N_SUPPORT
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_I18N_H_

package/src/headers/18/node_mem-inl.h

@@ -1,112 +0,0 @@
-#ifndef SRC_NODE_MEM_INL_H_
-#define SRC_NODE_MEM_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_mem.h"
-#include "node_internals.h"
-
-namespace node {
-namespace mem {
-
-template <typename Class, typename AllocatorStruct>
-AllocatorStruct NgLibMemoryManager<Class, AllocatorStruct>::MakeAllocator() {
-  return AllocatorStruct {
-    static_cast<void*>(static_cast<Class*>(this)),
-    MallocImpl,
-    FreeImpl,
-    CallocImpl,
-    ReallocImpl
-  };
-}
-
-template <typename Class, typename T>
-void* NgLibMemoryManager<Class, T>::ReallocImpl(void* ptr,
-                                             size_t size,
-                                             void* user_data) {
-  Class* manager = static_cast<Class*>(user_data);
-
-  size_t previous_size = 0;
-  char* original_ptr = nullptr;
-
-  // We prepend each allocated buffer with a size_t containing the full
-  // size of the allocation.
-  if (size > 0) size += sizeof(size_t);
-
-  if (ptr != nullptr) {
-    // We are free()ing or re-allocating.
-    original_ptr = static_cast<char*>(ptr) - sizeof(size_t);
-    previous_size = *reinterpret_cast<size_t*>(original_ptr);
-    // This means we called StopTracking() on this pointer before.
-    if (previous_size == 0) {
-      // Fall back to the standard Realloc() function.
-      char* ret = UncheckedRealloc(original_ptr, size);
-      if (ret != nullptr)
-        ret += sizeof(size_t);
-      return ret;
-    }
-  }
-
-  manager->CheckAllocatedSize(previous_size);
-
-  char* mem = UncheckedRealloc(original_ptr, size);
-
-  if (mem != nullptr) {
-    // Adjust the memory info counter.
-    // TODO(addaleax): Avoid the double bookkeeping we do with
-    // current_nghttp2_memory_ + AdjustAmountOfExternalAllocatedMemory
-    // and provide versions of our memory allocation utilities that take an
-    // Environment*/Isolate* parameter and call the V8 method transparently.
-    const int64_t new_size = size - previous_size;
-    manager->IncreaseAllocatedSize(new_size);
-    manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-        new_size);
-    *reinterpret_cast<size_t*>(mem) = size;
-    mem += sizeof(size_t);
-  } else if (size == 0) {
-    manager->DecreaseAllocatedSize(previous_size);
-    manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-        -static_cast<int64_t>(previous_size));
-  }
-  return mem;
-}
-
-template <typename Class, typename T>
-void* NgLibMemoryManager<Class, T>::MallocImpl(size_t size, void* user_data) {
-  return ReallocImpl(nullptr, size, user_data);
-}
-
-template <typename Class, typename T>
-void NgLibMemoryManager<Class, T>::FreeImpl(void* ptr, void* user_data) {
-  if (ptr == nullptr) return;
-  CHECK_NULL(ReallocImpl(ptr, 0, user_data));
-}
-
-template <typename Class, typename T>
-void* NgLibMemoryManager<Class, T>::CallocImpl(size_t nmemb,
-                                            size_t size,
-                                            void* user_data) {
-  size_t real_size = MultiplyWithOverflowCheck(nmemb, size);
-  void* mem = MallocImpl(real_size, user_data);
-  if (mem != nullptr)
-    memset(mem, 0, real_size);
-  return mem;
-}
-
-template <typename Class, typename T>
-void NgLibMemoryManager<Class, T>::StopTrackingMemory(void* ptr) {
-  size_t* original_ptr = reinterpret_cast<size_t*>(
-      static_cast<char*>(ptr) - sizeof(size_t));
-  Class* manager = static_cast<Class*>(this);
-  manager->DecreaseAllocatedSize(*original_ptr);
-  manager->env()->isolate()->AdjustAmountOfExternalAllocatedMemory(
-      -static_cast<int64_t>(*original_ptr));
-  *original_ptr = 0;
-}
-
-}  // namespace mem
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_MEM_INL_H_

package/src/headers/18/node_mem.h

@@ -1,45 +0,0 @@
-#ifndef SRC_NODE_MEM_H_
-#define SRC_NODE_MEM_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <cstddef>
-
-namespace node {
-namespace mem {
-
-// nghttp2 allows custom allocators that
-// follow exactly the same structure and behavior, but
-// use different struct names. To allow for code re-use,
-// the NgLibMemoryManager template class can be used for both.
-
-struct NgLibMemoryManagerBase {
-  virtual void StopTrackingMemory(void* ptr) = 0;
-};
-
-template <typename Class, typename AllocatorStructName>
-class NgLibMemoryManager : public NgLibMemoryManagerBase {
- public:
-  // Class needs to provide these methods:
-  // void CheckAllocatedSize(size_t previous_size) const;
-  // void IncreaseAllocatedSize(size_t size);
-  // void DecreaseAllocatedSize(size_t size);
-  // Environment* env() const;
-
-  AllocatorStructName MakeAllocator();
-
-  void StopTrackingMemory(void* ptr) override;
-
- private:
-  static void* ReallocImpl(void* ptr, size_t size, void* user_data);
-  static void* MallocImpl(size_t size, void* user_data);
-  static void FreeImpl(void* ptr, void* user_data);
-  static void* CallocImpl(size_t nmemb, size_t size, void* user_data);
-};
-
-}  // namespace mem
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_MEM_H_

package/src/headers/18/node_mutex.h

@@ -1,323 +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;
-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_