@encharm/cws 4.1.0 → 4.2.0

package/src/headers/12/aliased_buffer.h

@@ -1,263 +0,0 @@
-#ifndef SRC_ALIASED_BUFFER_H_
-#define SRC_ALIASED_BUFFER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <cinttypes>
-#include "util-inl.h"
-#include "v8.h"
-
-namespace node {
-
-/**
- * Do not use this class directly when creating instances of it - use the
- * Aliased*Array defined at the end of this file instead.
- *
- * This class encapsulates the technique of having a native buffer mapped to
- * a JS object. Writes to the native buffer can happen efficiently without
- * going through JS, and the data is then available to user's via the exposed
- * JS object.
- *
- * While this technique is computationally efficient, it is effectively a
- * write to JS program state w/out going through the standard
- * (monitored) API. Thus any VM capabilities to detect the modification are
- * circumvented.
- *
- * The encapsulation herein provides a placeholder where such writes can be
- * observed. Any notification APIs will be left as a future exercise.
- */
-template <class NativeT,
-          class V8T,
-          // SFINAE NativeT to be scalar
-          typename = std::enable_if_t<std::is_scalar<NativeT>::value>>
-class AliasedBufferBase {
- public:
-  AliasedBufferBase(v8::Isolate* isolate, const size_t count)
-      : isolate_(isolate), count_(count), byte_offset_(0) {
-    CHECK_GT(count, 0);
-    const v8::HandleScope handle_scope(isolate_);
-    const size_t size_in_bytes =
-        MultiplyWithOverflowCheck(sizeof(NativeT), count);
-
-    // allocate v8 ArrayBuffer
-    v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
-        isolate_, size_in_bytes);
-    buffer_ = static_cast<NativeT*>(ab->GetContents().Data());
-
-    // allocate v8 TypedArray
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, count);
-    js_array_ = v8::Global<V8T>(isolate, js_array);
-  }
-
-  /**
-   * Create an AliasedBufferBase over a sub-region of another aliased buffer.
-   * The two will share a v8::ArrayBuffer instance &
-   * a native buffer, but will each read/write to different sections of the
-   * native buffer.
-   *
-   *  Note that byte_offset must by aligned by sizeof(NativeT).
-   */
-  // TODO(refack): refactor into a non-owning `AliasedBufferBaseView`
-  AliasedBufferBase(
-      v8::Isolate* isolate,
-      const size_t byte_offset,
-      const size_t count,
-      const AliasedBufferBase<uint8_t, v8::Uint8Array>& backing_buffer)
-      : isolate_(isolate), count_(count), byte_offset_(byte_offset) {
-    const v8::HandleScope handle_scope(isolate_);
-
-    v8::Local<v8::ArrayBuffer> ab = backing_buffer.GetArrayBuffer();
-
-    // validate that the byte_offset is aligned with sizeof(NativeT)
-    CHECK_EQ(byte_offset & (sizeof(NativeT) - 1), 0);
-    // validate this fits inside the backing buffer
-    CHECK_LE(MultiplyWithOverflowCheck(sizeof(NativeT), count),
-             ab->ByteLength() - byte_offset);
-
-    buffer_ = reinterpret_cast<NativeT*>(
-        const_cast<uint8_t*>(backing_buffer.GetNativeBuffer() + byte_offset));
-
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset, count);
-    js_array_ = v8::Global<V8T>(isolate, js_array);
-  }
-
-  AliasedBufferBase(const AliasedBufferBase& that)
-      : isolate_(that.isolate_),
-        count_(that.count_),
-        byte_offset_(that.byte_offset_),
-        buffer_(that.buffer_) {
-    js_array_ = v8::Global<V8T>(that.isolate_, that.GetJSArray());
-  }
-
-  AliasedBufferBase& operator=(AliasedBufferBase&& that) noexcept {
-    this->~AliasedBufferBase();
-    isolate_ = that.isolate_;
-    count_ = that.count_;
-    byte_offset_ = that.byte_offset_;
-    buffer_ = that.buffer_;
-
-    js_array_.Reset(isolate_, that.js_array_.Get(isolate_));
-
-    that.buffer_ = nullptr;
-    that.js_array_.Reset();
-    return *this;
-  }
-
-  /**
-   * Helper class that is returned from operator[] to support assignment into
-   * a specified location.
-   */
-  class Reference {
-   public:
-    Reference(AliasedBufferBase<NativeT, V8T>* aliased_buffer, size_t index)
-        : aliased_buffer_(aliased_buffer), index_(index) {}
-
-    Reference(const Reference& that)
-        : aliased_buffer_(that.aliased_buffer_),
-          index_(that.index_) {
-    }
-
-    inline Reference& operator=(const NativeT& val) {
-      aliased_buffer_->SetValue(index_, val);
-      return *this;
-    }
-
-    inline Reference& operator=(const Reference& val) {
-      return *this = static_cast<NativeT>(val);
-    }
-
-    operator NativeT() const {
-      return aliased_buffer_->GetValue(index_);
-    }
-
-    inline Reference& operator+=(const NativeT& val) {
-      const NativeT current = aliased_buffer_->GetValue(index_);
-      aliased_buffer_->SetValue(index_, current + val);
-      return *this;
-    }
-
-    inline Reference& operator+=(const Reference& val) {
-      return this->operator+=(static_cast<NativeT>(val));
-    }
-
-    inline Reference& operator-=(const NativeT& val) {
-      const NativeT current = aliased_buffer_->GetValue(index_);
-      aliased_buffer_->SetValue(index_, current - val);
-      return *this;
-    }
-
-   private:
-    AliasedBufferBase<NativeT, V8T>* aliased_buffer_;
-    size_t index_;
-  };
-
-  /**
-   *  Get the underlying v8 TypedArray overlayed on top of the native buffer
-   */
-  v8::Local<V8T> GetJSArray() const {
-    return js_array_.Get(isolate_);
-  }
-
-  /**
-  *  Get the underlying v8::ArrayBuffer underlying the TypedArray and
-  *  overlaying the native buffer
-  */
-  v8::Local<v8::ArrayBuffer> GetArrayBuffer() const {
-    return GetJSArray()->Buffer();
-  }
-
-  /**
-   *  Get the underlying native buffer. Note that all reads/writes should occur
-   *  through the GetValue/SetValue/operator[] methods
-   */
-  inline const NativeT* GetNativeBuffer() const {
-    return buffer_;
-  }
-
-  /**
-   *  Synonym for GetBuffer()
-   */
-  inline const NativeT* operator * () const {
-    return GetNativeBuffer();
-  }
-
-  /**
-   *  Set position index to given value.
-   */
-  inline void SetValue(const size_t index, NativeT value) {
-    DCHECK_LT(index, count_);
-    buffer_[index] = value;
-  }
-
-  /**
-   *  Get value at position index
-   */
-  inline const NativeT GetValue(const size_t index) const {
-    DCHECK_LT(index, count_);
-    return buffer_[index];
-  }
-
-  /**
-   *  Effectively, a synonym for GetValue/SetValue
-   */
-  Reference operator[](size_t index) {
-    return Reference(this, index);
-  }
-
-  NativeT operator[](size_t index) const {
-    return GetValue(index);
-  }
-
-  size_t Length() const {
-    return count_;
-  }
-
-  // Should only be used to extend the array.
-  // Should only be used on an owning array, not one created as a sub array of
-  // an owning `AliasedBufferBase`.
-  void reserve(size_t new_capacity) {
-    DCHECK_GE(new_capacity, count_);
-    DCHECK_EQ(byte_offset_, 0);
-    const v8::HandleScope handle_scope(isolate_);
-
-    const size_t old_size_in_bytes = sizeof(NativeT) * count_;
-    const size_t new_size_in_bytes = MultiplyWithOverflowCheck(sizeof(NativeT),
-                                                              new_capacity);
-
-    // allocate v8 new ArrayBuffer
-    v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
-        isolate_, new_size_in_bytes);
-
-    // allocate new native buffer
-    NativeT* new_buffer = static_cast<NativeT*>(ab->GetContents().Data());
-    // copy old content
-    memcpy(new_buffer, buffer_, old_size_in_bytes);
-
-    // allocate v8 TypedArray
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, new_capacity);
-
-    // move over old v8 TypedArray
-    js_array_ = std::move(v8::Global<V8T>(isolate_, js_array));
-
-    buffer_ = new_buffer;
-    count_ = new_capacity;
-  }
-
- private:
-  v8::Isolate* isolate_;
-  size_t count_;
-  size_t byte_offset_;
-  NativeT* buffer_;
-  v8::Global<V8T> js_array_;
-};
-
-typedef AliasedBufferBase<int32_t, v8::Int32Array> AliasedInt32Array;
-typedef AliasedBufferBase<uint8_t, v8::Uint8Array> AliasedUint8Array;
-typedef AliasedBufferBase<uint32_t, v8::Uint32Array> AliasedUint32Array;
-typedef AliasedBufferBase<double, v8::Float64Array> AliasedFloat64Array;
-typedef AliasedBufferBase<uint64_t, v8::BigUint64Array> AliasedBigUint64Array;
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ALIASED_BUFFER_H_

package/src/headers/12/debug_utils.h

@@ -1,181 +0,0 @@
-#ifndef SRC_DEBUG_UTILS_H_
-#define SRC_DEBUG_UTILS_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "async_wrap.h"
-
-#include <algorithm>
-#include <sstream>
-#include <string>
-
-// Use FORCE_INLINE on functions that have a debug-category-enabled check first
-// and then ideally only a single function call following it, to maintain
-// performance for the common case (no debugging used).
-#ifdef __GNUC__
-#define FORCE_INLINE __attribute__((always_inline))
-#define COLD_NOINLINE __attribute__((cold, noinline))
-#else
-#define FORCE_INLINE
-#define COLD_NOINLINE
-#endif
-
-namespace node {
-class Environment;
-
-template <typename T>
-inline std::string ToString(const T& value);
-
-// C++-style variant of sprintf()/fprintf() that:
-// - Returns an std::string
-// - Handles \0 bytes correctly
-// - Supports %p and %s. %d, %i and %u are aliases for %s.
-// - Accepts any class that has a ToString() method for stringification.
-template <typename... Args>
-inline std::string SPrintF(const char* format, Args&&... args);
-template <typename... Args>
-inline void FPrintF(FILE* file, const char* format, Args&&... args);
-void FWrite(FILE* file, const std::string& str);
-
-// Listing the AsyncWrap provider types first enables us to cast directly
-// from a provider type to a debug category.
-#define DEBUG_CATEGORY_NAMES(V)                                                \
-  NODE_ASYNC_PROVIDER_TYPES(V)                                                 \
-  V(HUGEPAGES)                                                                 \
-  V(INSPECTOR_SERVER)                                                          \
-  V(INSPECTOR_PROFILER)                                                        \
-  V(CODE_CACHE)                                                                \
-  V(WASI)
-
-enum class DebugCategory {
-#define V(name) name,
-  DEBUG_CATEGORY_NAMES(V)
-#undef V
-      CATEGORY_COUNT
-};
-
-class EnabledDebugList {
- public:
-  bool enabled(DebugCategory category) const {
-    DCHECK_GE(static_cast<int>(category), 0);
-    DCHECK_LT(static_cast<int>(category),
-              static_cast<int>(DebugCategory::CATEGORY_COUNT));
-    return enabled_[static_cast<int>(category)];
-  }
-
-  // Uses NODE_DEBUG_NATIVE to initialize the categories. When env is not a
-  // nullptr, the environment variables set in the Environment are used.
-  // Otherwise the system environment variables are used.
-  void Parse(Environment* env);
-
- private:
-  // Set all categories matching cats to the value of enabled.
-  void Parse(const std::string& cats, bool enabled);
-  void set_enabled(DebugCategory category, bool enabled) {
-    DCHECK_GE(static_cast<int>(category), 0);
-    DCHECK_LT(static_cast<int>(category),
-              static_cast<int>(DebugCategory::CATEGORY_COUNT));
-    enabled_[static_cast<int>(category)] = true;
-  }
-
-  bool enabled_[static_cast<int>(DebugCategory::CATEGORY_COUNT)] = {false};
-};
-
-template <typename... Args>
-inline void FORCE_INLINE Debug(EnabledDebugList* list,
-                               DebugCategory cat,
-                               const char* format,
-                               Args&&... args);
-
-inline void FORCE_INLINE Debug(EnabledDebugList* list,
-                               DebugCategory cat,
-                               const char* message);
-
-template <typename... Args>
-inline void FORCE_INLINE
-Debug(Environment* env, DebugCategory cat, const char* format, Args&&... args);
-
-inline void FORCE_INLINE Debug(Environment* env,
-                               DebugCategory cat,
-                               const char* message);
-
-template <typename... Args>
-inline void Debug(Environment* env,
-                  DebugCategory cat,
-                  const std::string& format,
-                  Args&&... args);
-
-// Used internally by the 'real' Debug(AsyncWrap*, ...) functions below, so that
-// the FORCE_INLINE flag on them doesn't apply to the contents of this function
-// as well.
-// We apply COLD_NOINLINE to tell the compiler that it's not worth optimizing
-// this function for speed and it should rather focus on keeping it out of
-// hot code paths. In particular, we want to keep the string concatenating code
-// out of the function containing the original `Debug()` call.
-template <typename... Args>
-void COLD_NOINLINE UnconditionalAsyncWrapDebug(AsyncWrap* async_wrap,
-                                               const char* format,
-                                               Args&&... args);
-
-template <typename... Args>
-inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
-                               const char* format,
-                               Args&&... args);
-
-template <typename... Args>
-inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
-                               const std::string& format,
-                               Args&&... args);
-
-// Debug helper for inspecting the currently running `node` executable.
-class NativeSymbolDebuggingContext {
- public:
-  static std::unique_ptr<NativeSymbolDebuggingContext> New();
-
-  class SymbolInfo {
-   public:
-    std::string name;
-    std::string filename;
-    size_t line = 0;
-    size_t dis = 0;
-
-    std::string Display() const;
-  };
-
-  NativeSymbolDebuggingContext() = default;
-  virtual ~NativeSymbolDebuggingContext() = default;
-
-  virtual SymbolInfo LookupSymbol(void* address) { return {}; }
-  virtual bool IsMapped(void* address) { return false; }
-  virtual int GetStackTrace(void** frames, int count) { return 0; }
-
-  NativeSymbolDebuggingContext(const NativeSymbolDebuggingContext&) = delete;
-  NativeSymbolDebuggingContext(NativeSymbolDebuggingContext&&) = delete;
-  NativeSymbolDebuggingContext operator=(NativeSymbolDebuggingContext&)
-    = delete;
-  NativeSymbolDebuggingContext operator=(NativeSymbolDebuggingContext&&)
-    = delete;
-  static std::vector<std::string> GetLoadedLibraries();
-};
-
-// Variant of `uv_loop_close` that tries to be as helpful as possible
-// about giving information on currently existing handles, if there are any,
-// but still aborts the process.
-void CheckedUvLoopClose(uv_loop_t* loop);
-void PrintLibuvHandleInformation(uv_loop_t* loop, FILE* stream);
-
-namespace per_process {
-extern EnabledDebugList enabled_debug_list;
-
-template <typename... Args>
-inline void FORCE_INLINE Debug(DebugCategory cat,
-                               const char* format,
-                               Args&&... args);
-
-inline void FORCE_INLINE Debug(DebugCategory cat, const char* message);
-}  // namespace per_process
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_DEBUG_UTILS_H_

package/src/headers/12/histogram-inl.h

@@ -1,83 +0,0 @@
-#ifndef SRC_HISTOGRAM_INL_H_
-#define SRC_HISTOGRAM_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "histogram.h"
-#include "base_object-inl.h"
-#include "node_internals.h"
-
-namespace node {
-
-void Histogram::Reset() {
-  hdr_reset(histogram_.get());
-}
-
-bool Histogram::Record(int64_t value) {
-  return hdr_record_value(histogram_.get(), value);
-}
-
-int64_t Histogram::Min() {
-  return hdr_min(histogram_.get());
-}
-
-int64_t Histogram::Max() {
-  return hdr_max(histogram_.get());
-}
-
-double Histogram::Mean() {
-  return hdr_mean(histogram_.get());
-}
-
-double Histogram::Stddev() {
-  return hdr_stddev(histogram_.get());
-}
-
-double Histogram::Percentile(double percentile) {
-  CHECK_GT(percentile, 0);
-  CHECK_LE(percentile, 100);
-  return static_cast<double>(
-      hdr_value_at_percentile(histogram_.get(), percentile));
-}
-
-template <typename Iterator>
-void Histogram::Percentiles(Iterator&& fn) {
-  hdr_iter iter;
-  hdr_iter_percentile_init(&iter, histogram_.get(), 1);
-  while (hdr_iter_next(&iter)) {
-    double key = iter.specifics.percentiles.percentile;
-    double value = static_cast<double>(iter.value);
-    fn(key, value);
-  }
-}
-
-bool HistogramBase::RecordDelta() {
-  uint64_t time = uv_hrtime();
-  bool ret = true;
-  if (prev_ > 0) {
-    int64_t delta = time - prev_;
-    if (delta > 0) {
-      ret = Record(delta);
-      TraceDelta(delta);
-      if (!ret) {
-        if (exceeds_ < 0xFFFFFFFF)
-          exceeds_++;
-        TraceExceeds(delta);
-      }
-    }
-  }
-  prev_ = time;
-  return ret;
-}
-
-void HistogramBase::ResetState() {
-  Reset();
-  exceeds_ = 0;
-  prev_ = 0;
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_HISTOGRAM_INL_H_

package/src/headers/12/histogram.h

@@ -1,98 +0,0 @@
-#ifndef SRC_HISTOGRAM_H_
-#define SRC_HISTOGRAM_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "hdr_histogram.h"
-#include "base_object.h"
-#include "util.h"
-
-#include <functional>
-#include <limits>
-#include <map>
-
-namespace node {
-
-constexpr int kDefaultHistogramFigures = 3;
-
-class Histogram {
- public:
-  Histogram(
-      int64_t lowest = std::numeric_limits<int64_t>::min(),
-      int64_t highest = std::numeric_limits<int64_t>::max(),
-      int figures = kDefaultHistogramFigures);
-  virtual ~Histogram() = default;
-
-  inline bool Record(int64_t value);
-  inline void Reset();
-  inline int64_t Min();
-  inline int64_t Max();
-  inline double Mean();
-  inline double Stddev();
-  inline double Percentile(double percentile);
-
-  // Iterator is a function type that takes two doubles as argument, one for
-  // percentile and one for the value at that percentile.
-  template <typename Iterator>
-  inline void Percentiles(Iterator&& fn);
-
-  size_t GetMemorySize() const {
-    return hdr_get_memory_size(histogram_.get());
-  }
-
- private:
-  using HistogramPointer = DeleteFnPtr<hdr_histogram, hdr_close>;
-  HistogramPointer histogram_;
-};
-
-class HistogramBase : public BaseObject, public Histogram {
- public:
-  virtual ~HistogramBase() = default;
-
-  virtual void TraceDelta(int64_t delta) {}
-  virtual void TraceExceeds(int64_t delta) {}
-
-  inline bool RecordDelta();
-  inline void ResetState();
-
-  int64_t Exceeds() const { return exceeds_; }
-
-  void MemoryInfo(MemoryTracker* tracker) const override;
-  SET_MEMORY_INFO_NAME(HistogramBase)
-  SET_SELF_SIZE(HistogramBase)
-
-  static void GetMin(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetMax(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetMean(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetExceeds(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetStddev(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPercentile(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetPercentiles(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void DoReset(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Initialize(Environment* env);
-
-  static BaseObjectPtr<HistogramBase> New(
-      Environment* env,
-      int64_t lowest = std::numeric_limits<int64_t>::min(),
-      int64_t highest = std::numeric_limits<int64_t>::max(),
-      int figures = kDefaultHistogramFigures);
-
-  HistogramBase(
-      Environment* env,
-      v8::Local<v8::Object> wrap,
-      int64_t lowest = std::numeric_limits<int64_t>::min(),
-      int64_t highest = std::numeric_limits<int64_t>::max(),
-      int figures = kDefaultHistogramFigures);
-
- private:
-  int64_t exceeds_ = 0;
-  uint64_t prev_ = 0;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_HISTOGRAM_H_

package/src/headers/12/http_parser_adaptor.h

@@ -1,24 +0,0 @@
-#ifndef SRC_HTTP_PARSER_ADAPTOR_H_
-#define SRC_HTTP_PARSER_ADAPTOR_H_
-
-#ifdef NODE_EXPERIMENTAL_HTTP
-# include "llhttp.h"
-
-typedef llhttp_type_t parser_type_t;
-typedef llhttp_errno_t parser_errno_t;
-typedef llhttp_settings_t parser_settings_t;
-typedef llhttp_t parser_t;
-
-#else  /* !NODE_EXPERIMENTAL_HTTP */
-# include "http_parser.h"
-
-typedef enum http_parser_type parser_type_t;
-typedef enum http_errno parser_errno_t;
-typedef http_parser_settings parser_settings_t;
-typedef http_parser parser_t;
-
-#define HPE_USER HPE_UNKNOWN
-
-#endif  /* NODE_EXPERIMENTAL_HTTP */
-
-#endif  /* SRC_HTTP_PARSER_ADAPTOR_H_ */