react-native-windows 0.85.0-preview.1 → 0.85.0

package/external/folly/folly/portability/Time.cpp

@@ -0,0 +1,357 @@
+/*
+ * 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/Time.h>
+
+#include <folly/CPortability.h>
+#include <folly/Likely.h>
+#include <folly/Utility.h>
+
+#include <cassert>
+
+#include <chrono>
+
+template <typename _Rep, typename _Period>
+static void duration_to_ts(
+    std::chrono::duration<_Rep, _Period> d, struct timespec* ts) {
+  ts->tv_sec =
+      time_t(std::chrono::duration_cast<std::chrono::seconds>(d).count());
+  ts->tv_nsec = long(std::chrono::duration_cast<std::chrono::nanoseconds>(
+                         d % std::chrono::seconds(1))
+                         .count());
+}
+
+#if !FOLLY_HAVE_CLOCK_GETTIME || FOLLY_FORCE_CLOCK_GETTIME_DEFINITION
+#if __MACH__
+#include <errno.h>
+#include <mach/mach_init.h> // @manual
+#include <mach/mach_port.h> // @manual
+#include <mach/mach_time.h> // @manual
+#include <mach/mach_types.h> // @manual
+#include <mach/task.h> // @manual
+#include <mach/thread_act.h> // @manual
+#include <mach/vm_map.h> // @manual
+
+static std::chrono::nanoseconds time_value_to_ns(time_value_t t) {
+  return std::chrono::seconds(t.seconds) +
+      std::chrono::microseconds(t.microseconds);
+}
+
+static int clock_process_cputime(struct timespec* ts) {
+  // Get CPU usage for live threads.
+  task_thread_times_info thread_times_info;
+  mach_msg_type_number_t thread_times_info_count = TASK_THREAD_TIMES_INFO_COUNT;
+  kern_return_t kern_result = task_info(
+      mach_task_self(),
+      TASK_THREAD_TIMES_INFO,
+      (thread_info_t)&thread_times_info,
+      &thread_times_info_count);
+  if (FOLLY_UNLIKELY(kern_result != KERN_SUCCESS)) {
+    return -1;
+  }
+
+  // Get CPU usage for terminated threads.
+  mach_task_basic_info task_basic_info;
+  mach_msg_type_number_t task_basic_info_count = MACH_TASK_BASIC_INFO_COUNT;
+  kern_result = task_info(
+      mach_task_self(),
+      MACH_TASK_BASIC_INFO,
+      (thread_info_t)&task_basic_info,
+      &task_basic_info_count);
+  if (FOLLY_UNLIKELY(kern_result != KERN_SUCCESS)) {
+    return -1;
+  }
+
+  auto cputime = time_value_to_ns(thread_times_info.user_time) +
+      time_value_to_ns(thread_times_info.system_time) +
+      time_value_to_ns(task_basic_info.user_time) +
+      time_value_to_ns(task_basic_info.system_time);
+  duration_to_ts(cputime, ts);
+  return 0;
+}
+
+static int clock_thread_cputime(struct timespec* ts) {
+  mach_msg_type_number_t count = THREAD_BASIC_INFO_COUNT;
+  thread_basic_info_data_t thread_info_data;
+  thread_act_t thread = mach_thread_self();
+  kern_return_t kern_result = thread_info(
+      thread, THREAD_BASIC_INFO, (thread_info_t)&thread_info_data, &count);
+  mach_port_deallocate(mach_task_self(), thread);
+  if (FOLLY_UNLIKELY(kern_result != KERN_SUCCESS)) {
+    return -1;
+  }
+  auto cputime = time_value_to_ns(thread_info_data.system_time) +
+      time_value_to_ns(thread_info_data.user_time);
+  duration_to_ts(cputime, ts);
+  return 0;
+}
+
+FOLLY_ATTR_WEAK int clock_gettime(clockid_t clk_id, struct timespec* ts) {
+  switch (folly::to_underlying(clk_id)) {
+    case CLOCK_REALTIME: {
+      auto now = std::chrono::system_clock::now().time_since_epoch();
+      duration_to_ts(now, ts);
+      return 0;
+    }
+    case CLOCK_MONOTONIC: {
+      auto now = std::chrono::steady_clock::now().time_since_epoch();
+      duration_to_ts(now, ts);
+      return 0;
+    }
+    case CLOCK_PROCESS_CPUTIME_ID:
+      return clock_process_cputime(ts);
+    case CLOCK_THREAD_CPUTIME_ID:
+      return clock_thread_cputime(ts);
+    default:
+      errno = EINVAL;
+      return -1;
+  }
+}
+
+int clock_getres(clockid_t clk_id, struct timespec* ts) {
+  if (clk_id != CLOCK_MONOTONIC) {
+    return -1;
+  }
+
+  static auto info = [] {
+    static mach_timebase_info_data_t info;
+    auto result = (mach_timebase_info(&info) == KERN_SUCCESS) ? &info : nullptr;
+    assert(result);
+    return result;
+  }();
+
+  ts->tv_sec = 0;
+  ts->tv_nsec = info->numer / info->denom;
+
+  return 0;
+}
+#elif defined(_WIN32)
+#include <errno.h>
+#include <locale.h>
+#include <stdint.h>
+#include <stdlib.h>
+
+#include <folly/portability/Windows.h>
+
+using unsigned_nanos = std::chrono::duration<uint64_t, std::nano>;
+
+static unsigned_nanos filetimeToUnsignedNanos(FILETIME ft) {
+  ULARGE_INTEGER i;
+  i.HighPart = ft.dwHighDateTime;
+  i.LowPart = ft.dwLowDateTime;
+
+  // FILETIMEs are in units of 100ns.
+  return unsigned_nanos(i.QuadPart * 100);
+};
+
+static LARGE_INTEGER performanceFrequency() {
+  static auto result = [] {
+    LARGE_INTEGER freq;
+    // On Windows XP or later, this will never fail.
+    BOOL res = QueryPerformanceFrequency(&freq);
+    assert(res);
+    return freq;
+  }();
+  return result;
+}
+
+extern "C" int clock_getres(clockid_t clock_id, struct timespec* res) {
+  if (!res) {
+    errno = EFAULT;
+    return -1;
+  }
+
+  static constexpr size_t kNsPerSec = 1000000000;
+  switch (clock_id) {
+    case CLOCK_REALTIME: {
+      constexpr auto perSec = double(std::chrono::system_clock::period::num) /
+          std::chrono::system_clock::period::den;
+      res->tv_sec = time_t(perSec);
+      res->tv_nsec = time_t(perSec * kNsPerSec);
+      return 0;
+    }
+    case CLOCK_MONOTONIC: {
+      constexpr auto perSec = double(std::chrono::steady_clock::period::num) /
+          std::chrono::steady_clock::period::den;
+      res->tv_sec = time_t(perSec);
+      res->tv_nsec = time_t(perSec * kNsPerSec);
+      return 0;
+    }
+    case CLOCK_PROCESS_CPUTIME_ID:
+    case CLOCK_THREAD_CPUTIME_ID: {
+      DWORD adj, timeIncrement;
+      BOOL adjDisabled;
+      if (!GetSystemTimeAdjustment(&adj, &timeIncrement, &adjDisabled)) {
+        errno = EINVAL;
+        return -1;
+      }
+
+      res->tv_sec = 0;
+      res->tv_nsec = long(timeIncrement * 100);
+      return 0;
+    }
+
+    default:
+      errno = EINVAL;
+      return -1;
+  }
+}
+
+extern "C" int clock_gettime(clockid_t clock_id, struct timespec* tp) {
+  if (!tp) {
+    errno = EFAULT;
+    return -1;
+  }
+
+  const auto unanosToTimespec = [](timespec* tp, unsigned_nanos t) -> int {
+    static constexpr unsigned_nanos one_sec{std::chrono::seconds(1)};
+    tp->tv_sec =
+        time_t(std::chrono::duration_cast<std::chrono::seconds>(t).count());
+    tp->tv_nsec = long((t % one_sec).count());
+    return 0;
+  };
+
+  FILETIME createTime, exitTime, kernalTime, userTime;
+  switch (clock_id) {
+    case CLOCK_REALTIME: {
+      auto now = std::chrono::system_clock::now().time_since_epoch();
+      duration_to_ts(now, tp);
+      return 0;
+    }
+    case CLOCK_MONOTONIC: {
+      auto now = std::chrono::steady_clock::now().time_since_epoch();
+      duration_to_ts(now, tp);
+      return 0;
+    }
+    case CLOCK_PROCESS_CPUTIME_ID: {
+      if (!GetProcessTimes(
+              GetCurrentProcess(),
+              &createTime,
+              &exitTime,
+              &kernalTime,
+              &userTime)) {
+        errno = EINVAL;
+        return -1;
+      }
+
+      return unanosToTimespec(
+          tp,
+          filetimeToUnsignedNanos(kernalTime) +
+              filetimeToUnsignedNanos(userTime));
+    }
+    case CLOCK_THREAD_CPUTIME_ID: {
+      if (!GetThreadTimes(
+              GetCurrentThread(),
+              &createTime,
+              &exitTime,
+              &kernalTime,
+              &userTime)) {
+        errno = EINVAL;
+        return -1;
+      }
+
+      return unanosToTimespec(
+          tp,
+          filetimeToUnsignedNanos(kernalTime) +
+              filetimeToUnsignedNanos(userTime));
+    }
+
+    default:
+      errno = EINVAL;
+      return -1;
+  }
+}
+#else
+#error No clock_gettime(3) compatibility wrapper available for this platform.
+#endif
+#endif
+
+#ifdef _WIN32
+#include <iomanip>
+#include <sstream>
+
+#include <folly/portability/Windows.h>
+
+extern "C" {
+char* asctime_r(const tm* tm, char* buf) {
+  char tmpBuf[64];
+  if (asctime_s(tmpBuf, tm)) {
+    return nullptr;
+  }
+  // Nothing we can do if the buff is to small :(
+  return strcpy(buf, tmpBuf);
+}
+
+char* ctime_r(const time_t* t, char* buf) {
+  char tmpBuf[64];
+  if (ctime_s(tmpBuf, 64, t)) {
+    return nullptr;
+  }
+  // Nothing we can do if the buff is to small :(
+  return strcpy(buf, tmpBuf);
+}
+
+tm* gmtime_r(const time_t* t, tm* res) {
+  if (!gmtime_s(res, t)) {
+    return res;
+  }
+  return nullptr;
+}
+
+tm* localtime_r(const time_t* t, tm* o) {
+  if (!localtime_s(o, t)) {
+    return o;
+  }
+  return nullptr;
+}
+
+int nanosleep(const struct timespec* request, struct timespec* remain) {
+  Sleep((DWORD)((request->tv_sec * 1000) + (request->tv_nsec / 1000000)));
+  if (remain != nullptr) {
+    remain->tv_nsec = 0;
+    remain->tv_sec = 0;
+  }
+  return 0;
+}
+
+char* strptime(
+    const char* __restrict s,
+    const char* __restrict f,
+    struct tm* __restrict tm) {
+  // Isn't the C++ standard lib nice? std::get_time is defined such that its
+  // format parameters are the exact same as strptime. Of course, we have to
+  // create a string stream first, and imbue it with the current C locale, and
+  // we also have to make sure we return the right things if it fails, or
+  // if it succeeds, but this is still far simpler an implementation than any
+  // of the versions in any of the C standard libraries.
+  std::istringstream input(s);
+  input.imbue(std::locale(setlocale(LC_ALL, nullptr)));
+  input >> std::get_time(tm, f);
+  if (input.fail()) {
+    return nullptr;
+  }
+  return const_cast<char*>(s + input.tellg());
+}
+
+time_t timelocal(tm* tm) {
+  return mktime(tm);
+}
+
+time_t timegm(tm* tm) {
+  return _mkgmtime(tm);
+}
+}
+#endif

package/external/folly/folly/portability/Time.h

@@ -0,0 +1,74 @@
+/*
+ * 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 <stdint.h>
+#include <time.h>
+
+#include <folly/portability/Config.h>
+
+// OSX is a pain. The XCode 8 SDK always declares clock_gettime
+// even if the target OS version doesn't support it, so you get
+// an error at runtime because it can't resolve the symbol. We
+// solve that by pretending we have it here in the header and
+// then enable our implementation on the source side so that
+// gets linked in instead.
+#if defined(__MACH__) && defined(__CLOCK_AVAILABILITY)
+
+#ifdef FOLLY_HAVE_CLOCK_GETTIME
+#undef FOLLY_HAVE_CLOCK_GETTIME
+#endif
+
+#define FOLLY_HAVE_CLOCK_GETTIME 1
+#define FOLLY_FORCE_CLOCK_GETTIME_DEFINITION 1
+
+#else
+
+#define FOLLY_FORCE_CLOCK_GETTIME_DEFINITION 0
+
+#endif
+
+// These aren't generic implementations, so we can only declare them on
+// platforms we support.
+#if !FOLLY_HAVE_CLOCK_GETTIME && (defined(__MACH__) || defined(_WIN32))
+#define CLOCK_REALTIME 0
+#define CLOCK_MONOTONIC 1
+#define CLOCK_PROCESS_CPUTIME_ID 2
+#define CLOCK_THREAD_CPUTIME_ID 3
+
+typedef uint8_t clockid_t;
+extern "C" int clock_gettime(clockid_t clk_id, struct timespec* ts);
+extern "C" int clock_getres(clockid_t clk_id, struct timespec* ts);
+#endif
+
+#ifdef _WIN32
+#define TM_YEAR_BASE (1900)
+
+extern "C" {
+char* asctime_r(const tm* tm, char* buf);
+char* ctime_r(const time_t* t, char* buf);
+tm* gmtime_r(const time_t* t, tm* res);
+tm* localtime_r(const time_t* t, tm* o);
+int nanosleep(const struct timespec* request, struct timespec* remain);
+char* strptime(
+    const char* __restrict buf,
+    const char* __restrict fmt,
+    struct tm* __restrict tm);
+time_t timelocal(tm* tm);
+time_t timegm(tm* tm);
+}
+#endif

package/external/folly/folly/portability/Unistd.cpp

@@ -0,0 +1,33 @@
+// This is a reduced version of unistd.h from folly.
+// The version in folly does not work in UWP.
+// https://github.com/facebook/folly/issues/1452 tracks some of the work to get folly's unistd to work
+// Until the whole of unistd is implemented in folly, we can implement the limited part we need in
+// react-native-windows.
+
+// We need to prevent winnt.h from defining the core STATUS codes,
+// otherwise they will conflict with what we're getting from ntstatus.h
+#define UMDF_USING_NTSTATUS
+
+#include <folly/portability/Unistd.h>
+#include <folly/portability/Windows.h>
+
+namespace folly::portability::unistd {
+
+long sysconf(int tp) {
+  switch (tp) {
+    case _SC_PAGESIZE: {
+      SYSTEM_INFO inf;
+      GetSystemInfo(&inf);
+      return (long)inf.dwPageSize;
+    }
+    case _SC_NPROCESSORS_ONLN: {
+      SYSTEM_INFO inf;
+      GetSystemInfo(&inf);
+      return (long)inf.dwNumberOfProcessors;
+    }
+    default:
+      return -1L;
+  }
+}
+
+} // namespace folly::portability::unistd

package/external/folly/folly/portability/Unistd.h

@@ -0,0 +1,111 @@
+/*
+ * 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 <unistd.h>
+
+#if defined(__APPLE__) || defined(__EMSCRIPTEN__)
+typedef off_t off64_t;
+
+off64_t lseek64(int fh, off64_t off, int orig);
+
+ssize_t pread64(int fd, void* buf, size_t count, off64_t offset);
+
+#endif
+
+#else
+
+#include <cstdint>
+
+#include <process.h> // @manual
+
+#include <sys/locking.h> // @manual
+
+#include <folly/Portability.h>
+#include <folly/portability/SysTypes.h>
+
+// This is different from the normal headers because there are a few cases,
+// such as close(), where we need to override the definition of an existing
+// function. To avoid conflicts at link time, everything here is in a namespace
+// which is then used globally.
+
+#define _SC_PAGESIZE 1
+#define _SC_PAGE_SIZE _SC_PAGESIZE
+#define _SC_NPROCESSORS_ONLN 2
+#define _SC_NPROCESSORS_CONF 2
+
+// Windows doesn't define these, but these are the correct values
+// for Windows.
+#define STDIN_FILENO 0
+#define STDOUT_FILENO 1
+#define STDERR_FILENO 2
+
+// Windows is weird and doesn't actually defined these
+// for the parameters to access, so we have to do it ourselves -_-...
+#define F_OK 0
+#define X_OK F_OK
+#define W_OK 2
+#define R_OK 4
+#define RW_OK 6
+
+#define F_LOCK _LK_LOCK
+#define F_ULOCK _LK_UNLCK
+
+namespace folly {
+namespace portability {
+namespace unistd {
+using off64_t = int64_t;
+int access(char const* fn, int am);
+int chdir(const char* path);
+int close(int fh);
+int dup(int fh);
+int dup2(int fhs, int fhd);
+int fsync(int fd);
+int ftruncate(int fd, off_t len);
+char* getcwd(char* buf, int sz);
+int getdtablesize();
+int getgid();
+pid_t getppid();
+int getuid();
+int isatty(int fh);
+int lockf(int fd, int cmd, off_t len);
+off_t lseek(int fh, off_t off, int orig);
+off64_t lseek64(int fh, off64_t off, int orig);
+ssize_t read(int fh, void* buf, size_t mcc);
+int rmdir(const char* path);
+int pipe(int pth[2]);
+ssize_t pread(int fd, void* buf, size_t count, off_t offset);
+ssize_t pread64(int fd, void* buf, size_t count, off64_t offset);
+ssize_t pwrite(int fd, const void* buf, size_t count, off_t offset);
+ssize_t readlink(const char* path, char* buf, size_t buflen);
+void* sbrk(intptr_t i);
+unsigned int sleep(unsigned int seconds);
+long sysconf(int tp);
+int truncate(const char* path, off_t len);
+int usleep(unsigned int ms);
+ssize_t write(int fh, void const* buf, size_t count);
+} // namespace unistd
+} // namespace portability
+} // namespace folly
+
+FOLLY_PUSH_WARNING
+FOLLY_CLANG_DISABLE_WARNING("-Wheader-hygiene")
+/* using override */ using namespace folly::portability::unistd;
+FOLLY_POP_WARNING
+#endif

package/external/folly/folly/portability/Windows.h

@@ -0,0 +1,108 @@
+/*
+ * 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
+
+// Only do anything if we are on windows.
+#ifdef _WIN32
+// This header is intended to be used in-place of including <Windows.h>,
+// <WinSock2.h>, <io.h> or <direct.h>.
+// It includes all of them, and undefines certain names defined by them that
+// are used in places in Folly.
+//
+// These have to be this way because we define our own versions
+// of close(), because the normal Windows versions don't handle
+// sockets at all.
+
+// There are some ordering issues internally in the SDK; we need to ensure
+// stdio.h is included prior to including direct.h and io.h with internal names
+// disabled to ensure all of the normal names get declared properly.
+#include <stdio.h>
+
+#ifndef __STDC__
+/* nolint */
+#define __STDC__ 1
+#pragma push_macro("_CRT_DECLARE_NONSTDC_NAMES")
+#ifdef _CRT_DECLARE_NONSTDC_NAMES
+#undef _CRT_DECLARE_NONSTDC_NAMES
+#endif
+#pragma push_macro("_CRT_INTERNAL_NONSTDC_NAMES")
+#undef _CRT_INTERNAL_NONSTDC_NAMES
+#include <direct.h> // @manual nolint
+#include <io.h> // @manual nolint
+#undef __STDC__
+#pragma pop_macro("_CRT_INTERNAL_NONSTDC_NAMES")
+#pragma pop_macro("_CRT_DECLARE_NONSTDC_NAMES")
+#else
+#include <direct.h> // @manual nolint
+#include <io.h> // @manual nolint
+#endif
+
+#if defined(min) || defined(max)
+#error Windows.h needs to be included by this header, or else NOMINMAX needs \
+ to be defined before including it yourself.
+#endif
+
+// This is needed because, for some absurd reason, one of the windows headers
+// tries to define "min" and "max" as macros, which messes up most uses of
+// std::numeric_limits.
+#ifndef NOMINMAX
+#define NOMINMAX 1
+#endif
+
+#include <WinSock2.h> // @manual
+#include <Windows.h> // @manual
+
+#ifdef CAL_GREGORIAN
+#undef CAL_GREGORIAN
+#endif
+
+// Defined in the GDI interface.
+#ifdef ERROR
+#undef ERROR
+#endif
+
+// Defined in minwindef.h
+#ifdef IN
+#undef IN
+#endif
+
+// Defined in winerror.h
+#ifdef NO_ERROR
+#undef NO_ERROR
+#endif
+
+// Defined in minwindef.h
+#ifdef OUT
+#undef OUT
+#endif
+
+// Defined in minwindef.h
+#ifdef STRICT
+#undef STRICT
+#endif
+
+// Defined in Winbase.h
+#ifdef Yield
+#undef Yield
+#endif
+
+// Defined in nb30.h
+#ifdef REGISTERED
+#undef REGISTERED
+#endif
+
+#endif

package/external/folly/folly/portability/openat2.c

@@ -0,0 +1,30 @@
+/*
+ * 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/folly-config.h>
+
+#if FOLLY_HAVE_OPENAT2
+
+#include <folly/portability/openat2.h>
+
+#include <sys/syscall.h>
+#include <unistd.h>
+
+int openat2(int dirfd, const char* pathname, const struct open_how* how) {
+  return syscall(SYS_openat2, dirfd, pathname, how, sizeof(struct open_how));
+}
+
+#endif