@encharm/cws 4.4.1 → 4.5.2

package/src/headers/{18 → 22}/util-inl.h

@@ -27,43 +27,10 @@
 #include <cmath>
 #include <cstring>
 #include <locale>
+#include <regex>  // NOLINT(build/c++11)
+#include "node_revert.h"
 #include "util.h"
 
-// These are defined by <sys/byteorder.h> or <netinet/in.h> on some systems.
-// To avoid warnings, undefine them before redefining them.
-#ifdef BSWAP_2
-# undef BSWAP_2
-#endif
-#ifdef BSWAP_4
-# undef BSWAP_4
-#endif
-#ifdef BSWAP_8
-# undef BSWAP_8
-#endif
-
-#if defined(_MSC_VER)
-#include <intrin.h>
-#define BSWAP_2(x) _byteswap_ushort(x)
-#define BSWAP_4(x) _byteswap_ulong(x)
-#define BSWAP_8(x) _byteswap_uint64(x)
-#else
-#define BSWAP_2(x) ((x) << 8) | ((x) >> 8)
-#define BSWAP_4(x)                                                            \
-  (((x) & 0xFF) << 24) |                                                      \
-  (((x) & 0xFF00) << 8) |                                                     \
-  (((x) >> 8) & 0xFF00) |                                                     \
-  (((x) >> 24) & 0xFF)
-#define BSWAP_8(x)                                                            \
-  (((x) & 0xFF00000000000000ull) >> 56) |                                     \
-  (((x) & 0x00FF000000000000ull) >> 40) |                                     \
-  (((x) & 0x0000FF0000000000ull) >> 24) |                                     \
-  (((x) & 0x000000FF00000000ull) >> 8) |                                      \
-  (((x) & 0x00000000FF000000ull) << 8) |                                      \
-  (((x) & 0x0000000000FF0000ull) << 24) |                                     \
-  (((x) & 0x000000000000FF00ull) << 40) |                                     \
-  (((x) & 0x00000000000000FFull) << 56)
-#endif
-
 #define CHAR_TEST(bits, name, expr)                                           \
   template <typename T>                                                       \
   bool name(const T ch) {                                                     \
@@ -213,75 +180,6 @@ inline v8::Local<v8::String> OneByteString(v8::Isolate* isolate,
       .ToLocalChecked();
 }
 
-void SwapBytes16(char* data, size_t nbytes) {
-  CHECK_EQ(nbytes % 2, 0);
-
-#if defined(_MSC_VER)
-  if (AlignUp(data, sizeof(uint16_t)) == data) {
-    // MSVC has no strict aliasing, and is able to highly optimize this case.
-    uint16_t* data16 = reinterpret_cast<uint16_t*>(data);
-    size_t len16 = nbytes / sizeof(*data16);
-    for (size_t i = 0; i < len16; i++) {
-      data16[i] = BSWAP_2(data16[i]);
-    }
-    return;
-  }
-#endif
-
-  uint16_t temp;
-  for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
-    memcpy(&temp, &data[i], sizeof(temp));
-    temp = BSWAP_2(temp);
-    memcpy(&data[i], &temp, sizeof(temp));
-  }
-}
-
-void SwapBytes32(char* data, size_t nbytes) {
-  CHECK_EQ(nbytes % 4, 0);
-
-#if defined(_MSC_VER)
-  // MSVC has no strict aliasing, and is able to highly optimize this case.
-  if (AlignUp(data, sizeof(uint32_t)) == data) {
-    uint32_t* data32 = reinterpret_cast<uint32_t*>(data);
-    size_t len32 = nbytes / sizeof(*data32);
-    for (size_t i = 0; i < len32; i++) {
-      data32[i] = BSWAP_4(data32[i]);
-    }
-    return;
-  }
-#endif
-
-  uint32_t temp;
-  for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
-    memcpy(&temp, &data[i], sizeof(temp));
-    temp = BSWAP_4(temp);
-    memcpy(&data[i], &temp, sizeof(temp));
-  }
-}
-
-void SwapBytes64(char* data, size_t nbytes) {
-  CHECK_EQ(nbytes % 8, 0);
-
-#if defined(_MSC_VER)
-  if (AlignUp(data, sizeof(uint64_t)) == data) {
-    // MSVC has no strict aliasing, and is able to highly optimize this case.
-    uint64_t* data64 = reinterpret_cast<uint64_t*>(data);
-    size_t len64 = nbytes / sizeof(*data64);
-    for (size_t i = 0; i < len64; i++) {
-      data64[i] = BSWAP_8(data64[i]);
-    }
-    return;
-  }
-#endif
-
-  uint64_t temp;
-  for (size_t i = 0; i < nbytes; i += sizeof(temp)) {
-    memcpy(&temp, &data[i], sizeof(temp));
-    temp = BSWAP_8(temp);
-    memcpy(&data[i], &temp, sizeof(temp));
-  }
-}
-
 char ToLower(char c) {
   return std::tolower(c, std::locale::classic());
 }
@@ -349,7 +247,7 @@ T* UncheckedRealloc(T* pointer, size_t n) {
 
   void* allocated = realloc(pointer, full_size);
 
-  if (UNLIKELY(allocated == nullptr)) {
+  if (allocated == nullptr) [[unlikely]] {
     // Tell V8 that memory is low and retry.
     LowMemoryNotification();
     allocated = realloc(pointer, full_size);
@@ -361,14 +259,12 @@ T* UncheckedRealloc(T* pointer, size_t n) {
 // As per spec realloc behaves like malloc if passed nullptr.
 template <typename T>
 inline T* UncheckedMalloc(size_t n) {
-  if (n == 0) n = 1;
   return UncheckedRealloc<T>(nullptr, n);
 }
 
 template <typename T>
 inline T* UncheckedCalloc(size_t n) {
-  if (n == 0) n = 1;
-  MultiplyWithOverflowCheck(sizeof(T), n);
+  if (MultiplyWithOverflowCheck(sizeof(T), n) == 0) return nullptr;
   return static_cast<T*>(calloc(n, sizeof(T)));
 }
 
@@ -403,11 +299,34 @@ inline char* UncheckedCalloc(size_t n) { return UncheckedCalloc<char>(n); }
 // headers than we really need to.
 void ThrowErrStringTooLong(v8::Isolate* isolate);
 
+struct ArrayIterationData {
+  std::vector<v8::Global<v8::Value>>* out;
+  v8::Isolate* isolate = nullptr;
+};
+
+inline v8::Array::CallbackResult PushItemToVector(uint32_t index,
+                                                  v8::Local<v8::Value> element,
+                                                  void* data) {
+  auto vec = static_cast<ArrayIterationData*>(data)->out;
+  auto isolate = static_cast<ArrayIterationData*>(data)->isolate;
+  vec->push_back(v8::Global<v8::Value>(isolate, element));
+  return v8::Array::CallbackResult::kContinue;
+}
+
+v8::Maybe<void> FromV8Array(v8::Local<v8::Context> context,
+                            v8::Local<v8::Array> js_array,
+                            std::vector<v8::Global<v8::Value>>* out) {
+  uint32_t count = js_array->Length();
+  out->reserve(count);
+  ArrayIterationData data{out, context->GetIsolate()};
+  return js_array->Iterate(context, PushItemToVector, &data);
+}
+
 v8::MaybeLocal<v8::Value> ToV8Value(v8::Local<v8::Context> context,
                                     std::string_view str,
                                     v8::Isolate* isolate) {
   if (isolate == nullptr) isolate = context->GetIsolate();
-  if (UNLIKELY(str.size() >= static_cast<size_t>(v8::String::kMaxLength))) {
+  if (str.size() >= static_cast<size_t>(v8::String::kMaxLength)) [[unlikely]] {
     // V8 only has a TODO comment about adding an exception when the maximum
     // string size is exceeded.
     ThrowErrStringTooLong(isolate);
@@ -512,11 +431,28 @@ SlicedArguments::SlicedArguments(
     (*this)[i] = args[i + start];
 }
 
+template <typename T, size_t kStackStorageSize>
+void MaybeStackBuffer<T, kStackStorageSize>::AllocateSufficientStorage(
+    size_t storage) {
+  CHECK(!IsInvalidated());
+  if (storage > capacity()) {
+    bool was_allocated = IsAllocated();
+    T* allocated_ptr = was_allocated ? buf_ : nullptr;
+    buf_ = Realloc(allocated_ptr, storage);
+    capacity_ = storage;
+    if (!was_allocated && length_ > 0)
+      memcpy(buf_, buf_st_, length_ * sizeof(buf_[0]));
+  }
+
+  length_ = storage;
+}
+
 template <typename T, size_t S>
 ArrayBufferViewContents<T, S>::ArrayBufferViewContents(
     v8::Local<v8::Value> value) {
-  CHECK(value->IsArrayBufferView());
-  Read(value.As<v8::ArrayBufferView>());
+  DCHECK(value->IsArrayBufferView() || value->IsSharedArrayBuffer() ||
+         value->IsArrayBuffer());
+  ReadValue(value);
 }
 
 template <typename T, size_t S>
@@ -537,15 +473,35 @@ void ArrayBufferViewContents<T, S>::Read(v8::Local<v8::ArrayBufferView> abv) {
   static_assert(sizeof(T) == 1, "Only supports one-byte data at the moment");
   length_ = abv->ByteLength();
   if (length_ > sizeof(stack_storage_) || abv->HasBuffer()) {
-    data_ = static_cast<T*>(abv->Buffer()->GetBackingStore()->Data()) +
-        abv->ByteOffset();
+    data_ = static_cast<T*>(abv->Buffer()->Data()) + abv->ByteOffset();
   } else {
     abv->CopyContents(stack_storage_, sizeof(stack_storage_));
     data_ = stack_storage_;
   }
 }
 
-// ECMA262 20.1.2.5
+template <typename T, size_t S>
+void ArrayBufferViewContents<T, S>::ReadValue(v8::Local<v8::Value> buf) {
+  static_assert(sizeof(T) == 1, "Only supports one-byte data at the moment");
+  DCHECK(buf->IsArrayBufferView() || buf->IsSharedArrayBuffer() ||
+         buf->IsArrayBuffer());
+
+  if (buf->IsArrayBufferView()) {
+    Read(buf.As<v8::ArrayBufferView>());
+  } else if (buf->IsArrayBuffer()) {
+    auto ab = buf.As<v8::ArrayBuffer>();
+    length_ = ab->ByteLength();
+    data_ = static_cast<T*>(ab->Data());
+    was_detached_ = ab->WasDetached();
+  } else {
+    CHECK(buf->IsSharedArrayBuffer());
+    auto sab = buf.As<v8::SharedArrayBuffer>();
+    length_ = sab->ByteLength();
+    data_ = static_cast<T*>(sab->Data());
+  }
+}
+
+// ECMA-262, 15th edition, 21.1.2.5. Number.isSafeInteger
 inline bool IsSafeJsInt(v8::Local<v8::Value> v) {
   if (!v->IsNumber()) return false;
   double v_d = v.As<v8::Number>()->Value();
@@ -556,11 +512,11 @@ inline bool IsSafeJsInt(v8::Local<v8::Value> v) {
   return false;
 }
 
-constexpr size_t FastStringKey::HashImpl(const char* str) {
+constexpr size_t FastStringKey::HashImpl(std::string_view str) {
   // Low-quality hash (djb2), but just fine for current use cases.
   size_t h = 5381;
-  while (*str != '\0') {
-    h = h * 33 + *(str++);  // NOLINT(readability/pointer_notation)
+  for (const char c : str) {
+    h = h * 33 + c;
   }
   return h;
 }
@@ -571,22 +527,36 @@ constexpr size_t FastStringKey::Hash::operator()(
 }
 
 constexpr bool FastStringKey::operator==(const FastStringKey& other) const {
-  const char* p1 = name_;
-  const char* p2 = other.name_;
-  if (p1 == p2) return true;
-  do {
-    if (*(p1++) != *(p2++)) return false;
-  } while (*p1 != '\0');
-  return *p2 == '\0';
+  return name_ == other.name_;
 }
 
-constexpr FastStringKey::FastStringKey(const char* name)
-  : name_(name), cached_hash_(HashImpl(name)) {}
+constexpr FastStringKey::FastStringKey(std::string_view name)
+    : name_(name), cached_hash_(HashImpl(name)) {}
 
-constexpr const char* FastStringKey::c_str() const {
+constexpr std::string_view FastStringKey::as_string_view() const {
   return name_;
 }
 
+// Inline so the compiler can fully optimize it away on Unix platforms.
+bool IsWindowsBatchFile(const char* filename) {
+#ifdef _WIN32
+  std::string file_with_extension = filename;
+  // Regex to match the last extension part after the last dot, ignoring
+  // trailing spaces and dots
+  std::regex extension_regex(R"(\.([a-zA-Z0-9]+)\s*[\.\s]*$)");
+  std::smatch match;
+  std::string extension;
+
+  if (std::regex_search(file_with_extension, match, extension_regex)) {
+    extension = ToLower(match[1].str());
+  }
+
+  return !extension.empty() && (extension == "cmd" || extension == "bat");
+#else
+  return false;
+#endif  // _WIN32
+}
+
 }  // namespace node
 
 #endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS