@encharm/cws 4.4.1 → 4.5.2

package/src/headers/14/node_errors.h

@@ -1,214 +0,0 @@
-#ifndef SRC_NODE_ERRORS_H_
-#define SRC_NODE_ERRORS_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "env.h"
-#include "v8.h"
-
-// Use ostringstream to print exact-width integer types
-// because the format specifiers are not available on AIX.
-#include <sstream>
-
-namespace node {
-
-enum ErrorHandlingMode { CONTEXTIFY_ERROR, FATAL_ERROR, MODULE_ERROR };
-void AppendExceptionLine(Environment* env,
-                         v8::Local<v8::Value> er,
-                         v8::Local<v8::Message> message,
-                         enum ErrorHandlingMode mode);
-
-[[noreturn]] void FatalError(const char* location, const char* message);
-void OnFatalError(const char* location, const char* message);
-
-// Helpers to construct errors similar to the ones provided by
-// lib/internal/errors.js.
-// Example: with `V(ERR_INVALID_ARG_TYPE, TypeError)`, there will be
-// `node::ERR_INVALID_ARG_TYPE(isolate, "message")` returning
-// a `Local<Value>` containing the TypeError with proper code and message
-
-#define ERRORS_WITH_CODE(V)                                                    \
-  V(ERR_BUFFER_CONTEXT_NOT_AVAILABLE, Error)                                   \
-  V(ERR_BUFFER_OUT_OF_BOUNDS, RangeError)                                      \
-  V(ERR_BUFFER_TOO_LARGE, Error)                                               \
-  V(ERR_CONSTRUCT_CALL_REQUIRED, TypeError)                                    \
-  V(ERR_CONSTRUCT_CALL_INVALID, TypeError)                                     \
-  V(ERR_CRYPTO_UNKNOWN_CIPHER, Error)                                          \
-  V(ERR_CRYPTO_UNKNOWN_DH_GROUP, Error)                                        \
-  V(ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE, Error)                            \
-  V(ERR_INVALID_ARG_VALUE, TypeError)                                          \
-  V(ERR_OSSL_EVP_INVALID_DIGEST, Error)                                        \
-  V(ERR_INVALID_ARG_TYPE, TypeError)                                           \
-  V(ERR_INVALID_TRANSFER_OBJECT, TypeError)                                    \
-  V(ERR_MEMORY_ALLOCATION_FAILED, Error)                                       \
-  V(ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE, Error)                             \
-  V(ERR_MISSING_ARGS, TypeError)                                               \
-  V(ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST, TypeError)                      \
-  V(ERR_MISSING_PASSPHRASE, TypeError)                                         \
-  V(ERR_MISSING_PLATFORM_FOR_WORKER, Error)                                    \
-  V(ERR_NON_CONTEXT_AWARE_DISABLED, Error)                                     \
-  V(ERR_OUT_OF_RANGE, RangeError)                                              \
-  V(ERR_SCRIPT_EXECUTION_INTERRUPTED, Error)                                   \
-  V(ERR_SCRIPT_EXECUTION_TIMEOUT, Error)                                       \
-  V(ERR_STRING_TOO_LONG, Error)                                                \
-  V(ERR_TLS_INVALID_PROTOCOL_METHOD, TypeError)                                \
-  V(ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED, Error)                                \
-  V(ERR_VM_MODULE_CACHED_DATA_REJECTED, Error)                                 \
-  V(ERR_WASI_NOT_STARTED, Error)                                               \
-  V(ERR_WORKER_INIT_FAILED, Error)                                             \
-  V(ERR_PROTO_ACCESS, Error)
-
-#define V(code, type)                                                         \
-  inline v8::Local<v8::Value> code(v8::Isolate* isolate,                      \
-                                   const char* message)       {               \
-    v8::Local<v8::String> js_code = OneByteString(isolate, #code);            \
-    v8::Local<v8::String> js_msg = OneByteString(isolate, message);           \
-    v8::Local<v8::Object> e =                                                 \
-        v8::Exception::type(js_msg)->ToObject(                                \
-            isolate->GetCurrentContext()).ToLocalChecked();                   \
-    e->Set(isolate->GetCurrentContext(), OneByteString(isolate, "code"),      \
-           js_code).Check();                                                  \
-    return e;                                                                 \
-  }                                                                           \
-  inline void THROW_ ## code(v8::Isolate* isolate, const char* message) {     \
-    isolate->ThrowException(code(isolate, message));                          \
-  }                                                                           \
-  inline void THROW_ ## code(Environment* env, const char* message) {         \
-    THROW_ ## code(env->isolate(), message);                                  \
-  }
-  ERRORS_WITH_CODE(V)
-#undef V
-
-// Errors with predefined static messages
-
-#define PREDEFINED_ERROR_MESSAGES(V)                                           \
-  V(ERR_BUFFER_CONTEXT_NOT_AVAILABLE,                                          \
-    "Buffer is not available for the current Context")                         \
-  V(ERR_CONSTRUCT_CALL_INVALID, "Constructor cannot be called")                \
-  V(ERR_CONSTRUCT_CALL_REQUIRED, "Cannot call constructor without `new`")      \
-  V(ERR_CRYPTO_UNKNOWN_CIPHER, "Unknown cipher")                               \
-  V(ERR_CRYPTO_UNKNOWN_DH_GROUP, "Unknown DH group")                           \
-  V(ERR_EXECUTION_ENVIRONMENT_NOT_AVAILABLE,                                   \
-    "Context not associated with Node.js environment")                         \
-  V(ERR_INVALID_TRANSFER_OBJECT, "Found invalid object in transferList")       \
-  V(ERR_MEMORY_ALLOCATION_FAILED, "Failed to allocate memory")                 \
-  V(ERR_OSSL_EVP_INVALID_DIGEST, "Invalid digest used")                        \
-  V(ERR_MESSAGE_TARGET_CONTEXT_UNAVAILABLE,                                    \
-    "A message object could not be deserialized successfully in the target "   \
-    "vm.Context")                                                              \
-  V(ERR_MISSING_MESSAGE_PORT_IN_TRANSFER_LIST,                                 \
-    "Object that needs transfer was found in message but not listed "          \
-    "in transferList")                                                         \
-  V(ERR_MISSING_PLATFORM_FOR_WORKER,                                           \
-    "The V8 platform used by this instance of Node does not support "          \
-    "creating Workers")                                                        \
-  V(ERR_NON_CONTEXT_AWARE_DISABLED,                                            \
-    "Loading non context-aware native modules has been disabled")              \
-  V(ERR_SCRIPT_EXECUTION_INTERRUPTED,                                          \
-    "Script execution was interrupted by `SIGINT`")                            \
-  V(ERR_TLS_PSK_SET_IDENTIY_HINT_FAILED, "Failed to set PSK identity hint")    \
-  V(ERR_WASI_NOT_STARTED, "wasi.start() has not been called")                  \
-  V(ERR_WORKER_INIT_FAILED, "Worker initialization failure")                   \
-  V(ERR_PROTO_ACCESS,                                                          \
-    "Accessing Object.prototype.__proto__ has been "                           \
-    "disallowed with --disable-proto=throw")
-
-#define V(code, message)                                                     \
-  inline v8::Local<v8::Value> code(v8::Isolate* isolate) {                   \
-    return code(isolate, message);                                           \
-  }                                                                          \
-  inline void THROW_ ## code(v8::Isolate* isolate) {                         \
-    isolate->ThrowException(code(isolate, message));                         \
-  }                                                                          \
-  inline void THROW_ ## code(Environment* env) {                             \
-    THROW_ ## code(env->isolate());                                          \
-  }
-  PREDEFINED_ERROR_MESSAGES(V)
-#undef V
-
-// Errors with predefined non-static messages
-inline void THROW_ERR_SCRIPT_EXECUTION_TIMEOUT(Environment* env,
-                                               int64_t timeout) {
-  std::ostringstream message;
-  message << "Script execution timed out after ";
-  message << timeout << "ms";
-  THROW_ERR_SCRIPT_EXECUTION_TIMEOUT(env, message.str().c_str());
-}
-
-inline v8::Local<v8::Value> ERR_BUFFER_TOO_LARGE(v8::Isolate* isolate) {
-  char message[128];
-  snprintf(message, sizeof(message),
-      "Cannot create a Buffer larger than 0x%zx bytes",
-      v8::TypedArray::kMaxLength);
-  return ERR_BUFFER_TOO_LARGE(isolate, message);
-}
-
-inline v8::Local<v8::Value> ERR_STRING_TOO_LONG(v8::Isolate* isolate) {
-  char message[128];
-  snprintf(message, sizeof(message),
-      "Cannot create a string longer than 0x%x characters",
-      v8::String::kMaxLength);
-  return ERR_STRING_TOO_LONG(isolate, message);
-}
-
-#define THROW_AND_RETURN_IF_NOT_BUFFER(env, val, prefix)                     \
-  do {                                                                       \
-    if (!Buffer::HasInstance(val))                                           \
-      return node::THROW_ERR_INVALID_ARG_TYPE(env,                           \
-                                              prefix " must be a buffer");   \
-  } while (0)
-
-#define THROW_AND_RETURN_IF_NOT_STRING(env, val, prefix)                     \
-  do {                                                                       \
-    if (!val->IsString())                                                    \
-      return node::THROW_ERR_INVALID_ARG_TYPE(env,                           \
-                                              prefix " must be a string");   \
-  } while (0)
-
-namespace errors {
-
-class TryCatchScope : public v8::TryCatch {
- public:
-  enum class CatchMode { kNormal, kFatal };
-
-  explicit TryCatchScope(Environment* env, CatchMode mode = CatchMode::kNormal)
-      : v8::TryCatch(env->isolate()), env_(env), mode_(mode) {}
-  ~TryCatchScope();
-
-  // Since the dtor is not virtual we need to make sure no one creates
-  // object of it in the free store that might be held by polymorphic pointers.
-  void* operator new(std::size_t count) = delete;
-  void* operator new[](std::size_t count) = delete;
-  TryCatchScope(TryCatchScope&) = delete;
-  TryCatchScope(TryCatchScope&&) = delete;
-  TryCatchScope operator=(TryCatchScope&) = delete;
-  TryCatchScope operator=(TryCatchScope&&) = delete;
-
- private:
-  Environment* env_;
-  CatchMode mode_;
-};
-
-// Trigger the global uncaught exception handler `process._fatalException`
-// in JS land (which emits the 'uncaughtException' event). If that returns
-// true, continue program execution, otherwise exit the process.
-void TriggerUncaughtException(v8::Isolate* isolate,
-                              const v8::TryCatch& try_catch);
-void TriggerUncaughtException(v8::Isolate* isolate,
-                              v8::Local<v8::Value> error,
-                              v8::Local<v8::Message> message,
-                              bool from_promise = false);
-
-const char* errno_string(int errorno);
-void PerIsolateMessageListener(v8::Local<v8::Message> message,
-                               v8::Local<v8::Value> error);
-
-void DecorateErrorStack(Environment* env,
-                        const errors::TryCatchScope& try_catch);
-}  // namespace errors
-
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_ERRORS_H_

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

@@ -1,306 +0,0 @@
-#ifndef SRC_NODE_FILE_INL_H_
-#define SRC_NODE_FILE_INL_H_
-
-#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#include "node_file.h"
-#include "req_wrap-inl.h"
-
-namespace node {
-namespace fs {
-
-FSContinuationData::FSContinuationData(uv_fs_t* req, int mode, uv_fs_cb done_cb)
-  : done_cb_(done_cb), req_(req), mode_(mode) {
-}
-
-void FSContinuationData::PushPath(std::string&& path) {
-  paths_.emplace_back(std::move(path));
-}
-
-void FSContinuationData::PushPath(const std::string& path) {
-  paths_.push_back(path);
-}
-
-void FSContinuationData::MaybeSetFirstPath(const std::string& path) {
-  if (first_path_.empty()) {
-    first_path_ = path;
-  }
-}
-
-std::string FSContinuationData::PopPath() {
-  CHECK_GT(paths_.size(), 0);
-  std::string path = std::move(paths_.back());
-  paths_.pop_back();
-  return path;
-}
-
-void FSContinuationData::Done(int result) {
-  req_->result = result;
-  done_cb_(req_);
-}
-
-FSReqBase::FSReqBase(BindingData* binding_data,
-                     v8::Local<v8::Object> req,
-                     AsyncWrap::ProviderType type,
-                     bool use_bigint)
-  : ReqWrap(binding_data->env(), req, type),
-    use_bigint_(use_bigint),
-    binding_data_(binding_data) {
-}
-
-void FSReqBase::Init(const char* syscall,
-                     const char* data,
-                     size_t len,
-                     enum encoding encoding) {
-  syscall_ = syscall;
-  encoding_ = encoding;
-
-  if (data != nullptr) {
-    CHECK(!has_data_);
-    buffer_.AllocateSufficientStorage(len + 1);
-    buffer_.SetLengthAndZeroTerminate(len);
-    memcpy(*buffer_, data, len);
-    has_data_ = true;
-  }
-}
-
-FSReqBase::FSReqBuffer&
-FSReqBase::Init(const char* syscall, size_t len, enum encoding encoding) {
-  syscall_ = syscall;
-  encoding_ = encoding;
-
-  buffer_.AllocateSufficientStorage(len + 1);
-  has_data_ = false;  // so that the data does not show up in error messages
-  return buffer_;
-}
-
-FSReqCallback::FSReqCallback(BindingData* binding_data,
-                             v8::Local<v8::Object> req,
-                             bool use_bigint)
-  : FSReqBase(binding_data,
-              req,
-              AsyncWrap::PROVIDER_FSREQCALLBACK,
-              use_bigint) {}
-
-template <typename NativeT, typename V8T>
-void FillStatsArray(AliasedBufferBase<NativeT, V8T>* fields,
-                    const uv_stat_t* s,
-                    const size_t offset) {
-#define SET_FIELD_WITH_STAT(stat_offset, stat)                               \
-  fields->SetValue(offset + static_cast<size_t>(FsStatsOffset::stat_offset), \
-                   static_cast<NativeT>(stat))
-
-#define SET_FIELD_WITH_TIME_STAT(stat_offset, stat)                          \
-  /* NOLINTNEXTLINE(runtime/int) */                                          \
-  SET_FIELD_WITH_STAT(stat_offset, static_cast<unsigned long>(stat))
-
-  SET_FIELD_WITH_STAT(kDev, s->st_dev);
-  SET_FIELD_WITH_STAT(kMode, s->st_mode);
-  SET_FIELD_WITH_STAT(kNlink, s->st_nlink);
-  SET_FIELD_WITH_STAT(kUid, s->st_uid);
-  SET_FIELD_WITH_STAT(kGid, s->st_gid);
-  SET_FIELD_WITH_STAT(kRdev, s->st_rdev);
-  SET_FIELD_WITH_STAT(kBlkSize, s->st_blksize);
-  SET_FIELD_WITH_STAT(kIno, s->st_ino);
-  SET_FIELD_WITH_STAT(kSize, s->st_size);
-  SET_FIELD_WITH_STAT(kBlocks, s->st_blocks);
-
-  SET_FIELD_WITH_TIME_STAT(kATimeSec, s->st_atim.tv_sec);
-  SET_FIELD_WITH_TIME_STAT(kATimeNsec, s->st_atim.tv_nsec);
-  SET_FIELD_WITH_TIME_STAT(kMTimeSec, s->st_mtim.tv_sec);
-  SET_FIELD_WITH_TIME_STAT(kMTimeNsec, s->st_mtim.tv_nsec);
-  SET_FIELD_WITH_TIME_STAT(kCTimeSec, s->st_ctim.tv_sec);
-  SET_FIELD_WITH_TIME_STAT(kCTimeNsec, s->st_ctim.tv_nsec);
-  SET_FIELD_WITH_TIME_STAT(kBirthTimeSec, s->st_birthtim.tv_sec);
-  SET_FIELD_WITH_TIME_STAT(kBirthTimeNsec, s->st_birthtim.tv_nsec);
-
-#undef SET_FIELD_WITH_TIME_STAT
-#undef SET_FIELD_WITH_STAT
-}
-
-v8::Local<v8::Value> FillGlobalStatsArray(BindingData* binding_data,
-                                          const bool use_bigint,
-                                          const uv_stat_t* s,
-                                          const bool second) {
-  const ptrdiff_t offset =
-      second ? static_cast<ptrdiff_t>(FsStatsOffset::kFsStatsFieldsNumber) : 0;
-  if (use_bigint) {
-    auto* const arr = &binding_data->stats_field_bigint_array;
-    FillStatsArray(arr, s, offset);
-    return arr->GetJSArray();
-  } else {
-    auto* const arr = &binding_data->stats_field_array;
-    FillStatsArray(arr, s, offset);
-    return arr->GetJSArray();
-  }
-}
-
-template <typename AliasedBufferT>
-FSReqPromise<AliasedBufferT>*
-FSReqPromise<AliasedBufferT>::New(BindingData* binding_data,
-                                  bool use_bigint) {
-  Environment* env = binding_data->env();
-  v8::Local<v8::Object> obj;
-  if (!env->fsreqpromise_constructor_template()
-           ->NewInstance(env->context())
-           .ToLocal(&obj)) {
-    return nullptr;
-  }
-  v8::Local<v8::Promise::Resolver> resolver;
-  if (!v8::Promise::Resolver::New(env->context()).ToLocal(&resolver) ||
-      obj->Set(env->context(), env->promise_string(), resolver).IsNothing()) {
-    return nullptr;
-  }
-  return new FSReqPromise(binding_data, obj, use_bigint);
-}
-
-template <typename AliasedBufferT>
-FSReqPromise<AliasedBufferT>::~FSReqPromise() {
-  // Validate that the promise was explicitly resolved or rejected.
-  CHECK(finished_);
-}
-
-template <typename AliasedBufferT>
-FSReqPromise<AliasedBufferT>::FSReqPromise(
-    BindingData* binding_data,
-    v8::Local<v8::Object> obj,
-    bool use_bigint)
-  : FSReqBase(binding_data,
-              obj,
-              AsyncWrap::PROVIDER_FSREQPROMISE,
-              use_bigint),
-    stats_field_array_(
-        env()->isolate(),
-        static_cast<size_t>(FsStatsOffset::kFsStatsFieldsNumber)) {}
-
-template <typename AliasedBufferT>
-void FSReqPromise<AliasedBufferT>::Reject(v8::Local<v8::Value> reject) {
-  finished_ = true;
-  v8::HandleScope scope(env()->isolate());
-  InternalCallbackScope callback_scope(this);
-  v8::Local<v8::Value> value =
-      object()->Get(env()->context(),
-                    env()->promise_string()).ToLocalChecked();
-  v8::Local<v8::Promise::Resolver> resolver = value.As<v8::Promise::Resolver>();
-  USE(resolver->Reject(env()->context(), reject).FromJust());
-}
-
-template <typename AliasedBufferT>
-void FSReqPromise<AliasedBufferT>::Resolve(v8::Local<v8::Value> value) {
-  finished_ = true;
-  v8::HandleScope scope(env()->isolate());
-  InternalCallbackScope callback_scope(this);
-  v8::Local<v8::Value> val =
-      object()->Get(env()->context(),
-                    env()->promise_string()).ToLocalChecked();
-  v8::Local<v8::Promise::Resolver> resolver = val.As<v8::Promise::Resolver>();
-  USE(resolver->Resolve(env()->context(), value).FromJust());
-}
-
-template <typename AliasedBufferT>
-void FSReqPromise<AliasedBufferT>::ResolveStat(const uv_stat_t* stat) {
-  FillStatsArray(&stats_field_array_, stat);
-  Resolve(stats_field_array_.GetJSArray());
-}
-
-template <typename AliasedBufferT>
-void FSReqPromise<AliasedBufferT>::SetReturnValue(
-    const v8::FunctionCallbackInfo<v8::Value>& args) {
-  v8::Local<v8::Value> val =
-      object()->Get(env()->context(),
-                    env()->promise_string()).ToLocalChecked();
-  v8::Local<v8::Promise::Resolver> resolver = val.As<v8::Promise::Resolver>();
-  args.GetReturnValue().Set(resolver->GetPromise());
-}
-
-template <typename AliasedBufferT>
-void FSReqPromise<AliasedBufferT>::MemoryInfo(MemoryTracker* tracker) const {
-  FSReqBase::MemoryInfo(tracker);
-  tracker->TrackField("stats_field_array", stats_field_array_);
-}
-
-FSReqBase* GetReqWrap(const v8::FunctionCallbackInfo<v8::Value>& args,
-                      int index,
-                      bool use_bigint) {
-  v8::Local<v8::Value> value = args[index];
-  if (value->IsObject()) {
-    return Unwrap<FSReqBase>(value.As<v8::Object>());
-  }
-
-  BindingData* binding_data = Environment::GetBindingData<BindingData>(args);
-  Environment* env = binding_data->env();
-  if (value->StrictEquals(env->fs_use_promises_symbol())) {
-    if (use_bigint) {
-      return FSReqPromise<AliasedBigUint64Array>::New(binding_data, use_bigint);
-    } else {
-      return FSReqPromise<AliasedFloat64Array>::New(binding_data, use_bigint);
-    }
-  }
-  return nullptr;
-}
-
-// Returns nullptr if the operation fails from the start.
-template <typename Func, typename... Args>
-FSReqBase* AsyncDestCall(Environment* env, FSReqBase* req_wrap,
-                         const v8::FunctionCallbackInfo<v8::Value>& args,
-                         const char* syscall, const char* dest,
-                         size_t len, enum encoding enc, uv_fs_cb after,
-                         Func fn, Args... fn_args) {
-  CHECK_NOT_NULL(req_wrap);
-  req_wrap->Init(syscall, dest, len, enc);
-  int err = req_wrap->Dispatch(fn, fn_args..., after);
-  if (err < 0) {
-    uv_fs_t* uv_req = req_wrap->req();
-    uv_req->result = err;
-    uv_req->path = nullptr;
-    after(uv_req);  // after may delete req_wrap if there is an error
-    req_wrap = nullptr;
-  } else {
-    req_wrap->SetReturnValue(args);
-  }
-
-  return req_wrap;
-}
-
-// Returns nullptr if the operation fails from the start.
-template <typename Func, typename... Args>
-FSReqBase* AsyncCall(Environment* env,
-                     FSReqBase* req_wrap,
-                     const v8::FunctionCallbackInfo<v8::Value>& args,
-                     const char* syscall, enum encoding enc,
-                     uv_fs_cb after, Func fn, Args... fn_args) {
-  return AsyncDestCall(env, req_wrap, args,
-                       syscall, nullptr, 0, enc,
-                       after, fn, fn_args...);
-}
-
-// Template counterpart of SYNC_CALL, except that it only puts
-// the error number and the syscall in the context instead of
-// creating an error in the C++ land.
-// ctx must be checked using value->IsObject() before being passed.
-template <typename Func, typename... Args>
-int SyncCall(Environment* env, v8::Local<v8::Value> ctx,
-             FSReqWrapSync* req_wrap, const char* syscall,
-             Func fn, Args... args) {
-  env->PrintSyncTrace();
-  int err = fn(env->event_loop(), &(req_wrap->req), args..., nullptr);
-  if (err < 0) {
-    v8::Local<v8::Context> context = env->context();
-    v8::Local<v8::Object> ctx_obj = ctx.As<v8::Object>();
-    v8::Isolate* isolate = env->isolate();
-    ctx_obj->Set(context,
-                 env->errno_string(),
-                 v8::Integer::New(isolate, err)).Check();
-    ctx_obj->Set(context,
-                 env->syscall_string(),
-                 OneByteString(isolate, syscall)).Check();
-  }
-  return err;
-}
-
-}  // namespace fs
-}  // namespace node
-
-#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
-
-#endif  // SRC_NODE_FILE_INL_H_