react-native-windows 0.81.34 → 0.81.36

package/external/folly/folly/portability/Stdio.cpp

@@ -0,0 +1,77 @@
+/*
+ * 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/Stdio.h>
+
+#ifdef _WIN32
+
+#include <cstdlib>
+
+#include <folly/ScopeGuard.h>
+#include <folly/portability/Unistd.h>
+
+extern "C" {
+int dprintf(int fd, const char* fmt, ...) {
+  va_list args;
+  va_start(args, fmt);
+  SCOPE_EXIT {
+    va_end(args);
+  };
+
+  int ret = vsnprintf(nullptr, 0, fmt, args);
+  if (ret <= 0) {
+    return -1;
+  }
+  size_t len = size_t(ret);
+  char* buf = new char[len + 1];
+  SCOPE_EXIT {
+    delete[] buf;
+  };
+  if (size_t(vsnprintf(buf, len + 1, fmt, args)) == len &&
+      write(fd, buf, len) == ssize_t(len)) {
+    return ret;
+  }
+
+  return -1;
+}
+
+int pclose(FILE* f) {
+  return _pclose(f);
+}
+
+FILE* popen(const char* name, const char* mode) {
+  return _popen(name, mode);
+}
+
+void setbuffer(FILE* f, char* buf, size_t size) {
+  setvbuf(f, buf, _IOFBF, size);
+}
+
+int vasprintf(char** dest, const char* format, va_list ap) {
+  int len = vsnprintf(nullptr, 0, format, ap);
+  if (len <= 0) {
+    return -1;
+  }
+  char* buf = *dest = (char*)malloc(size_t(len + 1));
+  if (vsnprintf(buf, size_t(len + 1), format, ap) == len) {
+    return len;
+  }
+  free(buf);
+  return -1;
+}
+}
+
+#endif

package/external/folly/folly/portability/Stdio.h

@@ -0,0 +1,32 @@
+/*
+ * 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 <cstdio>
+
+#ifdef _WIN32
+#include <cstdarg>
+#include <cstdint>
+
+extern "C" {
+int dprintf(int fd, const char* fmt, ...);
+int pclose(FILE* f);
+FILE* popen(const char* name, const char* mode);
+void setbuffer(FILE* f, char* buf, size_t size);
+int vasprintf(char** dest, const char* format, va_list ap);
+}
+#endif

package/external/folly/folly/portability/Stdlib.cpp

@@ -0,0 +1,172 @@
+/*
+ * 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/Stdlib.h>
+
+#ifdef _WIN32
+
+#include <cstring>
+
+#include <errno.h>
+
+#include <folly/portability/Fcntl.h>
+#include <folly/portability/SysStat.h>
+#include <folly/portability/Windows.h>
+
+extern "C" {
+char* mktemp(char* tn) {
+  return _mktemp(tn);
+}
+
+// While yes, this is for a directory, due to this being windows,
+// a file and directory can't have the same name, resulting in this
+// still working just fine.
+char* mkdtemp(char* tn) {
+  char* ptr = nullptr;
+  auto len = strlen(tn);
+  int ret = 0;
+  do {
+    strcpy(tn + len - 6, "XXXXXX");
+    ptr = mktemp(tn);
+    if (ptr == nullptr || *ptr == '\0') {
+      return nullptr;
+    }
+    ret = mkdir(ptr, 0700);
+    if (ret != 0 && errno != EEXIST) {
+      return nullptr;
+    }
+  } while (ret != 0);
+  return tn;
+}
+
+int mkstemp(char* tn) {
+  char* ptr = nullptr;
+  auto len = strlen(tn);
+  int ret = 0;
+  do {
+    strcpy(tn + len - 6, "XXXXXX");
+    ptr = mktemp(tn);
+    if (ptr == nullptr || *ptr == '\0') {
+      return -1;
+    }
+    ret = open(ptr, O_RDWR | O_EXCL | O_CREAT, S_IRUSR | S_IWUSR);
+    if (ret == -1 && errno != EEXIST) {
+      return -1;
+    }
+  } while (ret == -1);
+  return ret;
+}
+
+char* realpath(const char* path, char* resolved_path) {
+  // I sure hope the caller gave us _MAX_PATH space in the buffer....
+  return _fullpath(resolved_path, path, _MAX_PATH);
+}
+
+int setenv(const char* name, const char* value, int overwrite) {
+  if (overwrite == 0 && getenv(name) != nullptr) {
+    return 0;
+  }
+
+  if (*value != '\0') {
+    auto e = _putenv_s(name, value);
+    if (e != 0) {
+      errno = e;
+      return -1;
+    }
+    return 0;
+  }
+
+  // We are trying to set the value to an empty string, but
+  // _putenv_s deletes entries if the value is an empty string,
+  // and just calling SetEnvironmentVariableA doesn't update
+  // _environ, so we have to do these terrible things.
+  if (_putenv_s(name, "  ") != 0) {
+    errno = EINVAL;
+    return -1;
+  }
+
+  // Here lies the documentation we blatently ignore to make
+  // this work >_>...
+  *getenv(name) = '\0';
+  // This would result in a double null termination, which
+  // normally signifies the end of the environment variable
+  // list, so we stick a completely empty environment variable
+  // into the list instead.
+  *(getenv(name) + 1) = '=';
+
+  // If _wenviron is null, the wide environment has not been initialized
+  // yet, and we don't need to try to update it.
+  // We have to do this otherwise we'd be forcing the initialization and
+  // maintenance of the wide environment even though it's never actually
+  // used in most programs.
+  if (_wenviron != nullptr) {
+    wchar_t buf[_MAX_ENV + 1];
+    size_t len;
+    if (mbstowcs_s(&len, buf, _MAX_ENV + 1, name, _MAX_ENV) != 0) {
+      errno = EINVAL;
+      return -1;
+    }
+    *_wgetenv(buf) = u'\0';
+    *(_wgetenv(buf) + 1) = u'=';
+  }
+
+  // And now, we have to update the outer environment to have
+  // a proper empty value.
+  if (!SetEnvironmentVariableA(name, value)) {
+    errno = EINVAL;
+    return -1;
+  }
+  return 0;
+}
+
+int unsetenv(const char* name) {
+  if (_putenv_s(name, "") != 0) {
+    return -1;
+  }
+  return 0;
+}
+}
+
+#endif
+
+#if !__linux__ && !FOLLY_MOBILE && !defined(__wasm32__)
+
+#include <string>
+#include <vector>
+
+extern "C" int clearenv() {
+  std::vector<std::string> data;
+  for (auto it = environ; it && *it; ++it) {
+    std::string entry(*it);
+    auto equalsPosition = entry.find('=');
+    if (equalsPosition == std::string::npos || equalsPosition == 0) {
+      // It's either a drive setting (if on Windows), or something clowny is
+      // going on in the environment.
+      continue;
+    } else {
+      data.emplace_back(entry.substr(0, equalsPosition));
+    }
+  }
+
+  for (auto s : data) {
+    if (unsetenv(s.c_str()) != 0)
+      return -1;
+  }
+
+  return 0;
+}
+
+#endif

package/external/folly/folly/portability/Stdlib.h

@@ -0,0 +1,64 @@
+/*
+ * 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 <cstdlib>
+
+#include <folly/portability/Config.h>
+
+#if defined(__APPLE__)
+#if __has_include(<crt_externs.h>)
+#include <crt_externs.h> // @manual
+#endif
+#define HOST_NAME_MAX _POSIX_HOST_NAME_MAX
+#endif
+
+extern "C" {
+#ifdef _WIN32
+// These are technically supposed to be defined linux/limits.h and
+// sys/param.h respectively, but Windows defines _MAX_PATH in stdlib.h,
+// so, instead of creating two headers for a single define each, we put
+// them here, where they are likely to already have been included in the
+// code that needs them.
+#define PATH_MAX _MAX_PATH
+#define MAXPATHLEN _MAX_PATH
+#define NAME_MAX _MAX_FNAME
+#define HOST_NAME_MAX 255
+
+char* mktemp(char* tn);
+char* mkdtemp(char* tn);
+int mkstemp(char* tn);
+char* realpath(const char* path, char* resolved_path);
+int setenv(const char* name, const char* value, int overwrite);
+int unsetenv(const char* name);
+#elif defined(__APPLE__)
+// environ doesn't work well with dylibs, so use _NSGetEnviron instead.
+#if !__has_include(<crt_externs.h>)
+char*** _NSGetEnviron(void);
+#endif
+#define environ (*_NSGetEnviron())
+#endif
+
+#if defined(__FreeBSD__)
+// Needed to resolve linkage
+extern char** environ;
+#endif
+
+#if !__linux__ && !FOLLY_MOBILE
+int clearenv();
+#endif
+}

package/external/folly/folly/portability/String.cpp

@@ -0,0 +1,53 @@
+/*
+ * 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/String.h>
+
+#if defined(_WIN32) || defined(__FreeBSD__)
+extern "C" char* strndup(const char* a, size_t len) {
+  auto neededLen = strlen(a);
+  if (neededLen > len) {
+    neededLen = len;
+  }
+  char* buf = (char*)malloc((neededLen + 1) * sizeof(char));
+  if (!buf) {
+    return nullptr;
+  }
+  memcpy(buf, a, neededLen);
+  buf[neededLen] = '\0';
+  return buf;
+}
+#endif
+
+#ifdef _WIN32
+extern "C" {
+void bzero(void* s, size_t n) {
+  memset(s, 0, n);
+}
+
+int strcasecmp(const char* a, const char* b) {
+  return _stricmp(a, b);
+}
+
+int strncasecmp(const char* a, const char* b, size_t c) {
+  return _strnicmp(a, b, c);
+}
+
+char* strtok_r(char* str, char const* delim, char** ctx) {
+  return strtok_s(str, delim, ctx);
+}
+}
+#endif

package/external/folly/folly/portability/String.h

@@ -0,0 +1,39 @@
+/*
+ * 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 <stdlib.h>
+#include <string.h>
+
+#include <folly/portability/Config.h>
+
+#if !defined(_WIN32)
+#include <strings.h>
+#endif
+
+#if defined(_WIN32) || defined(__FreeBSD__)
+extern "C" char* strndup(const char* a, size_t len);
+#endif
+
+#ifdef _WIN32
+extern "C" {
+void bzero(void* s, size_t n);
+int strcasecmp(const char* a, const char* b);
+int strncasecmp(const char* a, const char* b, size_t c);
+char* strtok_r(char* str, char const* delim, char** ctx);
+}
+#endif

package/external/folly/folly/portability/SysFile.cpp

@@ -0,0 +1,46 @@
+/*
+ * 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/SysFile.h>
+
+#ifdef _WIN32
+#include <limits>
+
+#include <folly/portability/Windows.h>
+
+extern "C" int flock(int fd, int operation) {
+  HANDLE h = (HANDLE)_get_osfhandle(fd);
+  if (h == INVALID_HANDLE_VALUE) {
+    return -1;
+  }
+
+  constexpr DWORD kMaxDWORD = std::numeric_limits<DWORD>::max();
+  if (operation & LOCK_UN) {
+    if (!UnlockFile(h, 0, 0, kMaxDWORD, kMaxDWORD)) {
+      return -1;
+    }
+  } else {
+    DWORD flags = DWORD(
+        (operation & LOCK_NB ? LOCKFILE_FAIL_IMMEDIATELY : 0) |
+        (operation & LOCK_EX ? LOCKFILE_EXCLUSIVE_LOCK : 0));
+    OVERLAPPED ov = {};
+    if (!LockFileEx(h, flags, 0, kMaxDWORD, kMaxDWORD, &ov)) {
+      return -1;
+    }
+  }
+  return 0;
+}
+#endif

package/external/folly/folly/portability/SysFile.h

@@ -0,0 +1,27 @@
+/*
+ * 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 <sys/file.h>
+#else
+#define LOCK_SH 1
+#define LOCK_EX 2
+#define LOCK_NB 4
+#define LOCK_UN 8
+extern "C" int flock(int fd, int operation);
+#endif

package/external/folly/folly/portability/SysMembarrier.cpp

@@ -0,0 +1,104 @@
+/*
+ * 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/SysMembarrier.h>
+
+#include <cassert>
+#include <cerrno>
+
+#include <folly/Portability.h>
+#include <folly/portability/SysSyscall.h>
+
+namespace folly {
+namespace detail {
+
+namespace {
+
+constexpr long linux_syscall_nr_(long nr, long def) {
+  return nr == -1 ? def : nr;
+}
+
+//  __NR_membarrier or -1; always defined as v.s. __NR_membarrier
+#if defined(__NR_membarrier)
+constexpr long linux_syscall_nr_membarrier_ = __NR_membarrier;
+#else
+constexpr long linux_syscall_nr_membarrier_ = -1;
+#endif
+
+#if defined(__aarch64__)
+constexpr long def_linux_syscall_nr_membarrier_ = 283;
+#elif defined(__x86_64__) || defined(_M_X64)
+constexpr long def_linux_syscall_nr_membarrier_ = 324;
+#else
+constexpr long def_linux_syscall_nr_membarrier_ = -1;
+#endif
+
+//  __NR_membarrier with hardcoded fallback where available or -1
+constexpr long linux_syscall_nr_membarrier =
+    (kIsArchAmd64 || kIsArchAArch64) && !kIsMobile && kIsLinux //
+    ? linux_syscall_nr_(
+          linux_syscall_nr_membarrier_, def_linux_syscall_nr_membarrier_)
+    : -1;
+
+//  linux_membarrier_cmd
+//
+//  Backport from the linux header, since older versions of the header may
+//  define the enum but not all of the enum constants that we require.
+//
+//  mimic: membarrier_cmd, linux/membarrier.h
+enum linux_membarrier_cmd {
+  MEMBARRIER_CMD_QUERY = 0,
+  MEMBARRIER_CMD_PRIVATE_EXPEDITED = (1 << 3),
+  MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED = (1 << 4),
+};
+
+FOLLY_ERASE int call_membarrier(int cmd, unsigned int flags = 0) {
+  if (linux_syscall_nr_membarrier < 0) {
+    errno = ENOSYS;
+    return -1;
+  }
+  return linux_syscall(linux_syscall_nr_membarrier, cmd, flags);
+}
+
+} // namespace
+
+bool sysMembarrierPrivateExpeditedAvailable() {
+  constexpr auto flags = 0 //
+      | MEMBARRIER_CMD_PRIVATE_EXPEDITED //
+      | MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED;
+
+  auto const r = call_membarrier(MEMBARRIER_CMD_QUERY);
+  return r != -1 && (r & flags) == flags;
+}
+
+int sysMembarrierPrivateExpedited() {
+  if (0 == call_membarrier(MEMBARRIER_CMD_PRIVATE_EXPEDITED)) {
+    return 0;
+  }
+  switch (errno) {
+    case EINVAL:
+    case ENOSYS:
+      return -1;
+  }
+  assert(errno == EPERM);
+  if (-1 == call_membarrier(MEMBARRIER_CMD_REGISTER_PRIVATE_EXPEDITED)) {
+    return -1;
+  }
+  return call_membarrier(MEMBARRIER_CMD_PRIVATE_EXPEDITED);
+}
+
+} // namespace detail
+} // namespace folly

package/external/folly/folly/portability/SysMembarrier.h

@@ -0,0 +1,26 @@
+/*
+ * 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
+
+namespace folly {
+namespace detail {
+
+int sysMembarrierPrivateExpedited();
+bool sysMembarrierPrivateExpeditedAvailable();
+
+} // namespace detail
+} // namespace folly