diff options
Diffstat (limited to 'include/support')
| -rw-r--r-- | include/support/android/locale_bionic.h | 31 | ||||
| -rw-r--r-- | include/support/ibm/limits.h | 99 | ||||
| -rw-r--r-- | include/support/ibm/support.h | 54 | ||||
| -rw-r--r-- | include/support/ibm/xlocale.h | 326 | ||||
| -rw-r--r-- | include/support/newlib/xlocale.h | 63 | ||||
| -rw-r--r-- | include/support/solaris/floatingpoint.h | 14 | ||||
| -rw-r--r-- | include/support/solaris/wchar.h | 47 | ||||
| -rw-r--r-- | include/support/solaris/xlocale.h | 67 | ||||
| -rw-r--r-- | include/support/win32/limits_win32.h | 79 | ||||
| -rw-r--r-- | include/support/win32/locale_win32.h | 129 | ||||
| -rw-r--r-- | include/support/win32/math_win32.h | 117 | ||||
| -rw-r--r-- | include/support/win32/support.h | 206 | ||||
| -rw-r--r-- | include/support/xlocale/xlocale.h | 194 |
13 files changed, 1426 insertions, 0 deletions
diff --git a/include/support/android/locale_bionic.h b/include/support/android/locale_bionic.h new file mode 100644 index 0000000000000..3a020da67e6bd --- /dev/null +++ b/include/support/android/locale_bionic.h @@ -0,0 +1,31 @@ +// -*- C++ -*- +//===------------------- support/android/locale_bionic.h ------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_SUPPORT_ANDROID_LOCALE_BIONIC_H +#define _LIBCPP_SUPPORT_ANDROID_LOCALE_BIONIC_H + +#if defined(__ANDROID__) + +#ifdef __cplusplus +extern "C" { +#endif + +#include <stdlib.h> +#include <xlocale.h> + +#ifdef __cplusplus +} +#endif + +// Share implementation with Newlib +#include <support/xlocale/xlocale.h> + +#endif // defined(__ANDROID__) +#endif // _LIBCPP_SUPPORT_ANDROID_LOCALE_BIONIC_H diff --git a/include/support/ibm/limits.h b/include/support/ibm/limits.h new file mode 100644 index 0000000000000..efdb359659653 --- /dev/null +++ b/include/support/ibm/limits.h @@ -0,0 +1,99 @@ +// -*- C++ -*- +//===--------------------- support/ibm/limits.h ---------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_SUPPORT_IBM_LIMITS_H +#define _LIBCPP_SUPPORT_IBM_LIMITS_H + +#if !defined(_AIX) // Linux +#include <math.h> // for HUGE_VAL, HUGE_VALF, HUGE_VALL, and NAN + +static const unsigned int _QNAN_F = 0x7fc00000; +#define NANF (*((float *)(&_QNAN_F))) +static const unsigned int _QNAN_LDBL128[4] = {0x7ff80000, 0x0, 0x0, 0x0}; +#define NANL (*((long double *)(&_QNAN_LDBL128))) +static const unsigned int _SNAN_F= 0x7f855555; +#define NANSF (*((float *)(&_SNAN_F))) +static const unsigned int _SNAN_D[2] = {0x7ff55555, 0x55555555}; +#define NANS (*((double *)(&_SNAN_D))) +static const unsigned int _SNAN_LDBL128[4] = {0x7ff55555, 0x55555555, 0x0, 0x0}; +#define NANSL (*((long double *)(&_SNAN_LDBL128))) + +#define __builtin_huge_val() HUGE_VAL +#define __builtin_huge_valf() HUGE_VALF +#define __builtin_huge_vall() HUGE_VALL +#define __builtin_nan(__dummy) NAN +#define __builtin_nanf(__dummy) NANF +#define __builtin_nanl(__dummy) NANL +#define __builtin_nans(__dummy) NANS +#define __builtin_nansf(__dummy) NANSF +#define __builtin_nansl(__dummy) NANSL + +#else + +#include <math.h> +#include <float.h> // limit constants + +#define __builtin_huge_val() HUGE_VAL //0x7ff0000000000000 +#define __builtin_huge_valf() HUGE_VALF //0x7f800000 +#define __builtin_huge_vall() HUGE_VALL //0x7ff0000000000000 +#define __builtin_nan(__dummy) nan(__dummy) //0x7ff8000000000000 +#define __builtin_nanf(__dummy) nanf(__dummy) // 0x7ff80000 +#define __builtin_nanl(__dummy) nanl(__dummy) //0x7ff8000000000000 +#define __builtin_nans(__dummy) DBL_SNAN //0x7ff5555555555555 +#define __builtin_nansf(__dummy) FLT_SNAN //0x7f855555 +#define __builtin_nansl(__dummy) DBL_SNAN //0x7ff5555555555555 + +#define __FLT_MANT_DIG__ FLT_MANT_DIG +#define __FLT_DIG__ FLT_DIG +#define __FLT_RADIX__ FLT_RADIX +#define __FLT_MIN_EXP__ FLT_MIN_EXP +#define __FLT_MIN_10_EXP__ FLT_MIN_10_EXP +#define __FLT_MAX_EXP__ FLT_MAX_EXP +#define __FLT_MAX_10_EXP__ FLT_MAX_10_EXP +#define __FLT_MIN__ FLT_MIN +#define __FLT_MAX__ FLT_MAX +#define __FLT_EPSILON__ FLT_EPSILON +// predefined by XLC on LoP +#define __FLT_DENORM_MIN__ 1.40129846e-45F + +#define __DBL_MANT_DIG__ DBL_MANT_DIG +#define __DBL_DIG__ DBL_DIG +#define __DBL_MIN_EXP__ DBL_MIN_EXP +#define __DBL_MIN_10_EXP__ DBL_MIN_10_EXP +#define __DBL_MAX_EXP__ DBL_MAX_EXP +#define __DBL_MAX_10_EXP__ DBL_MAX_10_EXP +#define __DBL_MIN__ DBL_MIN +#define __DBL_MAX__ DBL_MAX +#define __DBL_EPSILON__ DBL_EPSILON +// predefined by XLC on LoP +#define __DBL_DENORM_MIN__ 4.9406564584124654e-324 + +#define __LDBL_MANT_DIG__ LDBL_MANT_DIG +#define __LDBL_DIG__ LDBL_DIG +#define __LDBL_MIN_EXP__ LDBL_MIN_EXP +#define __LDBL_MIN_10_EXP__ LDBL_MIN_10_EXP +#define __LDBL_MAX_EXP__ LDBL_MAX_EXP +#define __LDBL_MAX_10_EXP__ LDBL_MAX_10_EXP +#define __LDBL_MIN__ LDBL_MIN +#define __LDBL_MAX__ LDBL_MAX +#define __LDBL_EPSILON__ LDBL_EPSILON +// predefined by XLC on LoP +#if __LONGDOUBLE128 +#define __LDBL_DENORM_MIN__ 4.94065645841246544176568792868221e-324L +#else +#define __LDBL_DENORM_MIN__ 4.9406564584124654e-324L +#endif + +// predefined by XLC on LoP +#define __CHAR_BIT__ 8 + +#endif // _AIX + +#endif // _LIBCPP_SUPPORT_IBM_LIMITS_H diff --git a/include/support/ibm/support.h b/include/support/ibm/support.h new file mode 100644 index 0000000000000..0abfa7f95a65a --- /dev/null +++ b/include/support/ibm/support.h @@ -0,0 +1,54 @@ +// -*- C++ -*- +//===----------------------- support/ibm/support.h ----------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_SUPPORT_IBM_SUPPORT_H +#define _LIBCPP_SUPPORT_IBM_SUPPORT_H + +extern "builtin" int __popcnt4(unsigned int); +extern "builtin" int __popcnt8(unsigned long long); +extern "builtin" unsigned int __cnttz4(unsigned int); +extern "builtin" unsigned int __cnttz8(unsigned long long); +extern "builtin" unsigned int __cntlz4(unsigned int); +extern "builtin" unsigned int __cntlz8(unsigned long long); + +// Builtin functions for counting population +#define __builtin_popcount(x) __popcnt4(x) +#define __builtin_popcountll(x) __popcnt8(x) +#if defined(__64BIT__) +#define __builtin_popcountl(x) __builtin_popcountll(x) +#else +#define __builtin_popcountl(x) __builtin_popcount(x) +#endif + +// Builtin functions for counting trailing zeros +#define __builtin_ctz(x) __cnttz4(x) +#define __builtin_ctzll(x) __cnttz8(x) +#if defined(__64BIT__) +#define __builtin_ctzl(x) __builtin_ctzll(x) +#else +#define __builtin_ctzl(x) __builtin_ctz(x) +#endif + +// Builtin functions for counting leading zeros +#define __builtin_clz(x) __cntlz4(x) +#define __builtin_clzll(x) __cntlz8(x) +#if defined(__64BIT__) +#define __builtin_clzl(x) __builtin_clzll(x) +#else +#define __builtin_clzl(x) __builtin_clz(x) +#endif + +#if defined(__64BIT__) +#define __SIZE_WIDTH__ 64 +#else +#define __SIZE_WIDTH__ 32 +#endif + +#endif // _LIBCPP_SUPPORT_IBM_SUPPORT_H diff --git a/include/support/ibm/xlocale.h b/include/support/ibm/xlocale.h new file mode 100644 index 0000000000000..8d99a5c7d34d5 --- /dev/null +++ b/include/support/ibm/xlocale.h @@ -0,0 +1,326 @@ +// -*- C++ -*- +//===--------------------- support/ibm/xlocale.h -------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_SUPPORT_IBM_XLOCALE_H +#define _LIBCPP_SUPPORT_IBM_XLOCALE_H + +#if defined(_AIX) +#include "cstdlib" + +#ifdef __cplusplus +extern "C" { +#endif + +#if !defined(_AIX71) +// AIX 7.1 and higher has these definitions. Definitions and stubs +// are provied here as a temporary workaround on AIX 6.1. + +#define LC_COLLATE_MASK 1 +#define LC_CTYPE_MASK 2 +#define LC_MESSAGES_MASK 4 +#define LC_MONETARY_MASK 8 +#define LC_NUMERIC_MASK 16 +#define LC_TIME_MASK 32 +#define LC_ALL_MASK (LC_COLLATE_MASK | LC_CTYPE_MASK | \ + LC_MESSAGES_MASK | LC_MONETARY_MASK |\ + LC_NUMERIC_MASK | LC_TIME_MASK) + +typedef void* locale_t; + +// The following are stubs. They are not supported on AIX 6.1. +static inline +locale_t newlocale(int category_mask, const char *locale, locale_t base) +{ + _LC_locale_t *newloc, *loc; + if ((loc = (_LC_locale_t *)__xopen_locale(locale)) == NULL) + { + errno = EINVAL; + return (locale_t)0; + } + if ((newloc = (_LC_locale_t *)calloc(1, sizeof(_LC_locale_t))) == NULL) + { + errno = ENOMEM; + return (locale_t)0; + } + if (!base) + base = (_LC_locale_t *)__xopen_locale("C"); + memcpy(newloc, base, sizeof (_LC_locale_t)); + if (category_mask & LC_COLLATE_MASK) + newloc->lc_collate = loc->lc_collate; + if (category_mask & LC_CTYPE_MASK) + newloc->lc_ctype = loc->lc_ctype; + //if (category_mask & LC_MESSAGES_MASK) + // newloc->lc_messages = loc->lc_messages; + if (category_mask & LC_MONETARY_MASK) + newloc->lc_monetary = loc->lc_monetary; + if (category_mask & LC_TIME_MASK) + newloc->lc_time = loc->lc_time; + if (category_mask & LC_NUMERIC_MASK) + newloc->lc_numeric = loc->lc_numeric; + return (locale_t)newloc; +} +static inline +void freelocale(locale_t locobj) +{ + free(locobj); +} +static inline +locale_t uselocale(locale_t newloc) +{ + return (locale_t)0; +} + +static inline +int isalnum_l(int c, locale_t locale) +{ + return __xisalnum(locale, c); +} +static inline +int isalpha_l(int c, locale_t locale) +{ + return __xisalpha(locale, c); +} +static inline +int isblank_l(int c, locale_t locale) +{ + return __xisblank(locale, c); +} +static inline +int iscntrl_l(int c, locale_t locale) +{ + return __xiscntrl(locale, c); +} +static inline +int isdigit_l(int c, locale_t locale) +{ + return __xisdigit(locale, c); +} +static inline +int isgraph_l(int c, locale_t locale) +{ + return __xisgraph(locale, c); +} +static inline +int islower_l(int c, locale_t locale) +{ + return __xislower(locale, c); +} +static inline +int isprint_l(int c, locale_t locale) +{ + return __xisprint(locale, c); +} + +static inline +int ispunct_l(int c, locale_t locale) +{ + return __xispunct(locale, c); +} +static inline +int isspace_l(int c, locale_t locale) +{ + return __xisspace(locale, c); +} +static inline +int isupper_l(int c, locale_t locale) +{ + return __xisupper(locale, c); +} + +static inline +int isxdigit_l(int c, locale_t locale) +{ + return __xisxdigit(locale, c); +} + +static inline +int iswalnum_l(wchar_t wc, locale_t locale) +{ + return __xiswalnum(locale, wc); +} + +static inline +int iswalpha_l(wchar_t wc, locale_t locale) +{ + return __xiswalpha(locale, wc); +} + +static inline +int iswblank_l(wchar_t wc, locale_t locale) +{ + return __xiswblank(locale, wc); +} + +static inline +int iswcntrl_l(wchar_t wc, locale_t locale) +{ + return __xiswcntrl(locale, wc); +} + +static inline +int iswdigit_l(wchar_t wc, locale_t locale) +{ + return __xiswdigit(locale, wc); +} + +static inline +int iswgraph_l(wchar_t wc, locale_t locale) +{ + return __xiswgraph(locale, wc); +} + +static inline +int iswlower_l(wchar_t wc, locale_t locale) +{ + return __xiswlower(locale, wc); +} + +static inline +int iswprint_l(wchar_t wc, locale_t locale) +{ + return __xiswprint(locale, wc); +} + +static inline +int iswpunct_l(wchar_t wc, locale_t locale) +{ + return __xiswpunct(locale, wc); +} + +static inline +int iswspace_l(wchar_t wc, locale_t locale) +{ + return __xiswspace(locale, wc); +} + +static inline +int iswupper_l(wchar_t wc, locale_t locale) +{ + return __xiswupper(locale, wc); +} + +static inline +int iswxdigit_l(wchar_t wc, locale_t locale) +{ + return __xiswxdigit(locale, wc); +} + +static inline +int iswctype_l(wint_t wc, wctype_t desc, locale_t locale) +{ + return __xiswctype(locale, wc, desc); +} + +static inline +int toupper_l(int c, locale_t locale) +{ + return __xtoupper(locale, c); +} +static inline +int tolower_l(int c, locale_t locale) +{ + return __xtolower(locale, c); +} +static inline +wint_t towupper_l(wint_t wc, locale_t locale) +{ + return __xtowupper(locale, wc); +} +static inline +wint_t towlower_l(wint_t wc, locale_t locale) +{ + return __xtowlower(locale, wc); +} + +static inline +int strcoll_l(const char *__s1, const char *__s2, locale_t locale) +{ + return __xstrcoll(locale, __s1, __s2); +} +static inline +int wcscoll_l(const wchar_t *__s1, const wchar_t *__s2, locale_t locale) +{ + return __xwcscoll(locale, __s1, __s2); +} +static inline +size_t strxfrm_l(char *__s1, const char *__s2, size_t __n, locale_t locale) +{ + return __xstrxfrm(locale, __s1, __s2, __n); +} + +static inline +size_t wcsxfrm_l(wchar_t *__ws1, const wchar_t *__ws2, size_t __n, + locale_t locale) +{ + return __xwcsxfrm(locale, __ws1, __ws2, __n); +} +#endif // !defined(_AIX71) + +// strftime_l() is defined by POSIX. However, AIX 7.1 does not have it +// implemented yet. +static inline +size_t strftime_l(char *__s, size_t __size, const char *__fmt, + const struct tm *__tm, locale_t locale) { + return __xstrftime(locale, __s, __size, __fmt, __tm); +} + +// The following are not POSIX routines. These are quick-and-dirty hacks +// to make things pretend to work +static inline +long long strtoll_l(const char *__nptr, char **__endptr, + int __base, locale_t locale) { + return strtoll(__nptr, __endptr, __base); +} +static inline +long strtol_l(const char *__nptr, char **__endptr, + int __base, locale_t locale) { + return strtol(__nptr, __endptr, __base); +} +static inline +long double strtold_l(const char *__nptr, char **__endptr, + locale_t locale) { + return strtold(__nptr, __endptr); +} +static inline +unsigned long long strtoull_l(const char *__nptr, char **__endptr, + int __base, locale_t locale) { + return strtoull(__nptr, __endptr, __base); +} +static inline +unsigned long strtoul_l(const char *__nptr, char **__endptr, + int __base, locale_t locale) { + return strtoul(__nptr, __endptr, __base); +} + +static inline +int vasprintf(char **strp, const char *fmt, va_list ap) +{ + const size_t buff_size = 256; + int str_size; + if ((*strp = (char *)malloc(buff_size)) == NULL) + { + return -1; + } + if ((str_size = vsnprintf(*strp, buff_size, fmt, ap)) >= buff_size) + { + if ((*strp = (char *)realloc(*strp, str_size + 1)) == NULL) + { + return -1; + } + str_size = vsnprintf(*strp, str_size + 1, fmt, ap); + } + return str_size; +} + +#ifdef __cplusplus +} +#endif +#endif // defined(_AIX) +#endif // _LIBCPP_SUPPORT_IBM_XLOCALE_H diff --git a/include/support/newlib/xlocale.h b/include/support/newlib/xlocale.h new file mode 100644 index 0000000000000..d067cf85a3bcb --- /dev/null +++ b/include/support/newlib/xlocale.h @@ -0,0 +1,63 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_SUPPORT_NEWLIB_XLOCALE_H +#define _LIBCPP_SUPPORT_NEWLIB_XLOCALE_H + +#if defined(_NEWLIB_VERSION) + +#include <cstdlib> +#include <clocale> +#include <cwctype> +#include <ctype.h> + +#ifdef __cplusplus +extern "C" { +#endif + +// Patch over newlib's lack of extended locale support +typedef void *locale_t; +static inline locale_t duplocale(locale_t) { + return NULL; +} + +static inline void freelocale(locale_t) { +} + +static inline locale_t newlocale(int, const char *, locale_t) { + return NULL; +} + +static inline locale_t uselocale(locale_t) { + return NULL; +} + +#define LC_COLLATE_MASK (1 << LC_COLLATE) +#define LC_CTYPE_MASK (1 << LC_CTYPE) +#define LC_MESSAGES_MASK (1 << LC_MESSAGES) +#define LC_MONETARY_MASK (1 << LC_MONETARY) +#define LC_NUMERIC_MASK (1 << LC_NUMERIC) +#define LC_TIME_MASK (1 << LC_TIME) +#define LC_ALL_MASK (LC_COLLATE_MASK|\ + LC_CTYPE_MASK|\ + LC_MONETARY_MASK|\ + LC_NUMERIC_MASK|\ + LC_TIME_MASK|\ + LC_MESSAGES_MASK) + +// Share implementation with Android's Bionic +#include <support/xlocale/xlocale.h> + +#ifdef __cplusplus +} // extern "C" +#endif + +#endif // _NEWLIB_VERSION + +#endif diff --git a/include/support/solaris/floatingpoint.h b/include/support/solaris/floatingpoint.h new file mode 100644 index 0000000000000..999d144b1f2e5 --- /dev/null +++ b/include/support/solaris/floatingpoint.h @@ -0,0 +1,14 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#define atof sun_atof +#define strtod sun_strtod +#include_next "floatingpoint.h" +#undef atof +#undef strtod diff --git a/include/support/solaris/wchar.h b/include/support/solaris/wchar.h new file mode 100644 index 0000000000000..0e8e660c8bd4f --- /dev/null +++ b/include/support/solaris/wchar.h @@ -0,0 +1,47 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#define iswalpha sun_iswalpha +#define iswupper sun_iswupper +#define iswlower sun_iswlower +#define iswdigit sun_iswdigit +#define iswxdigit sun_iswxdigit +#define iswalnum sun_iswalnum +#define iswspace sun_iswspace +#define iswpunct sun_iswpunct +#define iswprint sun_iswprint +#define iswgraph sun_iswgraph +#define iswcntrl sun_iswcntrl +#define iswctype sun_iswctype +#define towlower sun_towlower +#define towupper sun_towupper +#define wcswcs sun_wcswcs +#define wcswidth sun_wcswidth +#define wcwidth sun_wcwidth +#define wctype sun_wctype +#define _WCHAR_T 1 +#include_next "wchar.h" +#undef iswalpha +#undef iswupper +#undef iswlower +#undef iswdigit +#undef iswxdigit +#undef iswalnum +#undef iswspace +#undef iswpunct +#undef iswprint +#undef iswgraph +#undef iswcntrl +#undef iswctype +#undef towlower +#undef towupper +#undef wcswcs +#undef wcswidth +#undef wcwidth +#undef wctype diff --git a/include/support/solaris/xlocale.h b/include/support/solaris/xlocale.h new file mode 100644 index 0000000000000..62b0d74a6d23f --- /dev/null +++ b/include/support/solaris/xlocale.h @@ -0,0 +1,67 @@ +//===----------------------------------------------------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +//////////////////////////////////////////////////////////////////////////////// +// Minimal xlocale implementation for Solaris. This implements the subset of +// the xlocale APIs that libc++ depends on. +//////////////////////////////////////////////////////////////////////////////// +#ifndef __XLOCALE_H_INCLUDED +#define __XLOCALE_H_INCLUDED + +#include <stdlib.h> + +#ifdef __cplusplus +extern "C" { +#endif + + +int snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...); +int asprintf_l(char **__s, locale_t __l, const char *__format, ...); + +int sscanf_l(const char *__s, locale_t __l, const char *__format, ...); + +int toupper_l(int __c, locale_t __l); +int tolower_l(int __c, locale_t __l); + +struct lconv *localeconv(void); +struct lconv *localeconv_l(locale_t __l); + +// FIXME: These are quick-and-dirty hacks to make things pretend to work +static inline +long long strtoll_l(const char *__nptr, char **__endptr, + int __base, locale_t __loc) { + return strtoll(__nptr, __endptr, __base); +} +static inline +long strtol_l(const char *__nptr, char **__endptr, + int __base, locale_t __loc) { + return strtol(__nptr, __endptr, __base); +} +static inline +long double strtold_l(const char *__nptr, char **__endptr, + locale_t __loc) { + return strtold(__nptr, __endptr); +} +static inline +unsigned long long strtoull_l(const char *__nptr, char **__endptr, + int __base, locale_t __loc) { + return strtoull(__nptr, __endptr, __base); +} +static inline +unsigned long strtoul_l(const char *__nptr, char **__endptr, + int __base, locale_t __loc) { + return strtoul(__nptr, __endptr, __base); +} + + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/include/support/win32/limits_win32.h b/include/support/win32/limits_win32.h new file mode 100644 index 0000000000000..406cd3025bf84 --- /dev/null +++ b/include/support/win32/limits_win32.h @@ -0,0 +1,79 @@ +// -*- C++ -*- +//===--------------------- support/win32/limits_win32.h -------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_SUPPORT_WIN32_LIMITS_WIN32_H +#define _LIBCPP_SUPPORT_WIN32_LIMITS_WIN32_H + +#if !defined(_LIBCPP_MSVCRT) +#error "This header complements the Microsoft C Runtime library, and should not be included otherwise." +#else + +#include <limits.h> // CHAR_BIT +#include <float.h> // limit constants + +#if ! defined(__clang__) +#define __CHAR_BIT__ CHAR_BIT + +#define __FLT_MANT_DIG__ FLT_MANT_DIG +#define __FLT_DIG__ FLT_DIG +#define __FLT_RADIX__ FLT_RADIX +#define __FLT_MIN_EXP__ FLT_MIN_EXP +#define __FLT_MIN_10_EXP__ FLT_MIN_10_EXP +#define __FLT_MAX_EXP__ FLT_MAX_EXP +#define __FLT_MAX_10_EXP__ FLT_MAX_10_EXP +#define __FLT_MIN__ FLT_MIN +#define __FLT_MAX__ FLT_MAX +#define __FLT_EPSILON__ FLT_EPSILON +// predefined by MinGW GCC +#define __FLT_DENORM_MIN__ 1.40129846432481707092e-45F + +#define __DBL_MANT_DIG__ DBL_MANT_DIG +#define __DBL_DIG__ DBL_DIG +#define __DBL_RADIX__ DBL_RADIX +#define __DBL_MIN_EXP__ DBL_MIN_EXP +#define __DBL_MIN_10_EXP__ DBL_MIN_10_EXP +#define __DBL_MAX_EXP__ DBL_MAX_EXP +#define __DBL_MAX_10_EXP__ DBL_MAX_10_EXP +#define __DBL_MIN__ DBL_MIN +#define __DBL_MAX__ DBL_MAX +#define __DBL_EPSILON__ DBL_EPSILON +// predefined by MinGW GCC +#define __DBL_DENORM_MIN__ double(4.94065645841246544177e-324L) + +#define __LDBL_MANT_DIG__ LDBL_MANT_DIG +#define __LDBL_DIG__ LDBL_DIG +#define __LDBL_RADIX__ LDBL_RADIX +#define __LDBL_MIN_EXP__ LDBL_MIN_EXP +#define __LDBL_MIN_10_EXP__ LDBL_MIN_10_EXP +#define __LDBL_MAX_EXP__ LDBL_MAX_EXP +#define __LDBL_MAX_10_EXP__ LDBL_MAX_10_EXP +#define __LDBL_MIN__ LDBL_MIN +#define __LDBL_MAX__ LDBL_MAX +#define __LDBL_EPSILON__ LDBL_EPSILON +// predefined by MinGW GCC +#define __LDBL_DENORM_MIN__ 3.64519953188247460253e-4951L + +// __builtin replacements/workarounds +#include <math.h> // HUGE_VAL +#include <ymath.h> // internal MSVC header providing the needed functionality +#define __builtin_huge_val() HUGE_VAL +#define __builtin_huge_valf() _FInf._Float +#define __builtin_huge_vall() _LInf._Long_double +#define __builtin_nan(__dummy) _Nan._Double +#define __builtin_nanf(__dummy) _FNan._Float +#define __builtin_nanl(__dummmy) _LNan._Long_double +#define __builtin_nans(__dummy) _Snan._Double +#define __builtin_nansf(__dummy) _FSnan._Float +#define __builtin_nansl(__dummy) _LSnan._Long_double +#endif // ! defined(__clang__) + +#endif // _LIBCPP_MSVCRT + +#endif // _LIBCPP_SUPPORT_WIN32_LIMITS_WIN32_H diff --git a/include/support/win32/locale_win32.h b/include/support/win32/locale_win32.h new file mode 100644 index 0000000000000..f728d234472f9 --- /dev/null +++ b/include/support/win32/locale_win32.h @@ -0,0 +1,129 @@ +// -*- C++ -*- +//===--------------------- support/win32/locale_win32.h -------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H +#define _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H + +// ctype mask table defined in msvcrt.dll +extern "C" unsigned short __declspec(dllimport) _ctype[]; + +#include "support/win32/support.h" +#include <stdio.h> +#include <memory> +#include <xlocinfo.h> // _locale_t +#define locale_t _locale_t +#define LC_COLLATE_MASK _M_COLLATE +#define LC_CTYPE_MASK _M_CTYPE +#define LC_MONETARY_MASK _M_MONETARY +#define LC_NUMERIC_MASK _M_NUMERIC +#define LC_TIME_MASK _M_TIME +#define LC_MESSAGES_MASK _M_MESSAGES +#define LC_ALL_MASK ( LC_COLLATE_MASK \ + | LC_CTYPE_MASK \ + | LC_MESSAGES_MASK \ + | LC_MONETARY_MASK \ + | LC_NUMERIC_MASK \ + | LC_TIME_MASK ) +#define freelocale _free_locale +// FIXME: base currently unused. Needs manual work to construct the new locale +locale_t newlocale( int mask, const char * locale, locale_t base ); +locale_t uselocale( locale_t newloc ); +lconv *localeconv_l( locale_t loc ); +size_t mbrlen_l( const char *__restrict s, size_t n, + mbstate_t *__restrict ps, locale_t loc); +size_t mbsrtowcs_l( wchar_t *__restrict dst, const char **__restrict src, + size_t len, mbstate_t *__restrict ps, locale_t loc ); +size_t wcrtomb_l( char *__restrict s, wchar_t wc, mbstate_t *__restrict ps, + locale_t loc); +size_t mbrtowc_l( wchar_t *__restrict pwc, const char *__restrict s, + size_t n, mbstate_t *__restrict ps, locale_t loc); +size_t mbsnrtowcs_l( wchar_t *__restrict dst, const char **__restrict src, + size_t nms, size_t len, mbstate_t *__restrict ps, locale_t loc); +size_t wcsnrtombs_l( char *__restrict dst, const wchar_t **__restrict src, + size_t nwc, size_t len, mbstate_t *__restrict ps, locale_t loc); +wint_t btowc_l( int c, locale_t loc ); +int wctob_l( wint_t c, locale_t loc ); +typedef _VSTD::remove_pointer<locale_t>::type __locale_struct; +typedef _VSTD::unique_ptr<__locale_struct, decltype(&uselocale)> __locale_raii; +inline _LIBCPP_ALWAYS_INLINE +decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l ) +{ + __locale_raii __current( uselocale(__l), uselocale ); + return MB_CUR_MAX; +} + +// the *_l functions are prefixed on Windows, only available for msvcr80+, VS2005+ +#define mbtowc_l _mbtowc_l +#define strtoll_l _strtoi64_l +#define strtoull_l _strtoui64_l +// FIXME: current msvcrt does not know about long double +#define strtold_l _strtod_l + +inline _LIBCPP_INLINE_VISIBILITY +int +islower_l(int c, _locale_t loc) +{ + return _islower_l((int)c, loc); +} + +inline _LIBCPP_INLINE_VISIBILITY +int +isupper_l(int c, _locale_t loc) +{ + return _isupper_l((int)c, loc); +} + +#define isdigit_l _isdigit_l +#define isxdigit_l _isxdigit_l +#define strcoll_l _strcoll_l +#define strxfrm_l _strxfrm_l +#define wcscoll_l _wcscoll_l +#define wcsxfrm_l _wcsxfrm_l +#define toupper_l _toupper_l +#define tolower_l _tolower_l +#define iswspace_l _iswspace_l +#define iswprint_l _iswprint_l +#define iswcntrl_l _iswcntrl_l +#define iswupper_l _iswupper_l +#define iswlower_l _iswlower_l +#define iswalpha_l _iswalpha_l +#define iswdigit_l _iswdigit_l +#define iswpunct_l _iswpunct_l +#define iswxdigit_l _iswxdigit_l +#define towupper_l _towupper_l +#define towlower_l _towlower_l +#define strftime_l _strftime_l +#define sscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ ) +#define vsscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ ) +#define sprintf_l( __s, __l, __f, ... ) _sprintf_l( __s, __f, __l, __VA_ARGS__ ) +#define vsprintf_l( __s, __l, __f, ... ) _vsprintf_l( __s, __f, __l, __VA_ARGS__ ) +#define vsnprintf_l( __s, __n, __l, __f, ... ) _vsnprintf_l( __s, __n, __f, __l, __VA_ARGS__ ) +int snprintf_l(char *ret, size_t n, locale_t loc, const char *format, ...); +int asprintf_l( char **ret, locale_t loc, const char *format, ... ); +int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap ); + + +// not-so-pressing FIXME: use locale to determine blank characters +inline int isblank_l( int c, locale_t /*loc*/ ) +{ + return ( c == ' ' || c == '\t' ); +} +inline int iswblank_l( wint_t c, locale_t /*loc*/ ) +{ + return ( c == L' ' || c == L'\t' ); +} + +#if defined(_LIBCPP_MSVCRT) +inline int isblank( int c, locale_t /*loc*/ ) +{ return ( c == ' ' || c == '\t' ); } +inline int iswblank( wint_t c, locale_t /*loc*/ ) +{ return ( c == L' ' || c == L'\t' ); } +#endif // _LIBCPP_MSVCRT +#endif // _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H diff --git a/include/support/win32/math_win32.h b/include/support/win32/math_win32.h new file mode 100644 index 0000000000000..0d6b422a165cf --- /dev/null +++ b/include/support/win32/math_win32.h @@ -0,0 +1,117 @@ +// -*- C++ -*- +//===---------------------- support/win32/math_win32.h --------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_SUPPORT_WIN32_MATH_WIN32_H +#define _LIBCPP_SUPPORT_WIN32_MATH_WIN32_H + +#if !defined(_LIBCPP_MSVCRT) +#error "This header complements Microsoft's C Runtime library, and should not be included otherwise." +#else + +#include <math.h> +#include <float.h> // _FPCLASS_PN etc. +#include <crtversion.h> + +#if ((_VC_CRT_MAJOR_VERSION-0) < 12) +// Necessary? +typedef float float_t; +typedef double double_t; + +_LIBCPP_ALWAYS_INLINE bool isfinite( double num ) +{ + return _finite(num) != 0; +} +_LIBCPP_ALWAYS_INLINE bool isinf( double num ) +{ + return !isfinite(num) && !_isnan(num); +} +_LIBCPP_ALWAYS_INLINE bool isnan( double num ) +{ + return _isnan(num) != 0; +} +_LIBCPP_ALWAYS_INLINE bool isnormal( double num ) +{ + int class_ = _fpclass(num); + return class_ == _FPCLASS_NN || class_ == _FPCLASS_PN; +} + +_LIBCPP_ALWAYS_INLINE bool isgreater( double x, double y ) +{ + if(_fpclass(x) == _FPCLASS_SNAN || _fpclass(y) == _FPCLASS_SNAN) return false; + else return x > y; +} + +_LIBCPP_ALWAYS_INLINE bool isgreaterequal( double x, double y ) +{ + if(_fpclass(x) == _FPCLASS_SNAN || _fpclass(y) == _FPCLASS_SNAN) return false; + else return x >= y; +} + +_LIBCPP_ALWAYS_INLINE bool isless( double x, double y ) +{ + if(_fpclass(x) == _FPCLASS_SNAN || _fpclass(y) == _FPCLASS_SNAN) return false; + else return x < y; +} + +_LIBCPP_ALWAYS_INLINE bool islessequal( double x, double y ) +{ + if(::_fpclass(x) == _FPCLASS_SNAN || ::_fpclass(y) == _FPCLASS_SNAN) return false; + else return x <= y; +} + +_LIBCPP_ALWAYS_INLINE bool islessgreater( double x, double y ) +{ + if(::_fpclass(x) == _FPCLASS_SNAN || ::_fpclass(y) == _FPCLASS_SNAN) return false; + else return x < y || x > y; +} + +_LIBCPP_ALWAYS_INLINE bool isunordered( double x, double y ) +{ + return isnan(x) || isnan(y); +} +_LIBCPP_ALWAYS_INLINE bool signbit( double num ) +{ + switch(_fpclass(num)) + { + case _FPCLASS_SNAN: + case _FPCLASS_QNAN: + case _FPCLASS_NINF: + case _FPCLASS_NN: + case _FPCLASS_ND: + case _FPCLASS_NZ: + return true; + case _FPCLASS_PZ: + case _FPCLASS_PD: + case _FPCLASS_PN: + case _FPCLASS_PINF: + return false; + } + return false; +} +_LIBCPP_ALWAYS_INLINE float copysignf( float x, float y ) +{ + return (signbit (x) != signbit (y) ? - x : x); +} +_LIBCPP_ALWAYS_INLINE double copysign( double x, double y ) +{ + return ::_copysign(x,y); +} +_LIBCPP_ALWAYS_INLINE double copysignl( long double x, long double y ) +{ + return ::_copysignl(x,y); +} +_LIBCPP_ALWAYS_INLINE int fpclassify( double num ) +{ + return _fpclass(num); +} +#endif +#endif // _LIBCPP_MSVCRT + +#endif // _LIBCPP_SUPPORT_WIN32_MATH_WIN32_H diff --git a/include/support/win32/support.h b/include/support/win32/support.h new file mode 100644 index 0000000000000..5765babcd13b5 --- /dev/null +++ b/include/support/win32/support.h @@ -0,0 +1,206 @@ +// -*- C++ -*- +//===----------------------- support/win32/support.h ----------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_SUPPORT_WIN32_SUPPORT_H +#define _LIBCPP_SUPPORT_WIN32_SUPPORT_H + +// Functions and constants used in libc++ that +// are missing from the Windows C library. + +#include <wchar.h> // mbstate_t +#include <cstdarg> // va_ macros +// "builtins" not implemented here for Clang or GCC as they provide +// implementations. Assuming required for elsewhere else, certainly MSVC. +#if defined(_LIBCPP_MSVC) +#include <intrin.h> +#endif +#if defined(_LIBCPP_MSVCRT) +#include <xlocinfo.h> +#endif +#define swprintf _snwprintf +#define vswprintf _vsnwprintf + +#ifndef NOMINMAX +#define NOMINMAX +#endif + +// The mingw headers already define these as static. +#ifndef __MINGW32__ +extern "C" { + +int vasprintf(char **sptr, const char *__restrict fmt, va_list ap); +int asprintf(char **sptr, const char *__restrict fmt, ...); +size_t mbsnrtowcs(wchar_t *__restrict dst, const char **__restrict src, + size_t nmc, size_t len, mbstate_t *__restrict ps); +size_t wcsnrtombs(char *__restrict dst, const wchar_t **__restrict src, + size_t nwc, size_t len, mbstate_t *__restrict ps); +} +#endif // __MINGW32__ + +#if defined(_LIBCPP_MSVCRT) +#define snprintf _snprintf +#define atoll _atoi64 +#define strtoll _strtoi64 +#define strtoull _strtoui64 +#define wcstoll _wcstoi64 +#define wcstoull _wcstoui64 +_LIBCPP_ALWAYS_INLINE float strtof(const char *nptr, char **endptr) +{ + return _Stof(nptr, endptr, 0); +} +_LIBCPP_ALWAYS_INLINE double strtod(const char *nptr, char **endptr) +{ + return _Stod(nptr, endptr, 0); +} +_LIBCPP_ALWAYS_INLINE long double strtold(const char *nptr, char **endptr) +{ + return _Stold(nptr, endptr, 0); +} + +#define _Exit _exit +#endif + +#if defined(_LIBCPP_MSVC) + +// Bit builtin's make these assumptions when calling _BitScanForward/Reverse +// etc. These assumptions are expected to be true for Win32/Win64 which this +// file supports. +static_assert(sizeof(unsigned long long) == 8, ""); +static_assert(sizeof(unsigned long) == 4, ""); +static_assert(sizeof(unsigned int) == 4, ""); + +_LIBCPP_ALWAYS_INLINE int __builtin_popcount(unsigned int x) +{ + // Binary: 0101... + static const unsigned int m1 = 0x55555555; + // Binary: 00110011.. + static const unsigned int m2 = 0x33333333; + // Binary: 4 zeros, 4 ones ... + static const unsigned int m4 = 0x0f0f0f0f; + // The sum of 256 to the power of 0,1,2,3... + static const unsigned int h01 = 0x01010101; + // Put count of each 2 bits into those 2 bits. + x -= (x >> 1) & m1; + // Put count of each 4 bits into those 4 bits. + x = (x & m2) + ((x >> 2) & m2); + // Put count of each 8 bits into those 8 bits. + x = (x + (x >> 4)) & m4; + // Returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24). + return (x * h01) >> 24; +} + +_LIBCPP_ALWAYS_INLINE int __builtin_popcountl(unsigned long x) +{ + return __builtin_popcount(static_cast<int>(x)); +} + +_LIBCPP_ALWAYS_INLINE int __builtin_popcountll(unsigned long long x) +{ + // Binary: 0101... + static const unsigned long long m1 = 0x5555555555555555; + // Binary: 00110011.. + static const unsigned long long m2 = 0x3333333333333333; + // Binary: 4 zeros, 4 ones ... + static const unsigned long long m4 = 0x0f0f0f0f0f0f0f0f; + // The sum of 256 to the power of 0,1,2,3... + static const unsigned long long h01 = 0x0101010101010101; + // Put count of each 2 bits into those 2 bits. + x -= (x >> 1) & m1; + // Put count of each 4 bits into those 4 bits. + x = (x & m2) + ((x >> 2) & m2); + // Put count of each 8 bits into those 8 bits. + x = (x + (x >> 4)) & m4; + // Returns left 8 bits of x + (x<<8) + (x<<16) + (x<<24) + ... + return static_cast<int>((x * h01) >> 56); +} + +// Returns the number of trailing 0-bits in x, starting at the least significant +// bit position. If x is 0, the result is undefined. +_LIBCPP_ALWAYS_INLINE int __builtin_ctzll(unsigned long long mask) +{ + unsigned long where; +// Search from LSB to MSB for first set bit. +// Returns zero if no set bit is found. +#if defined(_WIN64) + if (_BitScanForward64(&where, mask)) + return static_cast<int>(where); +#elif defined(_WIN32) + // Win32 doesn't have _BitScanForward64 so emulate it with two 32 bit calls. + // Scan the Low Word. + if (_BitScanForward(&where, static_cast<unsigned long>(mask))) + return static_cast<int>(where); + // Scan the High Word. + if (_BitScanForward(&where, static_cast<unsigned long>(mask >> 32))) + return static_cast<int>(where + 32); // Create a bit offset from the LSB. +#else +#error "Implementation of __builtin_ctzll required" +#endif + return 64; +} + +_LIBCPP_ALWAYS_INLINE int __builtin_ctzl(unsigned long mask) +{ + unsigned long where; + // Search from LSB to MSB for first set bit. + // Returns zero if no set bit is found. + if (_BitScanForward(&where, mask)) + return static_cast<int>(where); + return 32; +} + +_LIBCPP_ALWAYS_INLINE int __builtin_ctz(unsigned int mask) +{ + // Win32 and Win64 expectations. + static_assert(sizeof(mask) == 4, ""); + static_assert(sizeof(unsigned long) == 4, ""); + return __builtin_ctzl(static_cast<unsigned long>(mask)); +} + +// Returns the number of leading 0-bits in x, starting at the most significant +// bit position. If x is 0, the result is undefined. +_LIBCPP_ALWAYS_INLINE int __builtin_clzll(unsigned long long mask) +{ + unsigned long where; +// BitScanReverse scans from MSB to LSB for first set bit. +// Returns 0 if no set bit is found. +#if defined(_WIN64) + if (_BitScanReverse64(&where, mask)) + return static_cast<int>(63 - where); +#elif defined(_WIN32) + // Scan the high 32 bits. + if (_BitScanReverse(&where, static_cast<unsigned long>(mask >> 32))) + return static_cast<int>(63 - + (where + 32)); // Create a bit offset from the MSB. + // Scan the low 32 bits. + if (_BitScanReverse(&where, static_cast<unsigned long>(mask))) + return static_cast<int>(63 - where); +#else +#error "Implementation of __builtin_clzll required" +#endif + return 64; // Undefined Behavior. +} + +_LIBCPP_ALWAYS_INLINE int __builtin_clzl(unsigned long mask) +{ + unsigned long where; + // Search from LSB to MSB for first set bit. + // Returns zero if no set bit is found. + if (_BitScanReverse(&where, mask)) + return static_cast<int>(31 - where); + return 32; // Undefined Behavior. +} + +_LIBCPP_ALWAYS_INLINE int __builtin_clz(unsigned int x) +{ + return __builtin_clzl(x); +} +#endif // _LIBCPP_MSVC + +#endif // _LIBCPP_SUPPORT_WIN32_SUPPORT_H diff --git a/include/support/xlocale/xlocale.h b/include/support/xlocale/xlocale.h new file mode 100644 index 0000000000000..99f710e8f44ea --- /dev/null +++ b/include/support/xlocale/xlocale.h @@ -0,0 +1,194 @@ +// -*- C++ -*- +//===------------------- support/xlocale/xlocale.h ------------------------===// +// +// The LLVM Compiler Infrastructure +// +// This file is dual licensed under the MIT and the University of Illinois Open +// Source Licenses. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// +// This is a shared implementation of a shim to provide extended locale support +// on top of libc's that don't support it (like Android's bionic, and Newlib). +// +// The 'illusion' only works when the specified locale is "C" or "POSIX", but +// that's about as good as we can do without implementing full xlocale support +// in the underlying libc. +//===----------------------------------------------------------------------===// + +#ifndef _LIBCPP_SUPPORT_XLOCALE_XLOCALE_H +#define _LIBCPP_SUPPORT_XLOCALE_XLOCALE_H + +#ifdef __cplusplus +extern "C" { +#endif + +static inline int isalnum_l(int c, locale_t) { + return isalnum(c); +} + +static inline int isalpha_l(int c, locale_t) { + return isalpha(c); +} + +static inline int isblank_l(int c, locale_t) { + return isblank(c); +} + +static inline int iscntrl_l(int c, locale_t) { + return iscntrl(c); +} + +static inline int isdigit_l(int c, locale_t) { + return isdigit(c); +} + +static inline int isgraph_l(int c, locale_t) { + return isgraph(c); +} + +static inline int islower_l(int c, locale_t) { + return islower(c); +} + +static inline int isprint_l(int c, locale_t) { + return isprint(c); +} + +static inline int ispunct_l(int c, locale_t) { + return ispunct(c); +} + +static inline int isspace_l(int c, locale_t) { + return isspace(c); +} + +static inline int isupper_l(int c, locale_t) { + return isupper(c); +} + +static inline int isxdigit_l(int c, locale_t) { + return isxdigit(c); +} + +static inline int iswalnum_l(wint_t c, locale_t) { + return iswalnum(c); +} + +static inline int iswalpha_l(wint_t c, locale_t) { + return iswalpha(c); +} + +static inline int iswblank_l(wint_t c, locale_t) { + return iswblank(c); +} + +static inline int iswcntrl_l(wint_t c, locale_t) { + return iswcntrl(c); +} + +static inline int iswdigit_l(wint_t c, locale_t) { + return iswdigit(c); +} + +static inline int iswgraph_l(wint_t c, locale_t) { + return iswgraph(c); +} + +static inline int iswlower_l(wint_t c, locale_t) { + return iswlower(c); +} + +static inline int iswprint_l(wint_t c, locale_t) { + return iswprint(c); +} + +static inline int iswpunct_l(wint_t c, locale_t) { + return iswpunct(c); +} + +static inline int iswspace_l(wint_t c, locale_t) { + return iswspace(c); +} + +static inline int iswupper_l(wint_t c, locale_t) { + return iswupper(c); +} + +static inline int iswxdigit_l(wint_t c, locale_t) { + return iswxdigit(c); +} + +static inline int toupper_l(int c, locale_t) { + return toupper(c); +} + +static inline int tolower_l(int c, locale_t) { + return tolower(c); +} + +static inline int towupper_l(int c, locale_t) { + return towupper(c); +} + +static inline int towlower_l(int c, locale_t) { + return towlower(c); +} + +static inline int strcoll_l(const char *s1, const char *s2, locale_t) { + return strcoll(s1, s2); +} + +static inline size_t strxfrm_l(char *dest, const char *src, size_t n, + locale_t) { + return strxfrm(dest, src, n); +} + +static inline size_t strftime_l(char *s, size_t max, const char *format, + const struct tm *tm, locale_t) { + return strftime(s, max, format, tm); +} + +static inline int wcscoll_l(const wchar_t *ws1, const wchar_t *ws2, locale_t) { + return wcscoll(ws1, ws2); +} + +static inline size_t wcsxfrm_l(wchar_t *dest, const wchar_t *src, size_t n, + locale_t) { + return wcsxfrm(dest, src, n); +} + +static inline long double strtold_l(const char *nptr, char **endptr, locale_t) { + return strtold(nptr, endptr); +} + +static inline long long strtoll_l(const char *nptr, char **endptr, int base, + locale_t) { + return strtoll(nptr, endptr, base); +} + +static inline unsigned long long strtoull_l(const char *nptr, char **endptr, + int base, locale_t) { + return strtoull(nptr, endptr, base); +} + +static inline long long wcstoll_l(const wchar_t *nptr, wchar_t **endptr, + int base, locale_t) { + return wcstoll(nptr, endptr, base); +} + +static inline unsigned long long wcstoull_l(const wchar_t *nptr, + wchar_t **endptr, int base, + locale_t) { + return wcstoull(nptr, endptr, base); +} + +static inline long double wcstold_l(const wchar_t *nptr, wchar_t **endptr, + locale_t) { + return wcstold(nptr, endptr); +} + +#ifdef __cplusplus +} +#endif + +#endif // _LIBCPP_SUPPORT_XLOCALE_XLOCALE_H |