react-native-windows 0.81.34 → 0.81.37

package/external/folly/folly/detail/UniqueInstance.h

@@ -0,0 +1,68 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstdint>
+#include <typeinfo>
+
+#include <folly/CppAttributes.h>
+#include <folly/detail/StaticSingletonManager.h>
+
+namespace folly {
+namespace detail {
+
+class UniqueInstance {
+ public:
+  template <template <typename...> class Z, typename... Key, typename... Mapped>
+  FOLLY_EXPORT FOLLY_ALWAYS_INLINE explicit UniqueInstance(
+      tag_t<Z<Key..., Mapped...>>, tag_t<Key...>, tag_t<Mapped...>) noexcept {
+    static constexpr Ptr const tmpl = FOLLY_TYPE_INFO_OF(key_t<Z>);
+    static constexpr Ptr const ptrs[] = {
+        FOLLY_TYPE_INFO_OF(tag_t<Key>)...,
+        FOLLY_TYPE_INFO_OF(tag_t<Mapped>)...};
+    static FOLLY_CONSTINIT Arg arg{
+        {tmpl, ptrs, sizeof...(Key), sizeof...(Mapped)},
+        {tag<Value, key_t<Z, Key...>>}};
+    enforce(arg);
+  }
+
+  UniqueInstance(UniqueInstance const&) = delete;
+  UniqueInstance(UniqueInstance&&) = delete;
+  UniqueInstance& operator=(UniqueInstance const&) = delete;
+  UniqueInstance& operator=(UniqueInstance&&) = delete;
+
+ private:
+  template <template <typename...> class Z, typename... Key>
+  struct key_t {};
+
+  using Ptr = std::type_info const*;
+  struct Value {
+    Ptr tmpl;
+    Ptr const* ptrs;
+    std::uint32_t key_size;
+    std::uint32_t mapped_size;
+  };
+  struct Arg {
+    Value local;
+    StaticSingletonManager::ArgCreate<true> global;
+  };
+
+  static void enforce(Arg& arg) noexcept;
+};
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/detail/base64_detail/BUCK

@@ -0,0 +1,102 @@
+load("@fbcode_macros//build_defs:cpp_library.bzl", "cpp_library")
+
+oncall("fbcode_entropy_wardens_folly")
+
+cpp_library(
+    name = "base64_api",
+    srcs = ["Base64Api.cpp"],
+    headers = ["Base64Api.h"],
+    deps = [
+        ":base64_sse4_2",
+        ":base64_swar",
+        "//folly:cpu_id",
+    ],
+    exported_deps = [
+        ":base64_common",
+        ":base64_scalar",
+        "//folly:portability",
+        "//folly/portability:constexpr",
+    ],
+)
+
+cpp_library(
+    name = "base64_common",
+    headers = ["Base64Common.h"],
+)
+
+cpp_library(
+    name = "base64_constants",
+    headers = ["Base64Constants.h"],
+)
+
+cpp_library(
+    name = "base64_hidden_constants",
+    headers = ["Base64HiddenConstants.h"],
+    exported_deps = [
+        ":base64_constants",
+    ],
+)
+
+cpp_library(
+    name = "base64_scalar",
+    headers = ["Base64Scalar.h"],
+    exported_deps = [
+        ":base64_common",
+        ":base64_constants",
+    ],
+)
+
+cpp_library(
+    name = "base64_simd",
+    headers = ["Base64Simd.h"],
+    exported_deps = [
+        ":base64_common",
+        ":base64_constants",
+        ":base64_hidden_constants",
+        ":base64_scalar",
+        ":base64_swar",
+        "//folly:c_portability",
+    ],
+)
+
+cpp_library(
+    name = "base64_sse4_2_platform",
+    headers = ["Base64_SSE4_2_Platform.h"],
+    exported_deps = [
+        ":base64_hidden_constants",
+        "//folly:portability",
+    ],
+)
+
+cpp_library(
+    name = "base64_sse4_2",
+    srcs = ["Base64_SSE4_2.cpp"],
+    headers = ["Base64_SSE4_2.h"],
+    compiler_flags = select({
+        "DEFAULT": [],
+        "ovr_config//cpu:x86_64": ["-msse4.2"],
+    }),
+    deps = [
+        ":base64_simd",
+        ":base64_sse4_2_platform",
+    ],
+    exported_deps = [
+        ":base64_common",
+        "//folly:portability",
+    ],
+)
+
+cpp_library(
+    name = "base64_swar",
+    srcs = ["Base64SWAR.cpp"],
+    headers = ["Base64SWAR.h"],
+    deps = [
+        ":base64_constants",
+        ":base64_hidden_constants",
+        ":base64_scalar",
+        "//folly:portability",
+    ],
+    exported_deps = [
+        ":base64_common",
+    ],
+)

package/external/folly/folly/detail/base64_detail/Base64Api.cpp

@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <folly/CpuId.h>
+#include <folly/Portability.h>
+#include <folly/detail/base64_detail/Base64Api.h>
+#include <folly/detail/base64_detail/Base64SWAR.h>
+#include <folly/detail/base64_detail/Base64_SSE4_2.h>
+
+namespace folly::detail::base64_detail {
+Base64RuntimeImpl base64EncodeSelectImplementation() {
+#if FOLLY_SSE_PREREQ(4, 2)
+  if (folly::CpuId().sse42()) {
+    return {
+        base64Encode_SSE4_2,
+        base64URLEncode_SSE4_2,
+        base64Decode_SSE4_2,
+        base64URLDecodeSWAR};
+  }
+#endif
+  return {
+      base64EncodeScalar,
+      base64URLEncodeScalar,
+      base64DecodeSWAR,
+      base64URLDecodeSWAR};
+}
+} // namespace folly::detail::base64_detail

package/external/folly/folly/detail/base64_detail/Base64Api.h

@@ -0,0 +1,101 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <type_traits>
+#include <folly/Portability.h>
+#include <folly/detail/base64_detail/Base64Common.h>
+#include <folly/detail/base64_detail/Base64Scalar.h>
+#include <folly/portability/Constexpr.h>
+
+namespace folly::detail::base64_detail {
+
+struct Base64RuntimeImpl {
+  using Encode = char* (*)(const char*, const char*, char*) noexcept;
+  using Decode =
+      Base64DecodeResult (*)(const char*, const char*, char*) noexcept;
+
+  Encode encode;
+  Encode encodeURL;
+  Decode decode;
+  Decode decodeURL;
+};
+
+Base64RuntimeImpl base64EncodeSelectImplementation();
+
+inline const auto& base64RuntimeImpl() {
+  static const auto r = base64EncodeSelectImplementation();
+  return r;
+}
+
+inline char* base64EncodeRuntime(
+    const char* f, const char* l, char* o) noexcept {
+  return base64RuntimeImpl().encode(f, l, o);
+}
+
+inline constexpr char* base64Encode(
+    const char* f, const char* l, char* o) noexcept {
+  if (folly::is_constant_evaluated_or(true)) {
+    return base64EncodeScalar(f, l, o);
+  } else {
+    return base64EncodeRuntime(f, l, o);
+  }
+}
+
+inline char* base64URLEncodeRuntime(
+    const char* f, const char* l, char* o) noexcept {
+  return base64RuntimeImpl().encodeURL(f, l, o);
+}
+
+inline constexpr char* base64URLEncode(
+    const char* f, const char* l, char* o) noexcept {
+  if (folly::is_constant_evaluated_or(true)) {
+    return base64URLEncodeScalar(f, l, o);
+  } else {
+    return base64URLEncodeRuntime(f, l, o);
+  }
+}
+
+inline Base64DecodeResult base64DecodeRuntime(
+    const char* f, const char* l, char* o) noexcept {
+  return base64RuntimeImpl().decode(f, l, o);
+}
+
+inline constexpr Base64DecodeResult base64Decode(
+    const char* f, const char* l, char* o) noexcept {
+  if (folly::is_constant_evaluated_or(true)) {
+    return base64DecodeScalar(f, l, o);
+  } else {
+    return base64DecodeRuntime(f, l, o);
+  }
+}
+
+inline Base64DecodeResult base64URLDecodeRuntime(
+    const char* f, const char* l, char* o) noexcept {
+  return base64RuntimeImpl().decodeURL(f, l, o);
+}
+
+inline constexpr Base64DecodeResult base64URLDecode(
+    const char* f, const char* l, char* o) noexcept {
+  if (folly::is_constant_evaluated_or(true)) {
+    return base64URLDecodeScalar(f, l, o);
+  } else {
+    return base64URLDecodeRuntime(f, l, o);
+  }
+}
+
+} // namespace folly::detail::base64_detail

package/external/folly/folly/detail/base64_detail/Base64Common.h

@@ -0,0 +1,80 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <cstddef>
+#include <cstdint>
+
+namespace folly::detail::base64_detail {
+
+constexpr std::size_t base64EncodedSize(std::size_t inSize) {
+  return ((inSize + 2) / 3) * 4;
+}
+
+constexpr std::size_t base64URLEncodedSize(std::size_t inSize) {
+  return (inSize / 3) * 4 + inSize % 3 + (inSize % 3 > 0);
+}
+
+// More incorrect usage of '=' padding will be detected during decoding
+constexpr std::size_t base64PaddingToSubtract(const char* l) {
+  bool isL_1Padding = *(l - 1) == '=';
+  bool isL_2Padding = *(l - 2) == '=';
+
+  return isL_1Padding + (isL_1Padding && isL_2Padding);
+}
+
+// Does not detect errors, all of them will be detected during actual decoding.
+constexpr std::size_t base64DecodedSize(const char* f, const char* l) {
+  std::size_t n = static_cast<std::size_t>(l - f);
+  if (n < 4) { // correctness is checked when decoding
+    return 0;
+  }
+  std::size_t res = n / 4 * 3;
+  res -= base64PaddingToSubtract(l);
+
+  return res;
+}
+
+constexpr std::size_t base64URLDecodedSize(const char* f, const char* l) {
+  std::size_t n = static_cast<std::size_t>(l - f);
+
+  // Unfortunatly, we cannot reuse the base64DecodedSize here.
+  if (n < 2) {
+    return 0;
+  }
+
+  std::size_t res = n / 4 * 3;
+
+  if (n % 4 == 0) {
+    // The invalid padding causes a lot of assumptions break.
+    // Introduced an extra check to only subtract padding when it's
+    // in a valid position.
+    res -= base64PaddingToSubtract(l);
+  }
+
+  std::size_t extra = (n % 4) > 0 ? n % 4 - 1 : 0;
+  res += extra;
+
+  return res;
+}
+
+struct Base64DecodeResult {
+  bool isSuccess = false;
+  char* o;
+};
+
+} // namespace folly::detail::base64_detail

package/external/folly/folly/detail/base64_detail/Base64Constants.h

@@ -0,0 +1,79 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+
+namespace folly::detail::base64_detail::constants {
+
+// Scalar --------------------------------------=
+
+constexpr char kBase64Charset[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+constexpr char kBase64URLCharset[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
+
+// Special value that we can or with any valid value and that
+// way keep track if we had encountered an error or not.
+constexpr char kDecodeErrorMarker = char(0xff);
+
+constexpr char base64DecodeRule(char x) {
+  if ('A' <= x && x <= 'Z') {
+    return x - 'A';
+  }
+  if ('a' <= x && x <= 'z') {
+    return x - 'a' + 26;
+  }
+  if ('0' <= x && x <= '9') {
+    return x - '0' + 26 * 2;
+  }
+  if (x == '+') {
+    return 62;
+  }
+  if (x == '/') {
+    return 63;
+  }
+  return kDecodeErrorMarker;
+}
+
+constexpr char base64URLDecodeRule(char x) {
+  if (x == '-') {
+    return 62;
+  }
+  if (x == '_') {
+    return 63;
+  }
+  return base64DecodeRule(x);
+}
+
+template <typename DecodeChar>
+constexpr auto buildDecodeTable(DecodeChar decodeChar) {
+  std::array<char, 256> res = {};
+  for (std::size_t i = 0; i != res.size(); ++i) {
+    res[i] = decodeChar(static_cast<char>(i));
+  }
+  return res;
+}
+
+constexpr std::array<char, 256> kBase64DecodeTable =
+    buildDecodeTable(base64DecodeRule);
+constexpr std::array<char, 256> kBase64URLDecodeTable =
+    buildDecodeTable(base64URLDecodeRule);
+
+} // namespace folly::detail::base64_detail::constants

package/external/folly/folly/detail/base64_detail/Base64HiddenConstants.h

@@ -0,0 +1,129 @@
+/*
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#pragma once
+
+#include <array>
+#include <cstdint>
+#include <limits>
+#include <folly/detail/base64_detail/Base64Constants.h>
+
+namespace folly::detail::base64_detail::constants {
+
+// Some constants we have to expose for everyone in order to
+// support constexpr operations.
+// These we can internalize.
+
+// SWAR -----------------------------------------
+
+constexpr std::uint32_t kSwarDecodeErrorMarker = 0xff'ff'ff'ff;
+
+template <typename DecodeChar>
+constexpr std::array<std::array<std::uint32_t, 256>, 4> buildSWARDecodeTable(
+    DecodeChar decodeChar) {
+  std::array<std::array<std::uint32_t, 256>, 4> res = {};
+
+  for (std::uint32_t c = std::numeric_limits<std::uint8_t>::min();
+       c != std::numeric_limits<std::uint8_t>::max() + 1;
+       ++c) {
+    char decoded = decodeChar(static_cast<char>(c));
+    if (decoded == kDecodeErrorMarker) {
+      res[0][c] = res[1][c] = res[2][c] = res[3][c] = kSwarDecodeErrorMarker;
+      continue;
+    }
+
+    // What we want? '____'cddd'bbcc'aaab (LE)
+    // clang-format off
+    const std::uint32_t d = static_cast<std::uint32_t>(decoded);
+    res[0][c] = d << 2;                                   // 0000'0000'aaa0
+    res[1][c] = d >> 4 | (d << 12 & 0xff00);              // 0000'bb00'000b
+    res[2][c] = (d << 6 & 0xff00) | (d << 22 & 0xff0000); // c000'00cc'0000
+    res[3][c] = d << 16;                                  // 0ddd'0000'0000
+    // clang-format on
+  }
+
+  return res;
+}
+
+constexpr auto kBase64SwarDecodeTable = buildSWARDecodeTable(base64DecodeRule);
+constexpr auto kBase64SwarURLDecodeTable =
+    buildSWARDecodeTable(base64URLDecodeRule);
+
+// Simd -----------------------------------------
+
+// clang-format off
+constexpr std::array<std::int8_t, 16> kEncodeTable {{
+  'A' - 0,  'a' - 26,
+  '0' - 52, '1' - 53, '2' - 54, '3' - 55, '4' - 56,
+  '5' - 57, '6' - 58, '7' - 59, '8' - 60, '9' - 61,
+  '+' - 62, '/' - 63,
+  '=' - 64, '\0' - 65
+}};
+// clang-format on
+
+constexpr auto kEncodeURLTable = [] {
+  auto res = kEncodeTable;
+  res[12] += '-' - '+';
+  res[13] += '_' - '/';
+  return res;
+}();
+
+constexpr auto kValidHighByLowNibble = [] {
+  auto build = [](auto... nibbles) {
+    std::uint8_t nibblesArr[] = {static_cast<std::uint8_t>(nibbles)...};
+    std::uint8_t res = 0;
+    for (std::uint8_t nibble : nibblesArr) {
+      res |= 1 << nibble;
+    }
+    return res;
+  };
+
+  std::array<std::uint8_t, 16> res{};
+
+  res[0] = build(3, 5, 7);
+
+  // 1 - 9
+  res[1] = build(3, 4, 5, 6, 7);
+  for (int i = 1; i != 0xA; ++i) {
+    res[i] = res[1];
+  }
+
+  res[0xA] = build(4, 5, 6, 7);
+  res[0xB] = build(4, 6);
+  res[0xC] = build(1, 4, 6);
+  res[0xD] = res[0xB];
+  res[0xE] = res[0xB];
+  res[0xF] = build(2, 4, 6);
+
+  return res;
+}();
+
+// clang-format off
+constexpr std::array<std::int8_t, 16> kOffsetByHighNibbleDecodeTable {{
+  0,          // invalid
+  62 - 0x1C,  // 1: '+'
+  63 - '/',   // 2: '/'
+  52 - '0',   // 3: '0' - '9'
+  0  - 'A',   // 4: 'A' - 'O'
+  0  - 'A',   // 5: 'P' - 'Z'
+  26 - 'a',   // 6: 'a' - 'o'
+  26 - 'a',   // 7: 'p' - 'z'
+  0, 0, 0, 0, // 8, 9, 10, A: invalid
+  0, 0, 0, 0, // B, C, D, E: invalid
+}};
+// clang-format on
+
+} // namespace folly::detail::base64_detail::constants