@encharm/cws 4.1.0 → 4.2.0

package/src/headers/{12 → 18}/v8abbr.h

@@ -41,7 +41,6 @@
 #define V8_FT_OPTIMIZED             V8DBG_FRAMETYPE_OPTIMIZEDFRAME
 #define V8_FT_INTERNAL              V8DBG_FRAMETYPE_INTERNALFRAME
 #define V8_FT_CONSTRUCT             V8DBG_FRAMETYPE_CONSTRUCTFRAME
-#define V8_FT_ADAPTOR               V8DBG_FRAMETYPE_ARGUMENTSADAPTORFRAME
 #define V8_FT_STUB                  V8DBG_FRAMETYPE_STUBFRAME
 
 /* Identification masks and tags */
@@ -91,7 +90,8 @@
     V8_OFF_HEAP(             \
       V8DBG_CLASS_SHAREDFUNCTIONINFO__NAME_OR_SCOPE_INFO__OBJECT)
 #define V8_OFF_SHARED_SCRIPT  \
-    V8_OFF_HEAP(V8DBG_CLASS_SHAREDFUNCTIONINFO__SCRIPT_OR_DEBUG_INFO__OBJECT)
+    V8_OFF_HEAP(              \
+        V8DBG_CLASS_SHAREDFUNCTIONINFO__SCRIPT_OR_DEBUG_INFO__HEAPOBJECT)
 #define V8_OFF_SHARED_FUNIDENT \
     V8_OFF_HEAP(               \
       V8DBG_CLASS_SHAREDFUNCTIONINFO__NAME_OR_SCOPE_INFO__OBJECT)

package/src/headers/10/aliased_buffer.h

@@ -1,241 +0,0 @@
-#ifndef SRC_ALIASED_BUFFER_H_
-#define SRC_ALIASED_BUFFER_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "v8.h"
-#include "util-inl.h"
-
-namespace node {
-
-/**
- * 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>
-class AliasedBuffer {
- public:
-  AliasedBuffer(v8::Isolate* isolate, const size_t count)
-      : isolate_(isolate),
-        count_(count),
-        byte_offset_(0),
-        free_buffer_(true) {
-    CHECK_GT(count, 0);
-    const v8::HandleScope handle_scope(isolate_);
-
-    const size_t sizeInBytes = sizeof(NativeT) * count;
-
-    // allocate native buffer
-    buffer_ = Calloc<NativeT>(count);
-
-    // allocate v8 ArrayBuffer
-    v8::Local<v8::ArrayBuffer> ab = v8::ArrayBuffer::New(
-        isolate_, buffer_, sizeInBytes);
-
-    // allocate v8 TypedArray
-    v8::Local<V8T> js_array = V8T::New(ab, byte_offset_, count);
-    js_array_ = v8::Global<V8T>(isolate, js_array);
-  }
-
-  /**
-   * Create an AliasedBuffer 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).
-   */
-  AliasedBuffer(v8::Isolate* isolate,
-                const size_t byte_offset,
-                const size_t count,
-                const AliasedBuffer<uint8_t,
-                v8::Uint8Array>& backing_buffer)
-      : isolate_(isolate),
-        count_(count),
-        byte_offset_(byte_offset),
-        free_buffer_(false) {
-    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(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);
-  }
-
-  AliasedBuffer(const AliasedBuffer& that)
-      : isolate_(that.isolate_),
-        count_(that.count_),
-        byte_offset_(that.byte_offset_),
-        buffer_(that.buffer_),
-        free_buffer_(false) {
-    js_array_ = v8::Global<V8T>(that.isolate_, that.GetJSArray());
-  }
-
-  ~AliasedBuffer() {
-    if (free_buffer_ && buffer_ != nullptr) {
-      free(buffer_);
-    }
-    js_array_.Reset();
-  }
-
-  AliasedBuffer& operator=(AliasedBuffer&& that) {
-    this->~AliasedBuffer();
-    isolate_ = that.isolate_;
-    count_ = that.count_;
-    byte_offset_ = that.byte_offset_;
-    buffer_ = that.buffer_;
-    free_buffer_ = that.free_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(AliasedBuffer<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:
-    AliasedBuffer<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) {
-#if defined(DEBUG) && DEBUG
-    CHECK_LT(index, count_);
-#endif
-    buffer_[index] = value;
-  }
-
-  /**
-   *  Get value at position index
-   */
-  inline const NativeT GetValue(const size_t index) const {
-#if defined(DEBUG) && DEBUG
-    CHECK_LT(index, count_);
-#endif
-    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_;
-  }
-
- private:
-  v8::Isolate* isolate_;
-  size_t count_;
-  size_t byte_offset_;
-  NativeT* buffer_;
-  v8::Global<V8T> js_array_;
-  bool free_buffer_;
-};
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ALIASED_BUFFER_H_

package/src/headers/10/async_wrap-inl.h

@@ -1,106 +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_ASYNC_WRAP_INL_H_
-#define SRC_ASYNC_WRAP_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "async_wrap.h"
-#include "base_object-inl.h"
-#include "node_internals.h"
-
-namespace node {
-
-inline AsyncWrap::ProviderType AsyncWrap::provider_type() const {
-  return provider_type_;
-}
-
-
-inline double AsyncWrap::get_async_id() const {
-  return async_id_;
-}
-
-
-inline double AsyncWrap::get_trigger_async_id() const {
-  return trigger_async_id_;
-}
-
-
-inline AsyncWrap::AsyncScope::AsyncScope(AsyncWrap* wrap)
-    : wrap_(wrap) {
-  Environment* env = wrap->env();
-  if (env->async_hooks()->fields()[Environment::AsyncHooks::kBefore] == 0)
-    return;
-  EmitBefore(env, wrap->get_async_id());
-}
-
-inline AsyncWrap::AsyncScope::~AsyncScope() {
-  Environment* env = wrap_->env();
-  if (env->async_hooks()->fields()[Environment::AsyncHooks::kAfter] == 0)
-    return;
-  EmitAfter(env, wrap_->get_async_id());
-}
-
-
-inline v8::MaybeLocal<v8::Value> AsyncWrap::MakeCallback(
-    const v8::Local<v8::String> symbol,
-    int argc,
-    v8::Local<v8::Value>* argv) {
-  return MakeCallback(symbol.As<v8::Name>(), argc, argv);
-}
-
-
-inline v8::MaybeLocal<v8::Value> AsyncWrap::MakeCallback(
-    const v8::Local<v8::Symbol> symbol,
-    int argc,
-    v8::Local<v8::Value>* argv) {
-  return MakeCallback(symbol.As<v8::Name>(), argc, argv);
-}
-
-
-inline v8::MaybeLocal<v8::Value> AsyncWrap::MakeCallback(
-    const v8::Local<v8::Name> symbol,
-    int argc,
-    v8::Local<v8::Value>* argv) {
-  v8::Local<v8::Value> cb_v;
-  if (!object()->Get(env()->context(), symbol).ToLocal(&cb_v))
-    return v8::MaybeLocal<v8::Value>();
-  if (!cb_v->IsFunction()) {
-    // TODO(addaleax): We should throw an error here to fulfill the
-    // `MaybeLocal<>` API contract.
-    return v8::MaybeLocal<v8::Value>();
-  }
-  return MakeCallback(cb_v.As<v8::Function>(), argc, argv);
-}
-
-
-// Defined here to avoid a circular dependency with env-inl.h.
-inline Environment::AsyncHooks::DefaultTriggerAsyncIdScope
-  ::DefaultTriggerAsyncIdScope(AsyncWrap* async_wrap)
-    : DefaultTriggerAsyncIdScope(async_wrap->env(),
-                                 async_wrap->get_async_id()) {}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ASYNC_WRAP_INL_H_

package/src/headers/10/async_wrap.h

@@ -1,218 +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_ASYNC_WRAP_H_
-#define SRC_ASYNC_WRAP_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "base_object.h"
-#include "v8.h"
-
-#include <stdint.h>
-
-namespace node {
-
-#define NODE_ASYNC_NON_CRYPTO_PROVIDER_TYPES(V)                               \
-  V(NONE)                                                                     \
-  V(DNSCHANNEL)                                                               \
-  V(FILEHANDLE)                                                               \
-  V(FILEHANDLECLOSEREQ)                                                       \
-  V(FSEVENTWRAP)                                                              \
-  V(FSREQWRAP)                                                                \
-  V(FSREQPROMISE)                                                             \
-  V(GETADDRINFOREQWRAP)                                                       \
-  V(GETNAMEINFOREQWRAP)                                                       \
-  V(HTTP2SESSION)                                                             \
-  V(HTTP2STREAM)                                                              \
-  V(HTTP2PING)                                                                \
-  V(HTTP2SETTINGS)                                                            \
-  V(HTTPPARSER)                                                               \
-  V(JSSTREAM)                                                                 \
-  V(MESSAGEPORT)                                                              \
-  V(PIPECONNECTWRAP)                                                          \
-  V(PIPESERVERWRAP)                                                           \
-  V(PIPEWRAP)                                                                 \
-  V(PROCESSWRAP)                                                              \
-  V(PROMISE)                                                                  \
-  V(QUERYWRAP)                                                                \
-  V(SHUTDOWNWRAP)                                                             \
-  V(SIGNALWRAP)                                                               \
-  V(STATWATCHER)                                                              \
-  V(STREAMPIPE)                                                               \
-  V(TCPCONNECTWRAP)                                                           \
-  V(TCPSERVERWRAP)                                                            \
-  V(TCPWRAP)                                                                  \
-  V(TIMERWRAP)                                                                \
-  V(TTYWRAP)                                                                  \
-  V(UDPSENDWRAP)                                                              \
-  V(UDPWRAP)                                                                  \
-  V(WORKER)                                                                   \
-  V(WRITEWRAP)                                                                \
-  V(ZLIB)
-
-#if HAVE_OPENSSL
-#define NODE_ASYNC_CRYPTO_PROVIDER_TYPES(V)                                   \
-  V(PBKDF2REQUEST)                                                            \
-  V(KEYPAIRGENREQUEST)                                                        \
-  V(RANDOMBYTESREQUEST)                                                       \
-  V(SCRYPTREQUEST)                                                            \
-  V(TLSWRAP)
-#else
-#define NODE_ASYNC_CRYPTO_PROVIDER_TYPES(V)
-#endif  // HAVE_OPENSSL
-
-#if HAVE_INSPECTOR
-#define NODE_ASYNC_INSPECTOR_PROVIDER_TYPES(V)                                \
-  V(INSPECTORJSBINDING)
-#else
-#define NODE_ASYNC_INSPECTOR_PROVIDER_TYPES(V)
-#endif  // HAVE_INSPECTOR
-
-#define NODE_ASYNC_PROVIDER_TYPES(V)                                          \
-  NODE_ASYNC_NON_CRYPTO_PROVIDER_TYPES(V)                                     \
-  NODE_ASYNC_CRYPTO_PROVIDER_TYPES(V)                                         \
-  NODE_ASYNC_INSPECTOR_PROVIDER_TYPES(V)
-
-class Environment;
-class DestroyParam;
-
-class AsyncWrap : public BaseObject {
- public:
-  enum ProviderType {
-#define V(PROVIDER)                                                           \
-    PROVIDER_ ## PROVIDER,
-    NODE_ASYNC_PROVIDER_TYPES(V)
-#undef V
-    PROVIDERS_LENGTH,
-  };
-
-  AsyncWrap(Environment* env,
-            v8::Local<v8::Object> object,
-            ProviderType provider,
-            double execution_async_id = kInvalidAsyncId);
-
-  virtual ~AsyncWrap();
-
-  static constexpr double kInvalidAsyncId = -1;
-
-  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
-      Environment* env);
-
-  static void Initialize(v8::Local<v8::Object> target,
-                         v8::Local<v8::Value> unused,
-                         v8::Local<v8::Context> context);
-
-  static void GetAsyncId(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void PushAsyncIds(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void PopAsyncIds(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void AsyncReset(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void QueueDestroyAsyncId(
-    const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void EmitAsyncInit(Environment* env,
-                            v8::Local<v8::Object> object,
-                            v8::Local<v8::String> type,
-                            double async_id,
-                            double trigger_async_id);
-
-  static void EmitDestroy(Environment* env, double async_id);
-  static void EmitBefore(Environment* env, double async_id);
-  static void EmitAfter(Environment* env, double async_id);
-  static void EmitPromiseResolve(Environment* env, double async_id);
-
-  void EmitDestroy();
-
-  void EmitTraceEventBefore();
-  static void EmitTraceEventAfter(ProviderType type, double async_id);
-  void EmitTraceEventDestroy();
-
-  static void DestroyAsyncIdsCallback(Environment* env, void* data);
-
-  inline ProviderType provider_type() const;
-
-  inline double get_async_id() const;
-
-  inline double get_trigger_async_id() const;
-
-  void AsyncReset(double execution_async_id = kInvalidAsyncId,
-                  bool silent = false);
-
-  // Only call these within a valid HandleScope.
-  v8::MaybeLocal<v8::Value> MakeCallback(const v8::Local<v8::Function> cb,
-                                         int argc,
-                                         v8::Local<v8::Value>* argv);
-  inline v8::MaybeLocal<v8::Value> MakeCallback(
-      const v8::Local<v8::Symbol> symbol,
-      int argc,
-      v8::Local<v8::Value>* argv);
-  inline v8::MaybeLocal<v8::Value> MakeCallback(
-      const v8::Local<v8::String> symbol,
-      int argc,
-      v8::Local<v8::Value>* argv);
-  inline v8::MaybeLocal<v8::Value> MakeCallback(
-      const v8::Local<v8::Name> symbol,
-      int argc,
-      v8::Local<v8::Value>* argv);
-
-  virtual std::string diagnostic_name() const;
-  virtual std::string MemoryInfoName() const;
-
-  static void WeakCallback(const v8::WeakCallbackInfo<DestroyParam> &info);
-
-  // Returns the object that 'owns' an async wrap. For example, for a
-  // TCP connection handle, this is the corresponding net.Socket.
-  v8::Local<v8::Object> GetOwner();
-  static v8::Local<v8::Object> GetOwner(Environment* env,
-                                        v8::Local<v8::Object> obj);
-
-  // This is a simplified version of InternalCallbackScope that only runs
-  // the `before` and `after` hooks. Only use it when not actually calling
-  // back into JS; otherwise, use InternalCallbackScope.
-  class AsyncScope {
-   public:
-    explicit inline AsyncScope(AsyncWrap* wrap);
-    ~AsyncScope();
-
-   private:
-    AsyncWrap* wrap_ = nullptr;
-  };
-
- private:
-  friend class PromiseWrap;
-
-  AsyncWrap(Environment* env,
-            v8::Local<v8::Object> promise,
-            ProviderType provider,
-            double execution_async_id,
-            bool silent);
-  inline AsyncWrap();
-  const ProviderType provider_type_;
-  // Because the values may be Reset(), cannot be made const.
-  double async_id_ = kInvalidAsyncId;
-  double trigger_async_id_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_ASYNC_WRAP_H_