@encharm/cws 4.4.1 → 4.5.2

package/src/headers/14/base_object.h

@@ -1,281 +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_BASE_OBJECT_H_
-#define SRC_BASE_OBJECT_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include <type_traits>  // std::remove_reference
-#include "memory_tracker.h"
-#include "v8.h"
-
-namespace node {
-
-class Environment;
-template <typename T, bool kIsWeak>
-class BaseObjectPtrImpl;
-
-namespace worker {
-class TransferData;
-}
-
-class BaseObject : public MemoryRetainer {
- public:
-  enum InternalFields { kSlot, kInternalFieldCount };
-
-  // Associates this object with `object`. It uses the 0th internal field for
-  // that, and in particular aborts if there is no such field.
-  inline BaseObject(Environment* env, v8::Local<v8::Object> object);
-  inline ~BaseObject() override;
-
-  BaseObject() = delete;
-
-  // Returns the wrapped object.  Returns an empty handle when
-  // persistent.IsEmpty() is true.
-  inline v8::Local<v8::Object> object() const;
-
-  // Same as the above, except it additionally verifies that this object
-  // is associated with the passed Isolate in debug mode.
-  inline v8::Local<v8::Object> object(v8::Isolate* isolate) const;
-
-  inline v8::Global<v8::Object>& persistent();
-
-  inline Environment* env() const;
-
-  // Get a BaseObject* pointer, or subclass pointer, for the JS object that
-  // was also passed to the `BaseObject()` constructor initially.
-  // This may return `nullptr` if the C++ object has not been constructed yet,
-  // e.g. when the JS object used `MakeLazilyInitializedJSTemplate`.
-  static inline BaseObject* FromJSObject(v8::Local<v8::Value> object);
-  template <typename T>
-  static inline T* FromJSObject(v8::Local<v8::Value> object);
-
-  // Make the `v8::Global` a weak reference and, `delete` this object once
-  // the JS object has been garbage collected and there are no (strong)
-  // BaseObjectPtr references to it.
-  inline void MakeWeak();
-
-  // Undo `MakeWeak()`, i.e. turn this into a strong reference that is a GC
-  // root and will not be touched by the garbage collector.
-  inline void ClearWeak();
-
-  // Utility to create a FunctionTemplate with one internal field (used for
-  // the `BaseObject*` pointer) and a constructor that initializes that field
-  // to `nullptr`.
-  static inline v8::Local<v8::FunctionTemplate> MakeLazilyInitializedJSTemplate(
-      Environment* env);
-
-  // Setter/Getter pair for internal fields that can be passed to SetAccessor.
-  template <int Field>
-  static void InternalFieldGet(v8::Local<v8::String> property,
-                               const v8::PropertyCallbackInfo<v8::Value>& info);
-  template <int Field, bool (v8::Value::*typecheck)() const>
-  static void InternalFieldSet(v8::Local<v8::String> property,
-                               v8::Local<v8::Value> value,
-                               const v8::PropertyCallbackInfo<void>& info);
-
-  // This is a bit of a hack. See the override in async_wrap.cc for details.
-  virtual bool IsDoneInitializing() const;
-
-  // Can be used to avoid this object keepling itself alive as a GC root
-  // indefinitely, for example when this object is owned and deleted by another
-  // BaseObject once that is torn down. This can only be called when there is
-  // a BaseObjectPtr to this object.
-  inline void Detach();
-
-  static v8::Local<v8::FunctionTemplate> GetConstructorTemplate(
-      Environment* env);
-
-  // Interface for transferring BaseObject instances using the .postMessage()
-  // method of MessagePorts (and, by extension, Workers).
-  // GetTransferMode() returns a transfer mode that indicates how to deal with
-  // the current object:
-  // - kUntransferable:
-  //     No transfer is possible, either because this type of BaseObject does
-  //     not know how to be transfered, or because it is not in a state in
-  //     which it is possible to do so (e.g. because it has already been
-  //     transfered).
-  // - kTransferable:
-  //     This object can be transfered in a destructive fashion, i.e. will be
-  //     rendered unusable on the sending side of the channel in the process
-  //     of being transfered. (In C++ this would be referred to as movable but
-  //     not copyable.) Objects of this type need to be listed in the
-  //     `transferList` argument of the relevant postMessage() call in order to
-  //     make sure that they are not accidentally destroyed on the sending side.
-  //     TransferForMessaging() will be called to get a representation of the
-  //     object that is used for subsequent deserialization.
-  //     The NestedTransferables() method can be used to transfer other objects
-  //     along with this one, if a situation requires it.
-  // - kCloneable:
-  //     This object can be cloned without being modified.
-  //     CloneForMessaging() will be called to get a representation of the
-  //     object that is used for subsequent deserialization, unless the
-  //     object is listed in transferList, in which case TransferForMessaging()
-  //     is attempted first.
-  // After a successful clone, FinalizeTransferRead() is called on the receiving
-  // end, and can read deserialize JS data possibly serialized by a previous
-  // FinalizeTransferWrite() call.
-  enum class TransferMode {
-    kUntransferable,
-    kTransferable,
-    kCloneable
-  };
-  virtual TransferMode GetTransferMode() const;
-  virtual std::unique_ptr<worker::TransferData> TransferForMessaging();
-  virtual std::unique_ptr<worker::TransferData> CloneForMessaging() const;
-  virtual v8::Maybe<std::vector<BaseObjectPtrImpl<BaseObject, false>>>
-      NestedTransferables() const;
-  virtual v8::Maybe<bool> FinalizeTransferRead(
-      v8::Local<v8::Context> context, v8::ValueDeserializer* deserializer);
-
-  virtual inline void OnGCCollect();
-
- private:
-  v8::Local<v8::Object> WrappedObject() const override;
-  bool IsRootNode() const override;
-  static void DeleteMe(void* data);
-
-  // persistent_handle_ needs to be at a fixed offset from the start of the
-  // class because it is used by src/node_postmortem_metadata.cc to calculate
-  // offsets and generate debug symbols for BaseObject, which assumes that the
-  // position of members in memory are predictable. For more information please
-  // refer to `doc/guides/node-postmortem-support.md`
-  friend int GenDebugSymbols();
-  friend class CleanupHookCallback;
-  template <typename T, bool kIsWeak>
-  friend class BaseObjectPtrImpl;
-
-  v8::Global<v8::Object> persistent_handle_;
-
-  // Metadata that is associated with this BaseObject if there are BaseObjectPtr
-  // or BaseObjectWeakPtr references to it.
-  // This object is deleted when the BaseObject itself is destroyed, and there
-  // are no weak references to it.
-  struct PointerData {
-    // Number of BaseObjectPtr instances that refer to this object. If this
-    // is non-zero, the BaseObject is always a GC root and will not be destroyed
-    // during cleanup until the count drops to zero again.
-    unsigned int strong_ptr_count = 0;
-    // Number of BaseObjectWeakPtr instances that refer to this object.
-    unsigned int weak_ptr_count = 0;
-    // Indicates whether MakeWeak() has been called.
-    bool wants_weak_jsobj = false;
-    // Indicates whether Detach() has been called. If that is the case, this
-    // object will be destryoed once the strong pointer count drops to zero.
-    bool is_detached = false;
-    // Reference to the original BaseObject. This is used by weak pointers.
-    BaseObject* self = nullptr;
-  };
-
-  inline bool has_pointer_data() const;
-  // This creates a PointerData struct if none was associated with this
-  // BaseObject before.
-  inline PointerData* pointer_data();
-
-  // Functions that adjust the strong pointer count.
-  inline void decrease_refcount();
-  inline void increase_refcount();
-
-  Environment* env_;
-  PointerData* pointer_data_ = nullptr;
-};
-
-// Global alias for FromJSObject() to avoid churn.
-template <typename T>
-inline T* Unwrap(v8::Local<v8::Value> obj) {
-  return BaseObject::FromJSObject<T>(obj);
-}
-
-#define ASSIGN_OR_RETURN_UNWRAP(ptr, obj, ...)                                 \
-  do {                                                                         \
-    *ptr = static_cast<typename std::remove_reference<decltype(*ptr)>::type>(  \
-        BaseObject::FromJSObject(obj));                                        \
-    if (*ptr == nullptr) return __VA_ARGS__;                                   \
-  } while (0)
-
-// Implementation of a generic strong or weak pointer to a BaseObject.
-// If strong, this will keep the target BaseObject alive regardless of other
-// circumstances such as the GC or Environment cleanup.
-// If weak, destruction behaviour is not affected, but the pointer will be
-// reset to nullptr once the BaseObject is destroyed.
-// The API matches std::shared_ptr closely.
-template <typename T, bool kIsWeak>
-class BaseObjectPtrImpl final {
- public:
-  inline BaseObjectPtrImpl();
-  inline ~BaseObjectPtrImpl();
-  inline explicit BaseObjectPtrImpl(T* target);
-
-  // Copy and move constructors. Note that the templated version is not a copy
-  // or move constructor in the C++ sense of the word, so an identical
-  // untemplated version is provided.
-  template <typename U, bool kW>
-  inline BaseObjectPtrImpl(const BaseObjectPtrImpl<U, kW>& other);
-  inline BaseObjectPtrImpl(const BaseObjectPtrImpl& other);
-  template <typename U, bool kW>
-  inline BaseObjectPtrImpl& operator=(const BaseObjectPtrImpl<U, kW>& other);
-  inline BaseObjectPtrImpl& operator=(const BaseObjectPtrImpl& other);
-  inline BaseObjectPtrImpl(BaseObjectPtrImpl&& other);
-  inline BaseObjectPtrImpl& operator=(BaseObjectPtrImpl&& other);
-
-  inline void reset(T* ptr = nullptr);
-  inline T* get() const;
-  inline T& operator*() const;
-  inline T* operator->() const;
-  inline operator bool() const;
-
-  template <typename U, bool kW>
-  inline bool operator ==(const BaseObjectPtrImpl<U, kW>& other) const;
-  template <typename U, bool kW>
-  inline bool operator !=(const BaseObjectPtrImpl<U, kW>& other) const;
-
- private:
-  union {
-    BaseObject* target;                     // Used for strong pointers.
-    BaseObject::PointerData* pointer_data;  // Used for weak pointers.
-  } data_;
-
-  inline BaseObject* get_base_object() const;
-  inline BaseObject::PointerData* pointer_data() const;
-};
-
-template <typename T>
-using BaseObjectPtr = BaseObjectPtrImpl<T, false>;
-template <typename T>
-using BaseObjectWeakPtr = BaseObjectPtrImpl<T, true>;
-
-// Create a BaseObject instance and return a pointer to it.
-// This variant leaves the object as a GC root by default.
-template <typename T, typename... Args>
-inline BaseObjectPtr<T> MakeBaseObject(Args&&... args);
-// Create a BaseObject instance and return a pointer to it.
-// This variant detaches the object by default, meaning that the caller fully
-// owns it, and once the last BaseObjectPtr to it is destroyed, the object
-// itself is also destroyed.
-template <typename T, typename... Args>
-inline BaseObjectPtr<T> MakeDetachedBaseObject(Args&&... args);
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_BASE_OBJECT_H_

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.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_