asherah 3.0.16 → 4.0.0-beta.2

package/src/logging_napi.cc

@@ -1,115 +0,0 @@
-#include "logging_napi.h"
-#include "napi_utils.h"
-
-LoggerNapi::LoggerNapi(Napi::Env &env, const std::string &system_name)
-    : StdErrLogger(system_name), log_hook(Napi::FunctionReference()), env(env) {
-}
-
-[[maybe_unused]] LoggerNapi::LoggerNapi(Napi::Env &env,
-                                        const std::string &system_name,
-                                        Napi::Function new_log_hook)
-    : StdErrLogger(system_name), env(env) {
-  if (unlikely(new_log_hook.IsEmpty())) {
-    NapiUtils::ThrowException(env,
-                              system_name + ": new_log_hook cannot be nullptr");
-  }
-  log_hook = Napi::Persistent(new_log_hook);
-}
-
-LoggerNapi::~LoggerNapi() {
-  auto old_log_hook = std::exchange(log_hook, Napi::FunctionReference());
-  if (!old_log_hook.IsEmpty()) {
-    old_log_hook.Unref();
-  }
-}
-
-void LoggerNapi::set_log_hook(Napi::Function new_log_hook) {
-  if (unlikely(new_log_hook.IsUndefined() || new_log_hook.IsEmpty())) {
-    NapiUtils::ThrowException(env,
-                              system_name + ": new_log_hook cannot be empty");
-  }
-  auto old_log_hook = std::exchange(log_hook, Napi::Persistent(new_log_hook));
-  if (!old_log_hook.IsEmpty()) {
-    old_log_hook.Unref();
-  }
-}
-
-void LoggerNapi::call_log_hook(int level, const std::string &message) const {
-  if (unlikely(log_hook.IsEmpty())) {
-    NapiUtils::ThrowException(env, system_name + ": log_hook cannot be empty");
-  }
-  Napi::HandleScope scope(env);
-  Napi::Function log_hook_function = log_hook.Value();
-  log_hook_function.Call(
-      {Napi::Number::New(env, level),
-       Napi::String::New(env, system_name + ": " + message)});
-}
-
-void LoggerNapi::debug_log(const char *function_name,
-                           const char *message) const {
-  if (unlikely(verbose_flag)) {
-    if (unlikely(log_hook.IsEmpty())) {
-      StdErrLogger::debug_log(function_name, message);
-    } else {
-      call_log_hook(posix_log_level_debug,
-                    system_name + ": " + function_name + ": " + message);
-    }
-  }
-}
-
-void LoggerNapi::debug_log(const char *function_name,
-                           const std::string &message) const {
-  if (unlikely(verbose_flag)) {
-    if (unlikely(log_hook.IsEmpty())) {
-      StdErrLogger::debug_log(function_name, message);
-    } else {
-      call_log_hook(posix_log_level_debug,
-                    system_name + ": " + function_name + ": " + message);
-    }
-  }
-}
-
-void LoggerNapi::debug_log_alloca(const char *function_name,
-                                  const char *variable_name,
-                                  size_t length) const {
-  if (unlikely(verbose_flag)) {
-    if (unlikely(log_hook.IsEmpty())) {
-      StdErrLogger::debug_log_alloca(function_name, variable_name, length);
-    } else {
-      call_log_hook(posix_log_level_debug,
-                    system_name + ": " + function_name + ": Calling alloca(" +
-                        std::to_string(length) + ") (stack) for " +
-                        variable_name);
-    }
-  }
-}
-
-void LoggerNapi::debug_log_new(const char *function_name,
-                               const char *variable_name, size_t length) const {
-  if (unlikely(verbose_flag)) {
-    if (unlikely(log_hook.IsEmpty())) {
-      StdErrLogger::debug_log_new(function_name, variable_name, length);
-    } else {
-      call_log_hook(posix_log_level_debug, system_name + ": " + function_name +
-                                               ": Calling new[" +
-                                               std::to_string(length) +
-                                               "] (heap) for " + variable_name);
-    }
-  }
-}
-
-void LoggerNapi::error_log(const char *function_name,
-                           const char *message) const {
-  if (likely(!log_hook.IsEmpty())) {
-    call_log_hook(posix_log_level_error,
-                  system_name + ": " + function_name + ": " + message);
-  }
-}
-
-void LoggerNapi::error_log(const char *function_name,
-                           const std::string &message) const {
-  if (likely(!log_hook.IsEmpty())) {
-    call_log_hook(posix_log_level_error,
-                  system_name + ": " + function_name + ": " + message);
-  }
-}

package/src/logging_napi.h

@@ -1,41 +0,0 @@
-#ifndef LOGGING_NAPI_H
-#define LOGGING_NAPI_H
-
-#include "hints.h"
-#include "logging.h"
-#include "logging_stderr.h"
-#include <napi.h>
-
-class LoggerNapi : public StdErrLogger {
-public:
-  LoggerNapi(Napi::Env &env, const std::string &system_name);
-
-  [[maybe_unused]] explicit LoggerNapi(Napi::Env &env,
-                                       const std::string &system_name,
-                                       Napi::Function new_log_hook);
-  ~LoggerNapi();
-
-  void set_log_hook(Napi::Function new_log_hook);
-
-  void debug_log(const char *function_name, const char *message) const override;
-  void debug_log(const char *function_name,
-                 const std::string &message) const override;
-  void debug_log_alloca(const char *function_name, const char *variable_name,
-                        size_t length) const override;
-
-  void debug_log_new(const char *function_name, const char *variable_name,
-                     size_t length) const override;
-
-  void error_log(const char *function_name, const char *message) const override;
-  void error_log(const char *function_name,
-                 const std::string &message) const override;
-
-private:
-  void call_log_hook(int level, const std::string &message) const;
-  Napi::FunctionReference log_hook;
-  Napi::Env env;
-  const int posix_log_level_error = 3;
-  const int posix_log_level_debug = 7;
-};
-
-#endif // LOGGING_NAPI_H

package/src/logging_stderr.cc

@@ -1,60 +0,0 @@
-#include "logging_stderr.h"
-#include "hints.h"
-#include <iostream>
-
-StdErrLogger::StdErrLogger(const std::string &system_name)
-    : Logger(system_name) {}
-
-void StdErrLogger::debug_log(const char *function_name,
-                             const char *message) const {
-  if (unlikely(verbose_flag)) {
-    std::cerr << system_name << ": [DEBUG] " << function_name << ": " << message
-              << std::endl
-              << std::flush;
-  }
-}
-
-void StdErrLogger::debug_log(const char *function_name,
-                             const std::string &message) const {
-  if (unlikely(verbose_flag)) {
-    std::cerr << system_name << ": [DEBUG] " << function_name << ": " << message
-              << std::endl
-              << std::flush;
-  }
-}
-
-void StdErrLogger::debug_log_alloca(const char *function_name,
-                                    const char *variable_name,
-                                    size_t length) const {
-  if (unlikely(verbose_flag)) {
-    std::cerr << system_name << ": [DEBUG] " << function_name
-              << ": Calling alloca(" << length << ") (stack) for "
-              << variable_name << std::endl
-              << std::flush;
-  }
-}
-
-void StdErrLogger::debug_log_new(const char *function_name,
-                                 const char *variable_name,
-                                 size_t length) const {
-  if (unlikely(verbose_flag)) {
-    std::cerr << system_name << ": [DEBUG] " << function_name
-              << ": Calling new[" << length << "] (heap) for " << variable_name
-              << std::endl
-              << std::flush;
-  }
-}
-
-void StdErrLogger::error_log(const char *function_name,
-                             const char *message) const {
-  std::cerr << system_name << ": [ERROR] " << function_name << ": " << message
-            << std::endl
-            << std::flush;
-}
-
-void StdErrLogger::error_log(const char *function_name,
-                             const std::string &message) const {
-  std::cerr << system_name << ": [ERROR] " << function_name << ": " << message
-            << std::endl
-            << std::flush;
-}

package/src/logging_stderr.h

@@ -1,23 +0,0 @@
-#ifndef STDERR_LOGGER_H
-#define STDERR_LOGGER_H
-
-#include "logging.h"
-
-class StdErrLogger : public Logger {
-public:
-  StdErrLogger() = delete;
-  explicit StdErrLogger(const std::string &system_name);
-
-  void debug_log(const char *function_name, const char *message) const override;
-  void debug_log(const char *function_name,
-                 const std::string &message) const override;
-  void debug_log_alloca(const char *function_name, const char *variable_name,
-                        size_t length) const override;
-  void debug_log_new(const char *function_name, const char *variable_name,
-                     size_t length) const override;
-  void error_log(const char *function_name, const char *message) const override;
-  void error_log(const char *function_name,
-                 const std::string &message) const override;
-};
-
-#endif // STDERR_LOGGER_H

package/src/napi_utils.h

@@ -1,164 +0,0 @@
-#ifndef NAPI_UTILS_H
-#define NAPI_UTILS_H
-
-#include "hints.h"
-#include <napi.h>
-#include <stdexcept>
-#include <string>
-
-class NapiUtils {
-public:
-  // This gets the length of the utf-8 string without allocating / copying
-  static size_t GetUtf8StringLength(const Napi::Env &env,
-                                    const Napi::String &napiString) {
-    size_t result;
-    napi_status status =
-        napi_get_value_string_utf8(env, napiString, nullptr, 0, &result);
-    if (status != napi_ok) {
-      ThrowException(env, "Failed to get UTF-8 string length. Status: " +
-                              std::to_string(status));
-    }
-    return result;
-  }
-
-  [[noreturn]] static void ThrowException(const Napi::Env &env,
-                                          const std::string &message) {
-    // throw std::runtime_error(message);
-    throw Napi::Error::New(env, message);
-  }
-
-  static void AsJsonObjectAndString(const Napi::Env &env,
-                                    const Napi::Value &value,
-                                    Napi::String &jsonString,
-                                    Napi::Object &jsonObject) {
-    auto json = env.Global().Get("JSON").As<Napi::Object>();
-    auto jsonStringify = json.Get("stringify").As<Napi::Function>();
-    auto jsonParse = json.Get("parse").As<Napi::Function>();
-    if (unlikely(value.IsUndefined())) {
-      ThrowException(env, "Input value is undefined");
-    } else if (value.IsString()) {
-      // Convert string to object using JSON.parse
-      auto str = value.As<Napi::String>();
-      jsonString = str;
-      jsonObject = jsonParse.Call({str}).As<Napi::Object>();
-    } else if (value.IsObject()) {
-      // Convert object to string using JSON.stringify
-        auto obj = value.As<Napi::Object>();
-      if (jsonStringify.IsUndefined()) {
-        ThrowException(env, "jsonStringify is undefined");
-      } else if (jsonStringify.IsEmpty()) {
-        ThrowException(env, "jsonStringify is empty");
-      }
-      jsonString = jsonStringify.Call({obj}).As<Napi::String>();
-      jsonObject = obj;
-    } else {
-      ThrowException(env, "Input value must be a Napi::Object or Napi::String");
-    }
-  }
-
-#pragma region Object Properties
-
-  static void GetStringProperty(const Napi::Object &obj,
-                                const char *propertyName,
-                                Napi::String &result) {
-    auto maybeValue = obj.Get(propertyName);
-
-    if (likely(!maybeValue.IsUndefined() && !maybeValue.IsNull() &&
-               maybeValue.IsString())) {
-      result = maybeValue.As<Napi::String>();
-    } else {
-      ThrowException(obj.Env(), "Property '" + std::string(propertyName) +
-                                    "' is not a Napi::String or is missing.");
-    }
-  }
-
-  static void GetBooleanProperty(const Napi::Object &obj,
-                                 const char *propertyName, bool &result,
-                                 bool defaultValue = false) {
-    auto maybeValue = obj.Get(propertyName);
-
-    if (likely(!maybeValue.IsEmpty())) {
-      Napi::Value value = maybeValue;
-
-      if (value.IsBoolean()) {
-        result = value.As<Napi::Boolean>();
-      } else {
-        // Coerce to boolean
-        result = value.ToBoolean();
-      }
-    } else {
-      result = defaultValue;
-    }
-  }
-
-#pragma endregion Object Properties
-
-#pragma region Parameter Support
-
-  static void RequireParameterCount(const Napi::CallbackInfo &info,
-                                    size_t expected) {
-    if (unlikely(info.Length() != expected)) {
-      std::string error_msg = "Expected " + std::to_string(expected) +
-                              " arguments, but got " +
-                              std::to_string(info.Length());
-      ThrowException(info.Env(), error_msg);
-    }
-  }
-
-  static Napi::String RequireParameterString(const Napi::Env &env,
-                                             const char *func_name,
-                                             Napi::Value value) {
-    if (likely(value.IsString())) {
-      return value.As<Napi::String>();
-    } else if (unlikely(value.IsUndefined())) {
-      ThrowException(env, std::string(func_name) +
-                              ": Expected String but received undefined");
-    } else if (unlikely(value.IsNull())) {
-      ThrowException(env, std::string(func_name) +
-                              ": Expected String but received null");
-    } else {
-      ThrowException(env, std::string(func_name) +
-                              ": Expected String but received unknown type");
-    }
-  }
-
-  __attribute__((unused)) static Napi::Buffer<unsigned char>
-  RequireParameterBuffer(const Napi::Env &env, const char *func_name,
-                         Napi::Value value) {
-    if (likely(value.IsBuffer())) {
-      return value.As<Napi::Buffer<unsigned char>>();
-    } else if (unlikely(value.IsUndefined())) {
-      ThrowException(env, std::string(func_name) +
-                              ": Expected String but received undefined");
-    } else if (unlikely(value.IsNull())) {
-      ThrowException(env, std::string(func_name) +
-                              ": Expected String but received null");
-    } else {
-      ThrowException(env, std::string(func_name) +
-                              ": Expected String but received unknown type");
-    }
-  }
-
-  static Napi::Value RequireParameterStringOrBuffer(const Napi::Env &env,
-                                                    const char *func_name,
-                                                    Napi::Value value) {
-    if (value.IsString()) {
-      return value.As<Napi::String>();
-    } else if (likely(value.IsBuffer())) {
-      return value.As<Napi::Buffer<unsigned char>>(); // NOLINT(*-slicing)
-    } else if (unlikely(value.IsUndefined())) {
-      ThrowException(env, std::string(func_name) +
-                              ": Expected String but received undefined");
-    } else if (unlikely(value.IsNull())) {
-      ThrowException(env, std::string(func_name) +
-                              ": Expected String but received null");
-    } else {
-      ThrowException(env, std::string(func_name) +
-                              ": Expected String but received unknown type");
-    }
-  }
-
-#pragma endregion Parameter Support
-};
-
-#endif // NAPI_UTILS_H

package/src/scoped_allocate.h

@@ -1,50 +0,0 @@
-#ifndef SCOPED_ALLOCATE_H
-#define SCOPED_ALLOCATE_H
-
-#ifdef USE_SCOPED_ALLOCATE_BUFFER
-
-/*
-  This macro allows us to allocate a buffer either on the stack or on the heap.
-  If the requested buffer size is less than max_stack_alloc_size, we create the
-  buffer on the stack using alloca().  Buffers allocated with alloca() are
-  automatically freed when the function exits, since they're on the call stack.
-  We use alloca() rather than VLAs because VLAs are limited by scope brackets
-  rather than by the function call, making it hard to create a VLA in an if
-  statement. If the buffer is larger than what we're willing to risk allocating
-  on the stack, we instead allocate it on the heap and use a unique_ptr which
-  will automatically free the allocated buffer when it goes out of scope.
-*/
-
-#define SCOPED_ALLOCATE_BUFFER_UNIQUE_PTR(buffer, buffer_size, unique_ptr,     \
-                                          max_stack_alloc_size, function_name) \
-  do {                                                                         \
-    buffer = nullptr;                                                          \
-    if (buffer_size < max_stack_alloc_size) {                                  \
-      /* If the buffer is small enough, allocate it on the stack */            \
-      buffer = (char *)alloca(buffer_size);                                    \
-      if (unlikely(buffer == nullptr)) {                                       \
-        throw std::runtime_error(std::string(function_name) + " alloca(" +     \
-                                 std::to_string(buffer_size) +                 \
-                                 ") returned null");                           \
-      }                                                                        \
-    } else {                                                                   \
-      /* Otherwise, allocate it on the heap */                                 \
-      buffer = new (std::nothrow) char[buffer_size];                           \
-      if (unlikely(buffer == nullptr)) {                                       \
-        throw std::runtime_error(std::string(function_name) + " new[" +        \
-                                 std::to_string(buffer_size) +                 \
-                                 "] returned null");                           \
-      }                                                                        \
-      unique_ptr.reset(buffer);                                                \
-    }                                                                          \
-  } while (0)
-
-#define SCOPED_ALLOCATE_BUFFER(buffer, buffer_size, max_stack_alloc_size,      \
-                               function_name)                                  \
-  std::unique_ptr<char[]> buffer##_unique_ptr;                                 \
-  SCOPED_ALLOCATE_BUFFER_UNIQUE_PTR(buffer, buffer_size, buffer##_unique_ptr,  \
-                                    max_stack_alloc_size, function_name)
-
-#endif // USE_SCOPED_ALLOCATE_BUFFER
-
-#endif // SCOPED_ALLOCATE_H