@encharm/cws 4.4.1 → 4.5.1

package/src/headers/18/json_utils.h

@@ -1,161 +0,0 @@
-#ifndef SRC_JSON_UTILS_H_
-#define SRC_JSON_UTILS_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <iomanip>
-#include <ostream>
-#include <limits>
-#include <string>
-
-namespace node {
-
-std::string EscapeJsonChars(const std::string& str);
-std::string Reindent(const std::string& str, int indentation);
-
-// JSON compiler definitions.
-class JSONWriter {
- public:
-  JSONWriter(std::ostream& out, bool compact)
-    : out_(out), compact_(compact) {}
-
- private:
-  inline void indent() { indent_ += 2; }
-  inline void deindent() { indent_ -= 2; }
-  inline void advance() {
-    if (compact_) return;
-    for (int i = 0; i < indent_; i++) out_ << ' ';
-  }
-  inline void write_one_space() {
-    if (compact_) return;
-    out_ << ' ';
-  }
-  inline void write_new_line() {
-    if (compact_) return;
-    out_ << '\n';
-  }
-
- public:
-  inline void json_start() {
-    if (state_ == kAfterValue) out_ << ',';
-    write_new_line();
-    advance();
-    out_ << '{';
-    indent();
-    state_ = kObjectStart;
-  }
-
-  inline void json_end() {
-    write_new_line();
-    deindent();
-    advance();
-    out_ << '}';
-    state_ = kAfterValue;
-  }
-  template <typename T>
-  inline void json_objectstart(T key) {
-    if (state_ == kAfterValue) out_ << ',';
-    write_new_line();
-    advance();
-    write_string(key);
-    out_ << ':';
-    write_one_space();
-    out_ << '{';
-    indent();
-    state_ = kObjectStart;
-  }
-
-  template <typename T>
-  inline void json_arraystart(T key) {
-    if (state_ == kAfterValue) out_ << ',';
-    write_new_line();
-    advance();
-    write_string(key);
-    out_ << ':';
-    write_one_space();
-    out_ << '[';
-    indent();
-    state_ = kObjectStart;
-  }
-  inline void json_objectend() {
-    write_new_line();
-    deindent();
-    advance();
-    out_ << '}';
-    if (indent_ == 0) {
-      // Top-level object is complete, so end the line.
-      out_ << '\n';
-    }
-    state_ = kAfterValue;
-  }
-
-  inline void json_arrayend() {
-    write_new_line();
-    deindent();
-    advance();
-    out_ << ']';
-    state_ = kAfterValue;
-  }
-  template <typename T, typename U>
-  inline void json_keyvalue(const T& key, const U& value) {
-    if (state_ == kAfterValue) out_ << ',';
-    write_new_line();
-    advance();
-    write_string(key);
-    out_ << ':';
-    write_one_space();
-    write_value(value);
-    state_ = kAfterValue;
-  }
-
-  template <typename U>
-  inline void json_element(const U& value) {
-    if (state_ == kAfterValue) out_ << ',';
-    write_new_line();
-    advance();
-    write_value(value);
-    state_ = kAfterValue;
-  }
-
-  struct Null {};  // Usable as a JSON value.
-
-  struct ForeignJSON {
-    std::string as_string;
-  };
-
- private:
-  template <typename T,
-            typename test_for_number = typename std::
-                enable_if<std::numeric_limits<T>::is_specialized, bool>::type>
-  inline void write_value(T number) {
-    if (std::is_same<T, bool>::value)
-      out_ << (number ? "true" : "false");
-    else
-      out_ << number;
-  }
-
-  inline void write_value(Null null) { out_ << "null"; }
-  inline void write_value(const char* str) { write_string(str); }
-  inline void write_value(const std::string& str) { write_string(str); }
-
-  inline void write_value(const ForeignJSON& json) {
-    out_ << Reindent(json.as_string, indent_);
-  }
-
-  inline void write_string(const std::string& str) {
-    out_ << '"' << EscapeJsonChars(str) << '"';
-  }
-  inline void write_string(const char* str) { write_string(std::string(str)); }
-
-  enum JSONState { kObjectStart, kAfterValue };
-  std::ostream& out_;
-  bool compact_;
-  int indent_ = 0;
-  int state_ = kObjectStart;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_JSON_UTILS_H_

package/src/headers/18/memory_tracker.h

@@ -1,284 +0,0 @@
-#pragma once
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "aliased_buffer.h"
-#include "v8-profiler.h"
-
-#include <uv.h>
-
-#include <limits>
-#include <queue>
-#include <stack>
-#include <string>
-#include <unordered_map>
-
-namespace node {
-
-// Set the node name of a MemoryRetainer to klass
-#define SET_MEMORY_INFO_NAME(Klass)                                            \
-  inline std::string MemoryInfoName() const override { return #Klass; }
-
-// Set the self size of a MemoryRetainer to the stack-allocated size of a
-// certain class
-#define SET_SELF_SIZE(Klass)                                                   \
-  inline size_t SelfSize() const override { return sizeof(Klass); }
-
-// Used when there is no additional fields to track
-#define SET_NO_MEMORY_INFO()                                                   \
-  inline void MemoryInfo(node::MemoryTracker* tracker) const override {}
-
-class MemoryTracker;
-class MemoryRetainerNode;
-template <typename T, bool kIsWeak>
-class BaseObjectPtrImpl;
-
-namespace crypto {
-class NodeBIO;
-}
-
-class CleanupHookCallback;
-
-/* Example:
- *
- * class ExampleRetainer : public MemoryRetainer {
- *   public:
- *     // Or use SET_NO_MEMORY_INFO() when there is no additional fields
- *     // to track.
- *     void MemoryInfo(MemoryTracker* tracker) const override {
- *       // Node name and size comes from the MemoryInfoName and SelfSize of
- *       // AnotherRetainerClass
- *       tracker->TrackField("another_retainer", another_retainer_);
- *
- *       // Add non_pointer_retainer as a separate node into the graph
- *       // and track its memory information recursively.
- *       // Note that we need to make sure its size is not accounted in
- *       // ExampleRetainer::SelfSize().
- *       tracker->TrackField("non_pointer_retainer", &non_pointer_retainer_);
- *
- *       // Specify node name and size explicitly
- *       tracker->TrackFieldWithSize("internal_member",
- *                                   internal_member_.size(),
- *                                   "InternalClass");
- *       // Node name falls back to the edge name,
- *       // elements in the container appear as grandchildren nodes
- *       tracker->TrackField("vector", vector_);
- *       // Node name and size come from the JS object
- *       tracker->TrackField("target", target_);
- *     }
- *
- *     // Or use SET_MEMORY_INFO_NAME(ExampleRetainer)
- *     std::string MemoryInfoName() const override {
- *       return "ExampleRetainer";
- *     }
- *
- *     // Classes that only want to return its sizeof() value can use the
- *     // SET_SELF_SIZE(Class) macro instead.
- *     size_t SelfSize() const override {
- *       // We need to exclude the size of non_pointer_retainer so that
- *       // we can track it separately in ExampleRetainer::MemoryInfo().
- *       return sizeof(ExampleRetainer) - sizeof(NonPointerRetainerClass);
- *     }
- *
- *     // Note: no need to implement these two methods when implementing
- *     // a BaseObject or an AsyncWrap class
- *     bool IsRootNode() const override { return !wrapped_.IsWeak(); }
- *     v8::Local<v8::Object> WrappedObject() const override {
- *       return node::PersistentToLocal::Default(wrapped_);
- *     }
- *
- *   private:
- *     AnotherRetainerClass* another_retainer_;
- *     NonPointerRetainerClass non_pointer_retainer;
- *     InternalClass internal_member_;
- *     std::vector<uv_async_t> vector_;
- *     v8::Global<Object> target_;
- *
- *     v8::Global<Object> wrapped_;
- * }
- *
- * This creates the following graph:
- *   Node / ExampleRetainer
- *    |> another_retainer :: Node / AnotherRetainerClass
- *    |> internal_member :: Node / InternalClass
- *    |> vector :: Node / vector (elements will be grandchildren)
- *        |> [1] :: Node / uv_async_t (uv_async_t has predefined names)
- *        |> [2] :: Node / uv_async_t
- *        |> ...
- *    |> target :: TargetClass (JS class name of the target object)
- *    |> wrapped :: WrappedClass (JS class name of the wrapped object)
- *        |> wrapper :: Node / ExampleRetainer (back reference)
- */
-class MemoryRetainer {
- public:
-  virtual ~MemoryRetainer() = default;
-
-  // Subclasses should implement these methods to provide information
-  // for the V8 heap snapshot generator.
-  // The MemoryInfo() method is assumed to be called within a context
-  // where all the edges start from the node of the current retainer,
-  // and point to the nodes as specified by tracker->Track* calls.
-  virtual void MemoryInfo(MemoryTracker* tracker) const = 0;
-  virtual std::string MemoryInfoName() const = 0;
-  virtual size_t SelfSize() const = 0;
-
-  virtual v8::Local<v8::Object> WrappedObject() const {
-    return v8::Local<v8::Object>();
-  }
-
-  virtual bool IsRootNode() const { return false; }
-};
-
-class MemoryTracker {
- public:
-  // Used to specify node name and size explicitly
-  inline void TrackFieldWithSize(const char* edge_name,
-                                 size_t size,
-                                 const char* node_name = nullptr);
-  inline void TrackInlineFieldWithSize(const char* edge_name,
-                                       size_t size,
-                                       const char* node_name = nullptr);
-
-  // Shortcut to extract the underlying object out of the smart pointer
-  template <typename T, typename D>
-  inline void TrackField(const char* edge_name,
-                         const std::unique_ptr<T, D>& value,
-                         const char* node_name = nullptr);
-
-  template <typename T>
-  inline void TrackField(const char* edge_name,
-                         const std::shared_ptr<T>& value,
-                         const char* node_name = nullptr);
-
-  template <typename T, bool kIsWeak>
-  void TrackField(const char* edge_name,
-                  const BaseObjectPtrImpl<T, kIsWeak>& value,
-                  const char* node_name = nullptr);
-
-  // For containers, the elements will be graphed as grandchildren nodes
-  // if the container is not empty.
-  // By default, we assume the parent count the stack size of the container
-  // into its SelfSize so that will be subtracted from the parent size when we
-  // spin off a new node for the container.
-  // TODO(joyeecheung): use RTTI to retrieve the class name at runtime?
-  template <typename T, typename Iterator = typename T::const_iterator>
-  inline void TrackField(const char* edge_name,
-                         const T& value,
-                         const char* node_name = nullptr,
-                         const char* element_name = nullptr,
-                         bool subtract_from_self = true);
-  template <typename T>
-  inline void TrackField(const char* edge_name,
-                         const std::queue<T>& value,
-                         const char* node_name = nullptr,
-                         const char* element_name = nullptr);
-  template <typename T, typename U>
-  inline void TrackField(const char* edge_name,
-                         const std::pair<T, U>& value,
-                         const char* node_name = nullptr);
-
-  // For the following types, node_name will be ignored and predefined names
-  // will be used instead. They are only in the signature for template
-  // expansion.
-  inline void TrackField(const char* edge_name,
-                         const MemoryRetainer& value,
-                         const char* node_name = nullptr);
-  inline void TrackField(const char* edge_name,
-                         const MemoryRetainer* value,
-                         const char* node_name = nullptr);
-  template <typename T>
-  inline void TrackField(const char* edge_name,
-                         const std::basic_string<T>& value,
-                         const char* node_name = nullptr);
-  template <typename T,
-            typename test_for_number = typename std::
-                enable_if<std::numeric_limits<T>::is_specialized, bool>::type,
-            typename dummy = bool>
-  inline void TrackField(const char* edge_name,
-                         const T& value,
-                         const char* node_name = nullptr);
-  template <typename T>
-  void TrackField(const char* edge_name,
-                  const v8::Eternal<T>& value,
-                  const char* node_name);
-  template <typename T>
-  inline void TrackField(const char* edge_name,
-                         const v8::PersistentBase<T>& value,
-                         const char* node_name = nullptr);
-  template <typename T>
-  inline void TrackField(const char* edge_name,
-                         const v8::Local<T>& value,
-                         const char* node_name = nullptr);
-  template <typename T>
-  inline void TrackField(const char* edge_name,
-                         const MallocedBuffer<T>& value,
-                         const char* node_name = nullptr);
-  inline void TrackField(const char* edge_name,
-                         const v8::BackingStore* value,
-                         const char* node_name = nullptr);
-  inline void TrackField(const char* edge_name,
-                         const uv_buf_t& value,
-                         const char* node_name = nullptr);
-  inline void TrackField(const char* edge_name,
-                         const uv_timer_t& value,
-                         const char* node_name = nullptr);
-  inline void TrackField(const char* edge_name,
-                         const uv_async_t& value,
-                         const char* node_name = nullptr);
-  inline void TrackInlineField(const char* edge_name,
-                               const uv_async_t& value,
-                               const char* node_name = nullptr);
-  template <class NativeT, class V8T>
-  inline void TrackField(const char* edge_name,
-                         const AliasedBufferBase<NativeT, V8T>& value,
-                         const char* node_name = nullptr);
-
-  // Put a memory container into the graph, create an edge from
-  // the current node if there is one on the stack.
-  inline void Track(const MemoryRetainer* retainer,
-                    const char* edge_name = nullptr);
-
-  // Useful for parents that do not wish to perform manual
-  // adjustments to its `SelfSize()` when embedding retainer
-  // objects inline.
-  // Put a memory container into the graph, create an edge from
-  // the current node if there is one on the stack - there should
-  // be one, of the container object which the current field is part of.
-  // Reduce the size of memory from the container so as to avoid
-  // duplication in accounting.
-  inline void TrackInlineField(const MemoryRetainer* retainer,
-                               const char* edge_name = nullptr);
-
-  inline v8::EmbedderGraph* graph() { return graph_; }
-  inline v8::Isolate* isolate() { return isolate_; }
-
-  inline explicit MemoryTracker(v8::Isolate* isolate,
-                                v8::EmbedderGraph* graph)
-    : isolate_(isolate), graph_(graph) {}
-
- private:
-  typedef std::unordered_map<const MemoryRetainer*, MemoryRetainerNode*>
-      NodeMap;
-
-  inline MemoryRetainerNode* CurrentNode() const;
-  inline MemoryRetainerNode* AddNode(const MemoryRetainer* retainer,
-                                     const char* edge_name = nullptr);
-  inline MemoryRetainerNode* PushNode(const MemoryRetainer* retainer,
-                                      const char* edge_name = nullptr);
-  inline MemoryRetainerNode* AddNode(const char* node_name,
-                                     size_t size,
-                                     const char* edge_name = nullptr);
-  inline MemoryRetainerNode* PushNode(const char* node_name,
-                                      size_t size,
-                                      const char* edge_name = nullptr);
-  inline void PopNode();
-
-  v8::Isolate* isolate_;
-  v8::EmbedderGraph* graph_;
-  std::stack<MemoryRetainerNode*> node_stack_;
-  NodeMap seen_;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS

package/src/headers/18/module_wrap.h

@@ -1,116 +0,0 @@
-#ifndef SRC_MODULE_WRAP_H_
-#define SRC_MODULE_WRAP_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <unordered_map>
-#include <string>
-#include <vector>
-#include "base_object.h"
-
-namespace node {
-
-class Environment;
-
-namespace contextify {
-class ContextifyContext;
-}
-
-namespace loader {
-
-enum ScriptType : int {
-  kScript,
-  kModule,
-  kFunction,
-};
-
-enum HostDefinedOptions : int {
-  kType = 8,
-  kID = 9,
-  kLength = 10,
-};
-
-class ModuleWrap : public BaseObject {
- public:
-  enum InternalFields {
-    kModuleWrapBaseField = BaseObject::kInternalFieldCount,
-    kURLSlot,
-    kSyntheticEvaluationStepsSlot,
-    kContextObjectSlot,  // Object whose creation context is the target Context
-    kInternalFieldCount
-  };
-
-  static void Initialize(v8::Local<v8::Object> target,
-                         v8::Local<v8::Value> unused,
-                         v8::Local<v8::Context> context,
-                         void* priv);
-  static void HostInitializeImportMetaObjectCallback(
-      v8::Local<v8::Context> context,
-      v8::Local<v8::Module> module,
-      v8::Local<v8::Object> meta);
-
-  void MemoryInfo(MemoryTracker* tracker) const override {
-    tracker->TrackField("resolve_cache", resolve_cache_);
-  }
-
-  inline uint32_t id() { return id_; }
-  v8::Local<v8::Context> context() const;
-  static ModuleWrap* GetFromID(node::Environment*, uint32_t id);
-
-  SET_MEMORY_INFO_NAME(ModuleWrap)
-  SET_SELF_SIZE(ModuleWrap)
-
-  bool IsNotIndicativeOfMemoryLeakAtExit() const override {
-    // XXX: The garbage collection rules for ModuleWrap are *super* unclear.
-    // Do these objects ever get GC'd? Are we just okay with leaking them?
-    return true;
-  }
-
- private:
-  ModuleWrap(Environment* env,
-             v8::Local<v8::Object> object,
-             v8::Local<v8::Module> module,
-             v8::Local<v8::String> url);
-  ~ModuleWrap() override;
-
-  static void New(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Link(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Instantiate(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void Evaluate(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetNamespace(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetStatus(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetError(const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void GetStaticDependencySpecifiers(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static void SetImportModuleDynamicallyCallback(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void SetInitializeImportMetaObjectCallback(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static v8::MaybeLocal<v8::Value> SyntheticModuleEvaluationStepsCallback(
-      v8::Local<v8::Context> context, v8::Local<v8::Module> module);
-  static void SetSyntheticExport(
-      const v8::FunctionCallbackInfo<v8::Value>& args);
-  static void CreateCachedData(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-  static v8::MaybeLocal<v8::Module> ResolveModuleCallback(
-      v8::Local<v8::Context> context,
-      v8::Local<v8::String> specifier,
-      v8::Local<v8::FixedArray> import_assertions,
-      v8::Local<v8::Module> referrer);
-  static ModuleWrap* GetFromModule(node::Environment*, v8::Local<v8::Module>);
-
-  v8::Global<v8::Module> module_;
-  std::unordered_map<std::string, v8::Global<v8::Promise>> resolve_cache_;
-  contextify::ContextifyContext* contextify_context_ = nullptr;
-  bool synthetic_ = false;
-  bool linked_ = false;
-  uint32_t id_;
-};
-
-}  // namespace loader
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_MODULE_WRAP_H_

package/src/headers/18/node_binding.h

@@ -1,99 +0,0 @@
-#ifndef SRC_NODE_BINDING_H_
-#define SRC_NODE_BINDING_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#if defined(__POSIX__)
-#include <dlfcn.h>
-#endif
-
-#include "node.h"
-#define NAPI_EXPERIMENTAL
-#include "node_api.h"
-#include "uv.h"
-
-enum {
-  NM_F_BUILTIN = 1 << 0,  // Unused.
-  NM_F_LINKED = 1 << 1,
-  NM_F_INTERNAL = 1 << 2,
-  NM_F_DELETEME = 1 << 3,
-};
-
-// Make sure our internal values match the public API's values.
-static_assert(static_cast<int>(NM_F_LINKED) ==
-              static_cast<int>(node::ModuleFlags::kLinked),
-              "NM_F_LINKED != node::ModuleFlags::kLinked");
-
-#define NODE_MODULE_CONTEXT_AWARE_CPP(modname, regfunc, priv, flags)           \
-  static node::node_module _module = {                                         \
-      NODE_MODULE_VERSION,                                                     \
-      flags,                                                                   \
-      nullptr,                                                                 \
-      __FILE__,                                                                \
-      nullptr,                                                                 \
-      (node::addon_context_register_func)(regfunc),                            \
-      NODE_STRINGIFY(modname),                                                 \
-      priv,                                                                    \
-      nullptr};                                                                \
-  void _register_##modname() { node_module_register(&_module); }
-
-void napi_module_register_by_symbol(v8::Local<v8::Object> exports,
-                                    v8::Local<v8::Value> module,
-                                    v8::Local<v8::Context> context,
-                                    napi_addon_register_func init);
-
-namespace node {
-
-#define NODE_MODULE_CONTEXT_AWARE_INTERNAL(modname, regfunc)                   \
-  NODE_MODULE_CONTEXT_AWARE_CPP(modname, regfunc, nullptr, NM_F_INTERNAL)
-
-// Globals per process
-// This is set by node::Init() which is used by embedders
-extern bool node_is_initialized;
-
-namespace binding {
-
-class DLib {
- public:
-#ifdef __POSIX__
-  static const int kDefaultFlags = RTLD_LAZY;
-#else
-  static const int kDefaultFlags = 0;
-#endif
-
-  DLib(const char* filename, int flags);
-
-  bool Open();
-  void Close();
-  void* GetSymbolAddress(const char* name);
-  void SaveInGlobalHandleMap(node_module* mp);
-  node_module* GetSavedModuleFromGlobalHandleMap();
-
-  const std::string filename_;
-  const int flags_;
-  std::string errmsg_;
-  void* handle_;
-#ifndef __POSIX__
-  uv_lib_t lib_;
-#endif
-  bool has_entry_in_global_handle_map_ = false;
-
-  DLib(const DLib&) = delete;
-  DLib& operator=(const DLib&) = delete;
-};
-
-// Call _register<module_name> functions for all of
-// the built-in modules. Because built-in modules don't
-// use the __attribute__((constructor)). Need to
-// explicitly call the _register* functions.
-void RegisterBuiltinModules();
-void GetInternalBinding(const v8::FunctionCallbackInfo<v8::Value>& args);
-void GetLinkedBinding(const v8::FunctionCallbackInfo<v8::Value>& args);
-void DLOpen(const v8::FunctionCallbackInfo<v8::Value>& args);
-
-}  // namespace binding
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-#endif  // SRC_NODE_BINDING_H_