@encharm/cws 4.4.1 → 4.5.1

package/src/headers/14/callback_queue-inl.h

@@ -1,97 +0,0 @@
-#ifndef SRC_CALLBACK_QUEUE_INL_H_
-#define SRC_CALLBACK_QUEUE_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "callback_queue.h"
-
-namespace node {
-
-template <typename R, typename... Args>
-template <typename Fn>
-std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
-CallbackQueue<R, Args...>::CreateCallback(Fn&& fn, CallbackFlags::Flags flags) {
-  return std::make_unique<CallbackImpl<Fn>>(std::move(fn), flags);
-}
-
-template <typename R, typename... Args>
-std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
-CallbackQueue<R, Args...>::Shift() {
-  std::unique_ptr<Callback> ret = std::move(head_);
-  if (ret) {
-    head_ = ret->get_next();
-    if (!head_)
-      tail_ = nullptr;  // The queue is now empty.
-  }
-  size_--;
-  return ret;
-}
-
-template <typename R, typename... Args>
-void CallbackQueue<R, Args...>::Push(std::unique_ptr<Callback> cb) {
-  Callback* prev_tail = tail_;
-
-  size_++;
-  tail_ = cb.get();
-  if (prev_tail != nullptr)
-    prev_tail->set_next(std::move(cb));
-  else
-    head_ = std::move(cb);
-}
-
-template <typename R, typename... Args>
-void CallbackQueue<R, Args...>::ConcatMove(CallbackQueue<R, Args...>&& other) {
-  size_ += other.size_;
-  if (tail_ != nullptr)
-    tail_->set_next(std::move(other.head_));
-  else
-    head_ = std::move(other.head_);
-  tail_ = other.tail_;
-  other.tail_ = nullptr;
-  other.size_ = 0;
-}
-
-template <typename R, typename... Args>
-size_t CallbackQueue<R, Args...>::size() const {
-  return size_.load();
-}
-
-template <typename R, typename... Args>
-CallbackQueue<R, Args...>::Callback::Callback(CallbackFlags::Flags flags)
-  : flags_(flags) {}
-
-template <typename R, typename... Args>
-CallbackFlags::Flags CallbackQueue<R, Args...>::Callback::flags() const {
-  return flags_;
-}
-
-template <typename R, typename... Args>
-std::unique_ptr<typename CallbackQueue<R, Args...>::Callback>
-CallbackQueue<R, Args...>::Callback::get_next() {
-  return std::move(next_);
-}
-
-template <typename R, typename... Args>
-void CallbackQueue<R, Args...>::Callback::set_next(
-    std::unique_ptr<Callback> next) {
-  next_ = std::move(next);
-}
-
-template <typename R, typename... Args>
-template <typename Fn>
-CallbackQueue<R, Args...>::CallbackImpl<Fn>::CallbackImpl(
-    Fn&& callback, CallbackFlags::Flags flags)
-  : Callback(flags),
-    callback_(std::move(callback)) {}
-
-template <typename R, typename... Args>
-template <typename Fn>
-R CallbackQueue<R, Args...>::CallbackImpl<Fn>::Call(Args... args) {
-  return callback_(std::forward<Args>(args)...);
-}
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_CALLBACK_QUEUE_INL_H_

package/src/headers/14/callback_queue.h

@@ -1,78 +0,0 @@
-#ifndef SRC_CALLBACK_QUEUE_H_
-#define SRC_CALLBACK_QUEUE_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <atomic>
-
-namespace node {
-
-namespace CallbackFlags {
-enum Flags {
-  kUnrefed = 0,
-  kRefed = 1,
-};
-}
-
-// A queue of C++ functions that take Args... as arguments and return R
-// (this is similar to the signature of std::function).
-// New entries are added using `CreateCallback()`/`Push()`, and removed using
-// `Shift()`.
-// The `refed` flag is left for easier use in situations in which some of these
-// should be run even if nothing else is keeping the event loop alive.
-template <typename R, typename... Args>
-class CallbackQueue {
- public:
-  class Callback {
-   public:
-    explicit inline Callback(CallbackFlags::Flags flags);
-
-    virtual ~Callback() = default;
-    virtual R Call(Args... args) = 0;
-
-    inline CallbackFlags::Flags flags() const;
-
-   private:
-    inline std::unique_ptr<Callback> get_next();
-    inline void set_next(std::unique_ptr<Callback> next);
-
-    CallbackFlags::Flags flags_;
-    std::unique_ptr<Callback> next_;
-
-    friend class CallbackQueue;
-  };
-
-  template <typename Fn>
-  inline std::unique_ptr<Callback> CreateCallback(
-      Fn&& fn, CallbackFlags::Flags);
-
-  inline std::unique_ptr<Callback> Shift();
-  inline void Push(std::unique_ptr<Callback> cb);
-  // ConcatMove adds elements from 'other' to the end of this list, and clears
-  // 'other' afterwards.
-  inline void ConcatMove(CallbackQueue&& other);
-
-  // size() is atomic and may be called from any thread.
-  inline size_t size() const;
-
- private:
-  template <typename Fn>
-  class CallbackImpl final : public Callback {
-   public:
-    CallbackImpl(Fn&& callback, CallbackFlags::Flags flags);
-    R Call(Args... args) override;
-
-   private:
-    Fn callback_;
-  };
-
-  std::atomic<size_t> size_ {0};
-  std::unique_ptr<Callback> head_;
-  Callback* tail_ = nullptr;
-};
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_CALLBACK_QUEUE_H_

package/src/headers/14/debug_utils-inl.h

@@ -1,223 +0,0 @@
-#ifndef SRC_DEBUG_UTILS_INL_H_
-#define SRC_DEBUG_UTILS_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "debug_utils.h"
-#include "env.h"
-
-#include <type_traits>
-
-namespace node {
-
-struct ToStringHelper {
-  template <typename T>
-  static std::string Convert(
-      const T& value,
-      std::string(T::* to_string)() const = &T::ToString) {
-    return (value.*to_string)();
-  }
-  template <typename T,
-            typename test_for_number = typename std::
-                enable_if<std::is_arithmetic<T>::value, bool>::type,
-            typename dummy = bool>
-  static std::string Convert(const T& value) { return std::to_string(value); }
-  static std::string Convert(const char* value) {
-    return value != nullptr ? value : "(null)";
-  }
-  static std::string Convert(const std::string& value) { return value; }
-  static std::string Convert(bool value) { return value ? "true" : "false"; }
-  template <unsigned BASE_BITS,
-            typename T,
-            typename std::enable_if<std::is_integral<T>::value, int>::type = 0>
-  static std::string BaseConvert(const T& value) {
-    auto v = static_cast<uint64_t>(value);
-    char ret[3 * sizeof(T)];
-    char* ptr = ret + 3 * sizeof(T) - 1;
-    *ptr = '\0';
-    const char* digits = "0123456789abcdef";
-    do {
-      unsigned digit = v & ((1 << BASE_BITS) - 1);
-      *--ptr =
-          (BASE_BITS < 4 ? static_cast<char>('0' + digit) : digits[digit]);
-    } while ((v >>= BASE_BITS) != 0);
-    return ptr;
-  }
-  template <unsigned BASE_BITS,
-            typename T,
-            typename std::enable_if<!std::is_integral<T>::value, int>::type = 0>
-  static std::string BaseConvert(T value) {
-    return Convert(std::forward<T>(value));
-  }
-};
-
-template <typename T>
-std::string ToString(const T& value) {
-  return ToStringHelper::Convert(value);
-}
-
-template <unsigned BASE_BITS, typename T>
-std::string ToBaseString(const T& value) {
-  return ToStringHelper::BaseConvert<BASE_BITS>(value);
-}
-
-inline std::string SPrintFImpl(const char* format) {
-  const char* p = strchr(format, '%');
-  if (LIKELY(p == nullptr)) return format;
-  CHECK_EQ(p[1], '%');  // Only '%%' allowed when there are no arguments.
-
-  return std::string(format, p + 1) + SPrintFImpl(p + 2);
-}
-
-template <typename Arg, typename... Args>
-std::string COLD_NOINLINE SPrintFImpl(  // NOLINT(runtime/string)
-    const char* format, Arg&& arg, Args&&... args) {
-  const char* p = strchr(format, '%');
-  CHECK_NOT_NULL(p);  // If you hit this, you passed in too many arguments.
-  std::string ret(format, p);
-  // Ignore long / size_t modifiers
-  while (strchr("lz", *++p) != nullptr) {}
-  switch (*p) {
-    case '%': {
-      return ret + '%' + SPrintFImpl(p + 1,
-                                     std::forward<Arg>(arg),
-                                     std::forward<Args>(args)...);
-    }
-    default: {
-      return ret + '%' + SPrintFImpl(p,
-                                     std::forward<Arg>(arg),
-                                     std::forward<Args>(args)...);
-    }
-    case 'd':
-    case 'i':
-    case 'u':
-    case 's':
-      ret += ToString(arg);
-      break;
-    case 'o':
-      ret += ToBaseString<3>(arg);
-      break;
-    case 'x':
-      ret += ToBaseString<4>(arg);
-      break;
-    case 'X':
-      ret += node::ToUpper(ToBaseString<4>(arg));
-      break;
-    case 'p': {
-      CHECK(std::is_pointer<typename std::remove_reference<Arg>::type>::value);
-      char out[20];
-      int n = snprintf(out,
-                       sizeof(out),
-                       "%p",
-                       *reinterpret_cast<const void* const*>(&arg));
-      CHECK_GE(n, 0);
-      ret += out;
-      break;
-    }
-  }
-  return ret + SPrintFImpl(p + 1, std::forward<Args>(args)...);
-}
-
-template <typename... Args>
-std::string COLD_NOINLINE SPrintF(  // NOLINT(runtime/string)
-    const char* format, Args&&... args) {
-  return SPrintFImpl(format, std::forward<Args>(args)...);
-}
-
-template <typename... Args>
-void COLD_NOINLINE FPrintF(FILE* file, const char* format, Args&&... args) {
-  FWrite(file, SPrintF(format, std::forward<Args>(args)...));
-}
-
-template <typename... Args>
-inline void FORCE_INLINE Debug(EnabledDebugList* list,
-                               DebugCategory cat,
-                               const char* format,
-                               Args&&... args) {
-  if (!UNLIKELY(list->enabled(cat))) return;
-  FPrintF(stderr, format, std::forward<Args>(args)...);
-}
-
-inline void FORCE_INLINE Debug(EnabledDebugList* list,
-                               DebugCategory cat,
-                               const char* message) {
-  if (!UNLIKELY(list->enabled(cat))) return;
-  FPrintF(stderr, "%s", message);
-}
-
-template <typename... Args>
-inline void FORCE_INLINE
-Debug(Environment* env, DebugCategory cat, const char* format, Args&&... args) {
-  Debug(env->enabled_debug_list(), cat, format, std::forward<Args>(args)...);
-}
-
-inline void FORCE_INLINE Debug(Environment* env,
-                               DebugCategory cat,
-                               const char* message) {
-  Debug(env->enabled_debug_list(), cat, message);
-}
-
-template <typename... Args>
-inline void Debug(Environment* env,
-                  DebugCategory cat,
-                  const std::string& format,
-                  Args&&... args) {
-  Debug(env->enabled_debug_list(),
-        cat,
-        format.c_str(),
-        std::forward<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) {
-  Debug(async_wrap->env(),
-        static_cast<DebugCategory>(async_wrap->provider_type()),
-        async_wrap->diagnostic_name() + " " + format + "\n",
-        std::forward<Args>(args)...);
-}
-
-template <typename... Args>
-inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
-                               const char* format,
-                               Args&&... args) {
-  DCHECK_NOT_NULL(async_wrap);
-  DebugCategory cat = static_cast<DebugCategory>(async_wrap->provider_type());
-  if (!UNLIKELY(async_wrap->env()->enabled_debug_list()->enabled(cat))) return;
-  UnconditionalAsyncWrapDebug(async_wrap, format, std::forward<Args>(args)...);
-}
-
-template <typename... Args>
-inline void FORCE_INLINE Debug(AsyncWrap* async_wrap,
-                               const std::string& format,
-                               Args&&... args) {
-  Debug(async_wrap, format.c_str(), std::forward<Args>(args)...);
-}
-
-namespace per_process {
-
-template <typename... Args>
-inline void FORCE_INLINE Debug(DebugCategory cat,
-                               const char* format,
-                               Args&&... args) {
-  Debug(&enabled_debug_list, cat, format, std::forward<Args>(args)...);
-}
-
-inline void FORCE_INLINE Debug(DebugCategory cat, const char* message) {
-  Debug(&enabled_debug_list, cat, message);
-}
-
-}  // namespace per_process
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_DEBUG_UTILS_INL_H_

package/src/headers/14/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_