react-native-windows 0.81.34 → 0.81.35

package/external/folly/folly/Exception.h

@@ -0,0 +1,150 @@
+/*
+ * 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 <errno.h>
+
+#include <cstdio>
+#include <stdexcept>
+#include <system_error>
+
+#include <folly/Conv.h>
+#include <folly/FBString.h>
+#include <folly/Likely.h>
+#include <folly/Portability.h>
+#include <folly/portability/SysTypes.h>
+
+namespace folly {
+
+// Various helpers to throw appropriate std::system_error exceptions from C
+// library errors (returned in errno, as positive return values (many POSIX
+// functions), or as negative return values (Linux syscalls))
+//
+// The *Explicit functions take an explicit value for errno.
+
+// On linux and similar platforms the value of `errno` is a mixture of
+// POSIX-`errno`-domain error codes and per-OS extended error codes. So the
+// most appropriate category to use is `system_category`.
+//
+// On Windows `system_category` means codes that can be returned by Win32 API
+// `GetLastError` and codes from the `errno`-domain must be reported as
+// `generic_category`.
+inline const std::error_category& errorCategoryForErrnoDomain() noexcept {
+  if (kIsWindows) {
+    return std::generic_category();
+  }
+  return std::system_category();
+}
+
+inline std::system_error makeSystemErrorExplicit(int err, const char* msg) {
+  return std::system_error(err, errorCategoryForErrnoDomain(), msg);
+}
+
+template <class... Args>
+std::system_error makeSystemErrorExplicit(int err, Args&&... args) {
+  return makeSystemErrorExplicit(
+      err, to<fbstring>(std::forward<Args>(args)...).c_str());
+}
+
+inline std::system_error makeSystemError(const char* msg) {
+  return makeSystemErrorExplicit(errno, msg);
+}
+
+template <class... Args>
+std::system_error makeSystemError(Args&&... args) {
+  return makeSystemErrorExplicit(errno, std::forward<Args>(args)...);
+}
+
+// Helper to throw std::system_error
+[[noreturn]] inline void throwSystemErrorExplicit(int err, const char* msg) {
+  throw_exception(makeSystemErrorExplicit(err, msg));
+}
+
+template <class... Args>
+[[noreturn]] void throwSystemErrorExplicit(int err, Args&&... args) {
+  throw_exception(makeSystemErrorExplicit(err, std::forward<Args>(args)...));
+}
+
+// Helper to throw std::system_error from errno and components of a string
+template <class... Args>
+[[noreturn]] void throwSystemError(Args&&... args) {
+  throwSystemErrorExplicit(errno, std::forward<Args>(args)...);
+}
+
+// Check a Posix return code (0 on success, error number on error), throw
+// on error.
+template <class... Args>
+void checkPosixError(int err, Args&&... args) {
+  if (FOLLY_UNLIKELY(err != 0)) {
+    throwSystemErrorExplicit(err, std::forward<Args>(args)...);
+  }
+}
+
+// Check a Linux kernel-style return code (>= 0 on success, negative error
+// number on error), throw on error.
+template <class... Args>
+void checkKernelError(ssize_t ret, Args&&... args) {
+  if (FOLLY_UNLIKELY(ret < 0)) {
+    throwSystemErrorExplicit(int(-ret), std::forward<Args>(args)...);
+  }
+}
+
+// Check a traditional Unix return code (-1 and sets errno on error), throw
+// on error.
+template <class... Args>
+void checkUnixError(ssize_t ret, Args&&... args) {
+  if (FOLLY_UNLIKELY(ret == -1)) {
+    throwSystemError(std::forward<Args>(args)...);
+  }
+}
+
+template <class... Args>
+void checkUnixErrorExplicit(ssize_t ret, int savedErrno, Args&&... args) {
+  if (FOLLY_UNLIKELY(ret == -1)) {
+    throwSystemErrorExplicit(savedErrno, std::forward<Args>(args)...);
+  }
+}
+
+// Check the return code from a fopen-style function (returns a non-nullptr
+// FILE* on success, nullptr on error, sets errno).  Works with fopen, fdopen,
+// freopen, tmpfile, etc.
+template <class... Args>
+void checkFopenError(FILE* fp, Args&&... args) {
+  if (FOLLY_UNLIKELY(!fp)) {
+    throwSystemError(std::forward<Args>(args)...);
+  }
+}
+
+template <class... Args>
+void checkFopenErrorExplicit(FILE* fp, int savedErrno, Args&&... args) {
+  if (FOLLY_UNLIKELY(!fp)) {
+    throwSystemErrorExplicit(savedErrno, std::forward<Args>(args)...);
+  }
+}
+
+/**
+ * If cond is not true, raise an exception of type E.  E must have a ctor that
+ * works with const char* (a description of the failure).
+ */
+#define CHECK_THROW(cond, E)                             \
+  do {                                                   \
+    if (!(cond)) {                                       \
+      folly::throw_exception<E>("Check failed: " #cond); \
+    }                                                    \
+  } while (0)
+
+} // namespace folly

package/external/folly/folly/ExceptionString.cpp

@@ -0,0 +1,51 @@
+/*
+ * 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/ExceptionString.h>
+
+#include <utility>
+
+#include <folly/Demangle.h>
+#include <folly/lang/Exception.h>
+#include <folly/lang/TypeInfo.h>
+
+namespace folly {
+
+namespace {
+
+fbstring exception_string_type(std::type_info const* ti) {
+  return ti ? demangle(*ti) : "<unknown exception>";
+}
+
+} // namespace
+
+/**
+ * Debug string for an exception: include type and what(), if
+ * defined.
+ */
+fbstring exceptionStr(std::exception const& e) {
+  auto prefix = exception_string_type(folly::type_info_of(e));
+  return std::move(prefix) + ": " + e.what();
+}
+
+fbstring exceptionStr(std::exception_ptr const& ep) {
+  if (auto ex = exception_ptr_get_object<std::exception>(ep)) {
+    return exceptionStr(*ex);
+  }
+  return exception_string_type(exception_ptr_get_type(ep));
+}
+
+} // namespace folly

package/external/folly/folly/ExceptionString.h

@@ -0,0 +1,33 @@
+/*
+ * 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 <exception>
+
+#include <folly/FBString.h>
+
+namespace folly {
+
+/**
+ * Debug string for an exception: include type and what(), if
+ * defined.
+ */
+fbstring exceptionStr(std::exception const& e);
+
+fbstring exceptionStr(std::exception_ptr const& ep);
+
+} // namespace folly

package/external/folly/folly/ExceptionWrapper-inl.h

@@ -0,0 +1,264 @@
+/*
+ * 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/Portability.h>
+
+namespace folly {
+
+struct exception_wrapper::with_exception_from_fn_ {
+  struct impl_var_ {
+    template <typename>
+    using apply = void;
+  };
+  struct impl_arg_ {
+    template <typename F>
+    using apply = typename function_traits<F>::template argument<0>;
+  };
+  struct impl_bye_;
+  template <
+      typename Sig,
+      typename Traits = function_traits<Sig>,
+      std::size_t NArgs = Traits::template arguments<type_pack_size_t>::value>
+  using impl_ = conditional_t<
+      Traits::is_variadic,
+      impl_var_,
+      conditional_t<NArgs == 1, impl_arg_, impl_bye_>>;
+
+  template <typename T>
+  using member_ = typename member_pointer_traits<T>::member_type;
+
+  template <typename Void, typename>
+  struct arg_type_;
+  template <class Sig>
+  struct arg_type_<std::enable_if_t<std::is_function<Sig>::value>, Sig> {
+    using type = typename impl_<Sig>::template apply<Sig>;
+  };
+  template <class Ptr>
+  struct arg_type_<std::enable_if_t<std::is_pointer<Ptr>::value>, Ptr>
+      : arg_type_<void, std::remove_pointer_t<Ptr>> {};
+  template <class Obj>
+  struct arg_type_<void_t<decltype(&Obj::operator())>, Obj>
+      : arg_type_<void, member_<decltype(&Obj::operator())>> {};
+
+  // void if Fn is a variadic callable; otherwise the first arg type
+  template <typename, typename Fn>
+  using apply = _t<arg_type_<void, Fn>>;
+};
+
+struct exception_wrapper::with_exception_from_ex_ {
+  template <typename Ex, typename>
+  using apply = Ex;
+};
+
+// The libc++ and cpplib implementations do not have a move constructor or a
+// move-assignment operator. To avoid refcount operations, we must improvise.
+// The libstdc++ implementation has a move constructor and a move-assignment
+// operator but having this does no harm.
+inline std::exception_ptr exception_wrapper::extract_(
+    std::exception_ptr&& ptr) noexcept {
+  constexpr auto sz = sizeof(std::exception_ptr);
+  // assume relocatability on all platforms
+  // assume nrvo for performance
+  std::exception_ptr ret;
+  std::memcpy(static_cast<void*>(&ret), &ptr, sz);
+  std::memset(static_cast<void*>(&ptr), 0, sz);
+  return ret;
+}
+
+inline exception_wrapper::exception_wrapper(exception_wrapper&& that) noexcept
+    : ptr_{extract_(std::move(that.ptr_))} {}
+
+inline exception_wrapper::exception_wrapper(
+    std::exception_ptr const& ptr) noexcept
+    : ptr_{ptr} {}
+
+inline exception_wrapper::exception_wrapper(std::exception_ptr&& ptr) noexcept
+    : ptr_{extract_(std::move(ptr))} {}
+
+template <
+    class Ex,
+    class Ex_,
+    FOLLY_REQUIRES_DEF(Conjunction<
+                       exception_wrapper::IsStdException<Ex_>,
+                       exception_wrapper::IsRegularExceptionType<Ex_>>::value)>
+inline exception_wrapper::exception_wrapper(Ex&& ex)
+    : ptr_{make_exception_ptr_with(std::in_place, std::forward<Ex>(ex))} {}
+
+template <
+    class Ex,
+    class Ex_,
+    FOLLY_REQUIRES_DEF(exception_wrapper::IsRegularExceptionType<Ex_>::value)>
+inline exception_wrapper::exception_wrapper(std::in_place_t, Ex&& ex)
+    : ptr_{make_exception_ptr_with(std::in_place, std::forward<Ex>(ex))} {}
+
+template <
+    class Ex,
+    typename... As,
+    FOLLY_REQUIRES_DEF(exception_wrapper::IsRegularExceptionType<Ex>::value)>
+inline exception_wrapper::exception_wrapper(
+    std::in_place_type_t<Ex>, As&&... as)
+    : ptr_{make_exception_ptr_with(
+          std::in_place_type<Ex>, std::forward<As>(as)...)} {}
+
+inline exception_wrapper& exception_wrapper::operator=(
+    exception_wrapper&& that) noexcept {
+  // assume relocatability on all platforms
+  constexpr auto sz = sizeof(std::exception_ptr);
+  std::exception_ptr tmp;
+  std::memcpy(static_cast<void*>(&tmp), &ptr_, sz);
+  std::memcpy(static_cast<void*>(&ptr_), &that.ptr_, sz);
+  std::memset(static_cast<void*>(&that.ptr_), 0, sz);
+  return *this;
+}
+
+inline void exception_wrapper::swap(exception_wrapper& that) noexcept {
+  // assume relocatability on all platforms
+  constexpr auto sz = sizeof(std::exception_ptr);
+  aligned_storage_for_t<std::exception_ptr> storage;
+  std::memcpy(&storage, &ptr_, sz);
+  std::memcpy(static_cast<void*>(&ptr_), &that.ptr_, sz);
+  std::memcpy(static_cast<void*>(&that.ptr_), &storage, sz);
+}
+
+inline exception_wrapper::operator bool() const noexcept {
+  return !!ptr_;
+}
+
+inline bool exception_wrapper::operator!() const noexcept {
+  return !ptr_;
+}
+
+inline void exception_wrapper::reset() {
+  ptr_ = {};
+}
+
+inline bool exception_wrapper::has_exception_ptr() const noexcept {
+  return !!ptr_;
+}
+
+inline std::exception* exception_wrapper::get_exception() noexcept {
+  return exception_ptr_get_object<std::exception>(ptr_);
+}
+inline std::exception const* exception_wrapper::get_exception() const noexcept {
+  return exception_ptr_get_object<std::exception>(ptr_);
+}
+
+template <typename Ex>
+inline Ex* exception_wrapper::get_exception() noexcept {
+  return exception_ptr_get_object_hint<Ex>(ptr_, tag<Ex>);
+}
+
+template <typename Ex>
+inline Ex const* exception_wrapper::get_exception() const noexcept {
+  return exception_ptr_get_object_hint<Ex>(ptr_, tag<Ex>);
+}
+
+inline std::exception_ptr exception_wrapper::to_exception_ptr() const noexcept {
+  return ptr_;
+}
+
+inline std::exception_ptr const& exception_wrapper::exception_ptr_ref()
+    const noexcept {
+  return ptr_;
+}
+
+inline std::type_info const* exception_wrapper::type() const noexcept {
+  return exception_ptr_get_type(ptr_);
+}
+
+inline folly::fbstring exception_wrapper::what() const {
+  if (auto e = get_exception()) {
+    return class_name() + ": " + e->what();
+  }
+  return class_name();
+}
+
+inline folly::fbstring exception_wrapper::class_name() const {
+  auto const* const ti = type();
+  return !*this ? "" : !ti ? "<unknown>" : folly::demangle(*ti);
+}
+
+template <class Ex>
+inline bool exception_wrapper::is_compatible_with() const noexcept {
+  return exception_ptr_get_object<Ex>(ptr_);
+}
+
+[[noreturn]] inline void exception_wrapper::throw_exception() const {
+  ptr_ ? std::rethrow_exception(ptr_) : onNoExceptionError(__func__);
+}
+
+template <class Ex>
+[[noreturn]] inline void exception_wrapper::throw_with_nested(Ex&& ex) const {
+  try {
+    throw_exception();
+  } catch (...) {
+    std::throw_with_nested(std::forward<Ex>(ex));
+  }
+}
+
+template <class This, class Fn>
+inline bool exception_wrapper::with_exception_(This&, Fn fn_, tag_t<void>) {
+  return void(fn_()), true;
+}
+
+template <class This, class Fn, typename Ex>
+inline bool exception_wrapper::with_exception_(This& this_, Fn fn_, tag_t<Ex>) {
+  auto ptr = this_.template get_exception<remove_cvref_t<Ex>>();
+  return ptr && (void(fn_(static_cast<Ex&>(*ptr))), true);
+}
+
+template <class Ex, class This, class Fn>
+inline bool exception_wrapper::with_exception_(This& this_, Fn fn_) {
+  using from_fn = with_exception_from_fn_;
+  using from_ex = with_exception_from_ex_;
+  using from = conditional_t<std::is_void<Ex>::value, from_fn, from_ex>;
+  using type = typename from::template apply<Ex, Fn>;
+  return with_exception_(this_, std::move(fn_), tag<type>);
+}
+
+template <class This, class... CatchFns>
+inline void exception_wrapper::handle_(
+    This& this_, char const* name, CatchFns&... fns) {
+  using _ = bool[];
+  if (!this_) {
+    onNoExceptionError(name);
+  }
+  bool handled = false;
+  void(_{false, (handled = handled || with_exception_<void>(this_, fns))...});
+  if (!handled) {
+    this_.throw_exception();
+  }
+}
+
+template <class Ex, class Fn>
+inline bool exception_wrapper::with_exception(Fn fn) {
+  return with_exception_<Ex>(*this, std::move(fn));
+}
+template <class Ex, class Fn>
+inline bool exception_wrapper::with_exception(Fn fn) const {
+  return with_exception_<Ex const>(*this, std::move(fn));
+}
+
+template <class... CatchFns>
+inline void exception_wrapper::handle(CatchFns... fns) {
+  handle_(*this, __func__, fns...);
+}
+template <class... CatchFns>
+inline void exception_wrapper::handle(CatchFns... fns) const {
+  handle_(*this, __func__, fns...);
+}
+
+} // namespace folly

package/external/folly/folly/ExceptionWrapper.cpp

@@ -0,0 +1,37 @@
+/*
+ * 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/ExceptionWrapper.h>
+
+#include <iostream>
+
+#include <folly/GLog.h>
+
+namespace folly {
+
+[[noreturn]] void exception_wrapper::onNoExceptionError(
+    char const* const name) {
+  std::ios_base::Init ioinit_; // ensure std::cerr is alive
+  std::cerr << "Cannot use `" << name
+            << "` with an empty folly::exception_wrapper" << std::endl;
+  std::terminate();
+}
+
+fbstring exceptionStr(exception_wrapper const& ew) {
+  return ew.what();
+}
+
+} // namespace folly