react-native-windows 0.83.2 → 0.83.3

package/external/folly/folly/portability/Constexpr.h

@@ -0,0 +1,145 @@
+/*
+ * 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 <folly/CPortability.h>
+#include <folly/Portability.h>
+
+#include <cstdint>
+#include <cstring>
+#include <type_traits>
+
+namespace folly {
+
+namespace detail {
+
+#if FOLLY_HAS_FEATURE(cxx_constexpr_string_builtins) || \
+    FOLLY_HAS_BUILTIN(__builtin_strlen) || defined(_MSC_VER)
+#define FOLLY_DETAIL_STRLEN __builtin_strlen
+#else
+#define FOLLY_DETAIL_STRLEN ::std::strlen
+#endif
+
+#if FOLLY_HAS_FEATURE(cxx_constexpr_string_builtins) || \
+    FOLLY_HAS_BUILTIN(__builtin_strcmp)
+#define FOLLY_DETAIL_STRCMP __builtin_strcmp
+#else
+#define FOLLY_DETAIL_STRCMP ::std::strcmp
+#endif
+
+// This overload is preferred if Char is char and if FOLLY_DETAIL_STRLEN
+// yields a compile-time constant.
+template <
+    typename Char,
+    std::size_t = FOLLY_DETAIL_STRLEN(static_cast<const Char*>(""))>
+constexpr std::size_t constexpr_strlen_internal(const Char* s, int) noexcept {
+  return FOLLY_DETAIL_STRLEN(s);
+}
+template <typename Char>
+constexpr std::size_t constexpr_strlen_internal(
+    const Char* s, unsigned) noexcept {
+  std::size_t ret = 0;
+  while (*s++) {
+    ++ret;
+  }
+  return ret;
+}
+
+template <typename Char>
+constexpr std::size_t constexpr_strlen_fallback(const Char* s) noexcept {
+  return constexpr_strlen_internal(s, 0u);
+}
+
+static_assert(
+    constexpr_strlen_fallback("123456789") == 9,
+    "Someone appears to have broken constexpr_strlen...");
+
+// This overload is preferred if Char is char and if FOLLY_DETAIL_STRCMP
+// yields a compile-time constant.
+template <
+    typename Char,
+    int = FOLLY_DETAIL_STRCMP(static_cast<const Char*>(""), "")>
+constexpr int constexpr_strcmp_internal(
+    const Char* s1, const Char* s2, int) noexcept {
+  return FOLLY_DETAIL_STRCMP(s1, s2);
+}
+template <typename Char>
+constexpr int constexpr_strcmp_internal(
+    const Char* s1, const Char* s2, unsigned) noexcept {
+  while (*s1 && *s1 == *s2) {
+    ++s1, ++s2;
+  }
+  // NOTE: `int(*s1 - *s2)` may cause signed arithmetics overflow which is UB.
+  return int(*s2 < *s1) - int(*s1 < *s2);
+}
+
+template <typename Char>
+constexpr int constexpr_strcmp_fallback(
+    const Char* s1, const Char* s2) noexcept {
+  return constexpr_strcmp_internal(s1, s2, 0u);
+}
+
+#undef FOLLY_DETAIL_STRCMP
+#undef FOLLY_DETAIL_STRLEN
+
+} // namespace detail
+
+template <typename Char>
+constexpr std::size_t constexpr_strlen(const Char* s) noexcept {
+#if __GNUC_PREREQ(11, 0)
+  return detail::constexpr_strlen_internal(s, 0u);
+#else
+  return detail::constexpr_strlen_internal(s, 0);
+#endif
+}
+
+template <typename Char>
+constexpr int constexpr_strcmp(const Char* s1, const Char* s2) noexcept {
+  return detail::constexpr_strcmp_internal(s1, s2, 0);
+}
+
+namespace detail {
+
+template <typename V>
+struct is_constant_evaluated_or_constinit_ {
+  V value;
+  FOLLY_ERASE FOLLY_CONSTEVAL /* implicit */
+  is_constant_evaluated_or_constinit_(V const v) noexcept(noexcept(V(v)))
+      : value{v} {}
+};
+
+} // namespace detail
+
+//  is_constant_evaluated_or
+//
+//  Similar in spirit to std::is_constant_evaluated (c++20), with differences:
+//  * Takes an argument to be used as the default return value, if the code is
+//    unable to tell whether it is in a constant context.
+constexpr bool is_constant_evaluated_or(
+    detail::is_constant_evaluated_or_constinit_<bool> const def) noexcept {
+#if defined(__cpp_lib_is_constant_evaluated)
+  return std::is_constant_evaluated();
+#endif
+
+#if FOLLY_HAS_BUILTIN(__builtin_is_constant_evaluated)
+  return __builtin_is_constant_evaluated();
+#endif
+
+  return def.value;
+}
+
+} // namespace folly

package/external/folly/folly/portability/Dirent.cpp

@@ -0,0 +1,140 @@
+/*
+ * 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/Dirent.h>
+
+#ifdef _WIN32
+#include <stdlib.h>
+#include <string>
+
+#include <folly/portability/Windows.h>
+
+struct DIR {
+  dirent dir{};
+  HANDLE searchHandle{INVALID_HANDLE_VALUE};
+  int entriesRead{0};
+  char currentName[MAX_PATH * 3];
+  std::string pattern;
+
+  int close() { return FindClose(searchHandle) ? 0 : -1; }
+
+  DIR* open() {
+    wchar_t patternBuf[MAX_PATH + 3];
+    size_t len;
+
+    if (pattern.empty()) {
+      return nullptr;
+    }
+
+    if (mbstowcs_s(&len, patternBuf, MAX_PATH, pattern.c_str(), MAX_PATH - 2)) {
+      return nullptr;
+    }
+
+    // `len` includes the trailing NUL
+    if (len) {
+      len--;
+    }
+    if (len && patternBuf[len - 1] != '/' && patternBuf[len - 1] != '\\') {
+      patternBuf[len++] = '\\';
+    }
+    patternBuf[len++] = '*';
+    patternBuf[len] = 0;
+
+    WIN32_FIND_DATAW fdata;
+    HANDLE h = FindFirstFileW(patternBuf, &fdata);
+    if (h == INVALID_HANDLE_VALUE) {
+      return nullptr;
+    }
+
+    searchHandle = h;
+    dir.d_name = currentName;
+    if (wcstombs(currentName, fdata.cFileName, MAX_PATH * 3) == (size_t)-1) {
+      return nullptr;
+    }
+
+    setEntryType(fdata.dwFileAttributes);
+    return this;
+  }
+
+  dirent* nextDir() {
+    if (entriesRead) {
+      WIN32_FIND_DATAW fdata;
+      if (!FindNextFileW(searchHandle, &fdata)) {
+        return nullptr;
+      }
+
+      if (wcstombs(currentName, fdata.cFileName, MAX_PATH * 3) == (size_t)-1) {
+        errno = EBADF;
+        return nullptr;
+      }
+      setEntryType(fdata.dwFileAttributes);
+    }
+
+    entriesRead++;
+    return &dir;
+  }
+
+ private:
+  void setEntryType(DWORD attr) {
+    if (attr & FILE_ATTRIBUTE_DIRECTORY) {
+      dir.d_type = DT_DIR;
+    } else {
+      dir.d_type = DT_REG;
+    }
+  }
+};
+
+extern "C" {
+int closedir(DIR* dir) {
+  auto ret = dir->close();
+  delete dir;
+  return ret;
+}
+
+DIR* opendir(const char* name) {
+  auto dir = new DIR();
+  dir->pattern = name;
+  if (!dir->open()) {
+    delete dir;
+    return nullptr;
+  }
+  return dir;
+}
+
+dirent* readdir(DIR* dir) {
+  return dir->nextDir();
+}
+
+int readdir_r(DIR* dir, dirent* buf, dirent** ent) {
+  if (!dir || !buf || !ent) {
+    return EBADF;
+  }
+  *ent = dir->nextDir();
+  // Our normal readdir implementation is actually
+  // already reentrant, but we need to do this copy
+  // in case the caller expects buf to have the value.
+  if (*ent) {
+    *buf = dir->dir;
+  }
+  return 0;
+}
+
+void rewinddir(DIR* dir) {
+  dir->close();
+  dir->open();
+}
+}
+#endif

package/external/folly/folly/portability/Dirent.h

@@ -0,0 +1,41 @@
+/*
+ * 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
+
+#ifndef _WIN32
+#include <dirent.h>
+#else
+
+#define DT_UNKNOWN 0
+#define DT_DIR 1
+#define DT_REG 2
+#define DT_LNK 3
+struct dirent {
+  unsigned char d_type;
+  char* d_name;
+};
+
+struct DIR;
+
+extern "C" {
+int closedir(DIR* dir);
+DIR* opendir(const char* name);
+dirent* readdir(DIR* dir);
+int readdir_r(DIR* dir, dirent* buf, dirent** ent);
+void rewinddir(DIR* dir);
+}
+#endif

package/external/folly/folly/portability/Event.h

@@ -0,0 +1,44 @@
+/*
+ * 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
+
+#ifdef _MSC_VER
+// This needs to be before the libevent include.
+#include <folly/portability/Windows.h>
+#endif
+
+#include <event.h>
+
+#ifdef _MSC_VER
+#include <event2/event_compat.h> // @manual
+// The signal_set macro from libevent 2 compat conflicts with the
+// boost::asio::signal_set function
+#undef signal_set
+#include <folly/portability/Fcntl.h>
+#endif
+
+// The signal_set macro from libevent 1.4.14b-stable conflicts with the
+// boost::asio::signal_set function
+#if _EVENT_NUMERIC_VERSION == 0x01040e00
+#undef signal_set
+#endif
+
+#include <folly/net/detail/SocketFileDescriptorMap.h>
+
+namespace folly {
+using libevent_fd_t = decltype(event::ev_fd);
+} // namespace folly

package/external/folly/folly/portability/Fcntl.cpp

@@ -0,0 +1,120 @@
+/*
+ * 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/Fcntl.h>
+
+#ifdef _WIN32
+#include <folly/portability/Sockets.h>
+#include <folly/portability/SysStat.h>
+#include <folly/portability/Windows.h>
+
+namespace folly {
+namespace portability {
+namespace fcntl {
+int creat(char const* fn, int pm) {
+  return _creat(fn, pm);
+}
+
+int fcntl(int fd, int cmd, ...) {
+  va_list args;
+  int res = -1;
+  va_start(args, cmd);
+  switch (cmd) {
+    case F_GETFD: {
+      HANDLE h = (HANDLE)_get_osfhandle(fd);
+      if (h != INVALID_HANDLE_VALUE) {
+        DWORD flags;
+        if (GetHandleInformation(h, &flags)) {
+          res = int(flags & HANDLE_FLAG_INHERIT);
+        }
+      }
+      break;
+    }
+    case F_SETFD: {
+      int flags = va_arg(args, int);
+      HANDLE h = (HANDLE)_get_osfhandle(fd);
+      if (h != INVALID_HANDLE_VALUE) {
+        if (SetHandleInformation(
+                h, HANDLE_FLAG_INHERIT, (DWORD)(flags & FD_CLOEXEC))) {
+          res = 0;
+        }
+      }
+      break;
+    }
+    case F_GETFL: {
+      // No idea how to get the IO blocking mode, so return 0.
+      res = 0;
+      break;
+    }
+    case F_SETFL: {
+      int flags = va_arg(args, int);
+      // If it's not a socket, it's probably a pipe.
+      if (folly::portability::sockets::is_fh_socket(fd)) {
+        SOCKET s = (SOCKET)_get_osfhandle(fd);
+        if (s != INVALID_SOCKET) {
+          u_long nonBlockingEnabled = (flags & O_NONBLOCK) ? 1 : 0;
+          res = ioctlsocket(s, FIONBIO, &nonBlockingEnabled);
+        }
+      } else {
+        HANDLE p = (HANDLE)_get_osfhandle(fd);
+        if (GetFileType(p) == FILE_TYPE_PIPE) {
+          DWORD newMode = PIPE_READMODE_BYTE;
+          newMode |= (flags & O_NONBLOCK) ? PIPE_NOWAIT : PIPE_WAIT;
+          if (SetNamedPipeHandleState(p, &newMode, nullptr, nullptr)) {
+            res = 0;
+          }
+        }
+      }
+      break;
+    }
+  }
+  va_end(args);
+  return res;
+}
+
+int open(char const* fn, int of, int pm) {
+  int fh;
+  int realMode = _S_IREAD;
+  if ((of & _O_RDWR) == _O_RDWR) {
+    realMode = _S_IREAD | _S_IWRITE;
+  } else if ((of & _O_WRONLY) == _O_WRONLY) {
+    realMode = _S_IWRITE;
+  } else if ((of & _O_RDONLY) != _O_RDONLY) {
+    // One of these needs to be present, just fail if
+    // none are.
+    return -1;
+  }
+  if (!strcmp(fn, "/dev/null")) {
+    // Windows doesn't have a /dev/null, but it does have
+    // NUL, which achieves the same result.
+    fn = "NUL";
+  }
+  if ((of & _O_TEXT) != _O_TEXT) {
+    of |= _O_BINARY;
+  }
+  errno_t res = _sopen_s(&fh, fn, of, _SH_DENYNO, realMode);
+  return res ? -1 : fh;
+}
+
+int posix_fallocate(int fd, off_t offset, off_t len) {
+  // We'll pretend we always have enough space. We
+  // can't exactly pre-allocate on windows anyways.
+  return 0;
+}
+} // namespace fcntl
+} // namespace portability
+} // namespace folly
+#endif

package/external/folly/folly/portability/Fcntl.h

@@ -0,0 +1,67 @@
+/*
+ * 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 <fcntl.h>
+
+#ifdef _WIN32
+#include <sys/types.h>
+
+#include <folly/portability/Windows.h>
+
+#include <folly/Portability.h>
+
+// I have no idea what the normal values for these are,
+// and really don't care what they are. They're only used
+// within fcntl, so it's not an issue.
+#define FD_CLOEXEC HANDLE_FLAG_INHERIT
+#define O_NONBLOCK 1
+#define O_CLOEXEC _O_NOINHERIT
+#define F_GETFD 1
+#define F_SETFD 2
+#define F_GETFL 3
+#define F_SETFL 4
+
+#ifdef HAVE_POSIX_FALLOCATE
+#undef HAVE_POSIX_FALLOCATE
+#endif
+#define HAVE_POSIX_FALLOCATE 1
+
+// See portability/Unistd.h for why these need to be in a namespace
+// rather then extern "C".
+namespace folly {
+namespace portability {
+namespace fcntl {
+int creat(char const* fn, int pm);
+int fcntl(int fd, int cmd, ...);
+int posix_fallocate(int fd, off_t offset, off_t len);
+int open(char const* fn, int of, int pm = 0);
+} // namespace fcntl
+} // namespace portability
+} // namespace folly
+
+FOLLY_PUSH_WARNING
+FOLLY_CLANG_DISABLE_WARNING("-Wheader-hygiene")
+/* using override */ using namespace folly::portability::fcntl;
+FOLLY_POP_WARNING
+#endif
+
+#ifdef _WIN32
+#define FOLLY_PORT_WIN32_OPEN_BINARY _O_BINARY
+#else
+#define FOLLY_PORT_WIN32_OPEN_BINARY 0
+#endif

package/external/folly/folly/portability/Filesystem.cpp

@@ -0,0 +1,67 @@
+/*
+ * 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/Filesystem.h>
+
+namespace folly::fs {
+
+#if __cpp_lib_filesystem >= 201703
+
+path lexically_normal_fn::operator()(path const& p) const {
+  return p.lexically_normal();
+}
+
+#elif __cpp_lib_experimental_filesystem >= 201406
+
+//  mimic: std::filesystem::path::lexically_normal, C++17
+//  from: https://github.com/gulrak/filesystem/tree/v1.5.0, MIT
+path lexically_normal_fn::operator()(path const& p) const {
+  path dest;
+  bool lastDotDot = false;
+  for (path::string_type s : p) {
+    if (s == ".") {
+      dest /= "";
+      continue;
+    } else if (s == ".." && !dest.empty()) {
+      auto root = p.root_path();
+      if (dest == root) {
+        continue;
+      } else if (*(--dest.end()) != "..") {
+        auto drepr = dest.native();
+        if (drepr.back() == path::preferred_separator) {
+          drepr.pop_back();
+          dest = std::move(drepr);
+        }
+        dest.remove_filename();
+        continue;
+      }
+    }
+    if (!(s.empty() && lastDotDot)) {
+      dest /= s;
+    }
+    lastDotDot = s == "..";
+  }
+  if (dest.empty()) {
+    dest = ".";
+  }
+  return dest;
+}
+
+#else
+#error require filesystem
+#endif
+
+} // namespace folly::fs