@encharm/cws 4.3.0 → 4.4.0

package/src/headers/20/base64-inl.h

@@ -0,0 +1,193 @@
+#ifndef SRC_BASE64_INL_H_
+#define SRC_BASE64_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base64.h"
+#include "libbase64.h"
+#include "util.h"
+
+namespace node {
+
+static constexpr char base64_table_url[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+                                           "abcdefghijklmnopqrstuvwxyz"
+                                           "0123456789-_";
+
+extern const int8_t unbase64_table[256];
+
+
+inline static int8_t unbase64(uint8_t x) {
+  return unbase64_table[x];
+}
+
+
+inline uint32_t ReadUint32BE(const unsigned char* p) {
+  return static_cast<uint32_t>(p[0] << 24U) |
+         static_cast<uint32_t>(p[1] << 16U) |
+         static_cast<uint32_t>(p[2] << 8U) |
+         static_cast<uint32_t>(p[3]);
+}
+
+#ifdef _MSC_VER
+#pragma warning(push)
+// MSVC C4003: not enough actual parameters for macro 'identifier'
+#pragma warning(disable : 4003)
+#endif
+
+template <typename TypeName>
+bool base64_decode_group_slow(char* const dst, const size_t dstlen,
+                              const TypeName* const src, const size_t srclen,
+                              size_t* const i, size_t* const k) {
+  uint8_t hi;
+  uint8_t lo;
+#define V(expr)                                                                \
+  for (;;) {                                                                   \
+    const uint8_t c = static_cast<uint8_t>(src[*i]);                           \
+    lo = unbase64(c);                                                          \
+    *i += 1;                                                                   \
+    if (lo < 64) break;                         /* Legal character. */         \
+    if (c == '=' || *i >= srclen) return false; /* Stop decoding. */           \
+  }                                                                            \
+  expr;                                                                        \
+  if (*i >= srclen) return false;                                              \
+  if (*k >= dstlen) return false;                                              \
+  hi = lo;
+  V(/* Nothing. */);
+  V(dst[(*k)++] = ((hi & 0x3F) << 2) | ((lo & 0x30) >> 4));
+  V(dst[(*k)++] = ((hi & 0x0F) << 4) | ((lo & 0x3C) >> 2));
+  V(dst[(*k)++] = ((hi & 0x03) << 6) | ((lo & 0x3F) >> 0));
+#undef V
+  return true;  // Continue decoding.
+}
+
+#ifdef _MSC_VER
+#pragma warning(pop)
+#endif
+
+template <typename TypeName>
+size_t base64_decode_fast(char* const dst, const size_t dstlen,
+                          const TypeName* const src, const size_t srclen,
+                          const size_t decoded_size) {
+  const size_t available = dstlen < decoded_size ? dstlen : decoded_size;
+  const size_t max_k = available / 3 * 3;
+  size_t max_i = srclen / 4 * 4;
+  size_t i = 0;
+  size_t k = 0;
+  while (i < max_i && k < max_k) {
+    const unsigned char txt[] = {
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 0]))),
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 1]))),
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 2]))),
+        static_cast<unsigned char>(unbase64(static_cast<uint8_t>(src[i + 3]))),
+    };
+
+    const uint32_t v = ReadUint32BE(txt);
+    // If MSB is set, input contains whitespace or is not valid base64.
+    if (v & 0x80808080) {
+      if (!base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k))
+        return k;
+      max_i = i + (srclen - i) / 4 * 4;  // Align max_i again.
+    } else {
+      dst[k + 0] = ((v >> 22) & 0xFC) | ((v >> 20) & 0x03);
+      dst[k + 1] = ((v >> 12) & 0xF0) | ((v >> 10) & 0x0F);
+      dst[k + 2] = ((v >>  2) & 0xC0) | ((v >>  0) & 0x3F);
+      i += 4;
+      k += 3;
+    }
+  }
+  if (i < srclen && k < dstlen) {
+    base64_decode_group_slow(dst, dstlen, src, srclen, &i, &k);
+  }
+  return k;
+}
+
+
+template <typename TypeName>
+size_t base64_decoded_size(const TypeName* src, size_t size) {
+  // 1-byte input cannot be decoded
+  if (size < 2)
+    return 0;
+
+  if (src[size - 1] == '=') {
+    size--;
+    if (src[size - 1] == '=')
+      size--;
+  }
+  return base64_decoded_size_fast(size);
+}
+
+
+template <typename TypeName>
+size_t base64_decode(char* const dst, const size_t dstlen,
+                     const TypeName* const src, const size_t srclen) {
+  const size_t decoded_size = base64_decoded_size(src, srclen);
+  return base64_decode_fast(dst, dstlen, src, srclen, decoded_size);
+}
+
+
+inline size_t base64_encode(const char* src,
+                            size_t slen,
+                            char* dst,
+                            size_t dlen,
+                            Base64Mode mode) {
+  // We know how much we'll write, just make sure that there's space.
+  CHECK(dlen >= base64_encoded_size(slen, mode) &&
+        "not enough space provided for base64 encode");
+
+  dlen = base64_encoded_size(slen, mode);
+
+  if (mode == Base64Mode::NORMAL) {
+    ::base64_encode(src, slen, dst, &dlen, 0);
+    return dlen;
+  }
+
+  unsigned a;
+  unsigned b;
+  unsigned c;
+  unsigned i;
+  unsigned k;
+  unsigned n;
+
+  const char* table = base64_table_url;
+
+  i = 0;
+  k = 0;
+  n = slen / 3 * 3;
+
+  while (i < n) {
+    a = src[i + 0] & 0xff;
+    b = src[i + 1] & 0xff;
+    c = src[i + 2] & 0xff;
+
+    dst[k + 0] = table[a >> 2];
+    dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
+    dst[k + 2] = table[((b & 0x0f) << 2) | (c >> 6)];
+    dst[k + 3] = table[c & 0x3f];
+
+    i += 3;
+    k += 4;
+  }
+
+  switch (slen - n) {
+    case 1:
+      a = src[i + 0] & 0xff;
+      dst[k + 0] = table[a >> 2];
+      dst[k + 1] = table[(a & 3) << 4];
+      break;
+    case 2:
+      a = src[i + 0] & 0xff;
+      b = src[i + 1] & 0xff;
+      dst[k + 0] = table[a >> 2];
+      dst[k + 1] = table[((a & 3) << 4) | (b >> 4)];
+      dst[k + 2] = table[(b & 0x0f) << 2];
+      break;
+  }
+
+  return dlen;
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_BASE64_INL_H_

package/src/headers/20/base64.h

@@ -0,0 +1,53 @@
+#ifndef SRC_BASE64_H_
+#define SRC_BASE64_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "util.h"
+
+#include <cmath>
+#include <cstddef>
+#include <cstdint>
+
+namespace node {
+//// Base 64 ////
+
+enum class Base64Mode {
+  NORMAL,
+  URL
+};
+
+static inline constexpr size_t base64_encoded_size(
+    size_t size,
+    Base64Mode mode = Base64Mode::NORMAL) {
+  return mode == Base64Mode::NORMAL ? ((size + 2) / 3 * 4)
+                                    : static_cast<size_t>(std::ceil(
+                                          static_cast<double>(size * 4) / 3));
+}
+
+// Doesn't check for padding at the end.  Can be 1-2 bytes over.
+static inline constexpr size_t base64_decoded_size_fast(size_t size) {
+  // 1-byte input cannot be decoded
+  return size > 1 ? (size / 4) * 3 + (size % 4 + 1) / 2 : 0;
+}
+
+inline uint32_t ReadUint32BE(const unsigned char* p);
+
+template <typename TypeName>
+size_t base64_decoded_size(const TypeName* src, size_t size);
+
+template <typename TypeName>
+size_t base64_decode(char* const dst, const size_t dstlen,
+                     const TypeName* const src, const size_t srclen);
+
+inline size_t base64_encode(const char* src,
+                            size_t slen,
+                            char* dst,
+                            size_t dlen,
+                            Base64Mode mode = Base64Mode::NORMAL);
+}  // namespace node
+
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_BASE64_H_

package/src/headers/20/base64_version.h

@@ -0,0 +1,6 @@
+// This is an auto generated file, please do not edit.
+// Refer to tools/dep_updaters/update-base64.sh
+#ifndef SRC_BASE64_VERSION_H_
+#define SRC_BASE64_VERSION_H_
+#define BASE64_VERSION "0.5.0"
+#endif  // SRC_BASE64_VERSION_H_

package/src/headers/20/base_object-inl.h

@@ -0,0 +1,316 @@
+// 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_INL_H_
+#define SRC_BASE_OBJECT_INL_H_
+
+#if defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#include "base_object.h"
+#include "env-inl.h"
+#include "util.h"
+
+#include "v8.h"
+
+namespace node {
+
+BaseObject::BaseObject(Environment* env, v8::Local<v8::Object> object)
+    : BaseObject(env->principal_realm(), object) {
+  // TODO(legendecas): Check the shorthand is only used in the principal realm
+  // while allowing to create a BaseObject in a vm context.
+}
+
+void BaseObject::Detach() {
+  CHECK_GT(pointer_data()->strong_ptr_count, 0);
+  pointer_data()->is_detached = true;
+}
+
+v8::Global<v8::Object>& BaseObject::persistent() {
+  return persistent_handle_;
+}
+
+
+v8::Local<v8::Object> BaseObject::object() const {
+  return PersistentToLocal::Default(env()->isolate(), persistent_handle_);
+}
+
+v8::Local<v8::Object> BaseObject::object(v8::Isolate* isolate) const {
+  v8::Local<v8::Object> handle = object();
+
+  DCHECK_EQ(handle->GetCreationContext().ToLocalChecked()->GetIsolate(),
+            isolate);
+  DCHECK_EQ(env()->isolate(), isolate);
+
+  return handle;
+}
+
+Environment* BaseObject::env() const {
+  return realm_->env();
+}
+
+Realm* BaseObject::realm() const {
+  return realm_;
+}
+
+bool BaseObject::IsBaseObject(IsolateData* isolate_data,
+                              v8::Local<v8::Object> obj) {
+  if (obj->InternalFieldCount() < BaseObject::kInternalFieldCount) {
+    return false;
+  }
+
+  uint16_t* ptr = static_cast<uint16_t*>(
+      obj->GetAlignedPointerFromInternalField(BaseObject::kEmbedderType));
+  return ptr == isolate_data->embedder_id_for_non_cppgc();
+}
+
+void BaseObject::TagBaseObject(IsolateData* isolate_data,
+                               v8::Local<v8::Object> object) {
+  DCHECK_GE(object->InternalFieldCount(), BaseObject::kInternalFieldCount);
+  object->SetAlignedPointerInInternalField(
+      BaseObject::kEmbedderType, isolate_data->embedder_id_for_non_cppgc());
+}
+
+void BaseObject::SetInternalFields(IsolateData* isolate_data,
+                                   v8::Local<v8::Object> object,
+                                   void* slot) {
+  TagBaseObject(isolate_data, object);
+  object->SetAlignedPointerInInternalField(BaseObject::kSlot, slot);
+}
+
+BaseObject* BaseObject::FromJSObject(v8::Local<v8::Value> value) {
+  v8::Local<v8::Object> obj = value.As<v8::Object>();
+  DCHECK_GE(obj->InternalFieldCount(), BaseObject::kInternalFieldCount);
+  return static_cast<BaseObject*>(
+      obj->GetAlignedPointerFromInternalField(BaseObject::kSlot));
+}
+
+template <typename T>
+T* BaseObject::FromJSObject(v8::Local<v8::Value> object) {
+  return static_cast<T*>(FromJSObject(object));
+}
+
+void BaseObject::OnGCCollect() {
+  delete this;
+}
+
+void BaseObject::ClearWeak() {
+  if (has_pointer_data())
+    pointer_data()->wants_weak_jsobj = false;
+
+  persistent_handle_.ClearWeak();
+}
+
+bool BaseObject::IsWeakOrDetached() const {
+  if (persistent_handle_.IsWeak()) return true;
+
+  if (!has_pointer_data()) return false;
+  const PointerData* pd = const_cast<BaseObject*>(this)->pointer_data();
+  return pd->wants_weak_jsobj || pd->is_detached;
+}
+
+v8::EmbedderGraph::Node::Detachedness BaseObject::GetDetachedness() const {
+  return IsWeakOrDetached() ? v8::EmbedderGraph::Node::Detachedness::kDetached
+                            : v8::EmbedderGraph::Node::Detachedness::kUnknown;
+}
+
+template <int Field>
+void BaseObject::InternalFieldGet(
+    v8::Local<v8::String> property,
+    const v8::PropertyCallbackInfo<v8::Value>& info) {
+  info.GetReturnValue().Set(
+      info.This()->GetInternalField(Field).As<v8::Value>());
+}
+
+template <int Field, bool (v8::Value::* typecheck)() const>
+void BaseObject::InternalFieldSet(v8::Local<v8::String> property,
+                                  v8::Local<v8::Value> value,
+                                  const v8::PropertyCallbackInfo<void>& info) {
+  // This could be e.g. value->IsFunction().
+  CHECK(((*value)->*typecheck)());
+  info.This()->SetInternalField(Field, value);
+}
+
+bool BaseObject::has_pointer_data() const {
+  return pointer_data_ != nullptr;
+}
+
+template <typename T, bool kIsWeak>
+BaseObject::PointerData*
+BaseObjectPtrImpl<T, kIsWeak>::pointer_data() const {
+  if constexpr (kIsWeak) {
+    return data_.pointer_data;
+  }
+  if (get_base_object() == nullptr) {
+    return nullptr;
+  }
+  return get_base_object()->pointer_data();
+}
+
+template <typename T, bool kIsWeak>
+BaseObject* BaseObjectPtrImpl<T, kIsWeak>::get_base_object() const {
+  if constexpr (kIsWeak) {
+    if (pointer_data() == nullptr) {
+      return nullptr;
+    }
+    return pointer_data()->self;
+  }
+  return data_.target;
+}
+
+template <typename T, bool kIsWeak>
+BaseObjectPtrImpl<T, kIsWeak>::~BaseObjectPtrImpl() {
+  if constexpr (kIsWeak) {
+    if (pointer_data() != nullptr &&
+        --pointer_data()->weak_ptr_count == 0 &&
+        pointer_data()->self == nullptr) {
+      delete pointer_data();
+    }
+  } else if (get() != nullptr) {
+    get()->decrease_refcount();
+  }
+}
+
+template <typename T, bool kIsWeak>
+BaseObjectPtrImpl<T, kIsWeak>::BaseObjectPtrImpl() {
+  data_.target = nullptr;
+}
+
+template <typename T, bool kIsWeak>
+BaseObjectPtrImpl<T, kIsWeak>::BaseObjectPtrImpl(T* target)
+  : BaseObjectPtrImpl() {
+  if (target == nullptr) return;
+  if constexpr (kIsWeak) {
+    data_.pointer_data = target->pointer_data();
+    CHECK_NOT_NULL(pointer_data());
+    pointer_data()->weak_ptr_count++;
+  } else {
+    data_.target = target;
+    CHECK_NOT_NULL(pointer_data());
+    get()->increase_refcount();
+  }
+}
+
+template <typename T, bool kIsWeak>
+template <typename U, bool kW>
+BaseObjectPtrImpl<T, kIsWeak>::BaseObjectPtrImpl(
+    const BaseObjectPtrImpl<U, kW>& other)
+  : BaseObjectPtrImpl(other.get()) {}
+
+template <typename T, bool kIsWeak>
+BaseObjectPtrImpl<T, kIsWeak>::BaseObjectPtrImpl(const BaseObjectPtrImpl& other)
+  : BaseObjectPtrImpl(other.get()) {}
+
+template <typename T, bool kIsWeak>
+template <typename U, bool kW>
+BaseObjectPtrImpl<T, kIsWeak>& BaseObjectPtrImpl<T, kIsWeak>::operator=(
+    const BaseObjectPtrImpl<U, kW>& other) {
+  if (other.get() == get()) return *this;
+  this->~BaseObjectPtrImpl();
+  return *new (this) BaseObjectPtrImpl(other);
+}
+
+template <typename T, bool kIsWeak>
+BaseObjectPtrImpl<T, kIsWeak>& BaseObjectPtrImpl<T, kIsWeak>::operator=(
+    const BaseObjectPtrImpl& other) {
+  if (other.get() == get()) return *this;
+  this->~BaseObjectPtrImpl();
+  return *new (this) BaseObjectPtrImpl(other);
+}
+
+template <typename T, bool kIsWeak>
+BaseObjectPtrImpl<T, kIsWeak>::BaseObjectPtrImpl(BaseObjectPtrImpl&& other)
+  : data_(other.data_) {
+  if constexpr (kIsWeak)
+    other.data_.target = nullptr;
+  else
+    other.data_.pointer_data = nullptr;
+}
+
+template <typename T, bool kIsWeak>
+BaseObjectPtrImpl<T, kIsWeak>& BaseObjectPtrImpl<T, kIsWeak>::operator=(
+    BaseObjectPtrImpl&& other) {
+  if (&other == this) return *this;
+  this->~BaseObjectPtrImpl();
+  return *new (this) BaseObjectPtrImpl(std::move(other));
+}
+
+template <typename T, bool kIsWeak>
+void BaseObjectPtrImpl<T, kIsWeak>::reset(T* ptr) {
+  *this = BaseObjectPtrImpl(ptr);
+}
+
+template <typename T, bool kIsWeak>
+T* BaseObjectPtrImpl<T, kIsWeak>::get() const {
+  return static_cast<T*>(get_base_object());
+}
+
+template <typename T, bool kIsWeak>
+T& BaseObjectPtrImpl<T, kIsWeak>::operator*() const {
+  return *get();
+}
+
+template <typename T, bool kIsWeak>
+T* BaseObjectPtrImpl<T, kIsWeak>::operator->() const {
+  return get();
+}
+
+template <typename T, bool kIsWeak>
+BaseObjectPtrImpl<T, kIsWeak>::operator bool() const {
+  return get() != nullptr;
+}
+
+template <typename T, bool kIsWeak>
+template <typename U, bool kW>
+bool BaseObjectPtrImpl<T, kIsWeak>::operator ==(
+    const BaseObjectPtrImpl<U, kW>& other) const {
+  return get() == other.get();
+}
+
+template <typename T, bool kIsWeak>
+template <typename U, bool kW>
+bool BaseObjectPtrImpl<T, kIsWeak>::operator !=(
+    const BaseObjectPtrImpl<U, kW>& other) const {
+  return get() != other.get();
+}
+
+template <typename T, typename... Args>
+BaseObjectPtr<T> MakeBaseObject(Args&&... args) {
+  return BaseObjectPtr<T>(new T(std::forward<Args>(args)...));
+}
+template <typename T, typename... Args>
+BaseObjectWeakPtr<T> MakeWeakBaseObject(Args&&... args) {
+  T* target = new T(std::forward<Args>(args)...);
+  target->MakeWeak();
+  return BaseObjectWeakPtr<T>(target);
+}
+
+template <typename T, typename... Args>
+BaseObjectPtr<T> MakeDetachedBaseObject(Args&&... args) {
+  BaseObjectPtr<T> target = MakeBaseObject<T>(std::forward<Args>(args)...);
+  target->Detach();
+  return target;
+}
+
+}  // namespace node
+
+#endif  // defined(NODE_WANT_INTERNALS) && NODE_WANT_INTERNALS
+
+#endif  // SRC_BASE_OBJECT_INL_H_