C11 Compatibility Summary

Fuchsia's libc supports the functions listed in Appendix B of the C11 standard as documented below.

B.1 Diagnostics <assert.h>

Function	Supported
void assert(scalar expression);	Yes

B.2 Complex <complex.h>

Function	Supported
double complex cacos(double complex z);	Yes
float complex cacosf(float complex z);	Yes
long double complex cacosl(long double complex z);	Yes
double complex casin(double complex z);	Yes
float complex casinf(float complex z);	Yes
long double complex casinl(long double complex z);	Yes
double complex catan(double complex z);	Yes
float complex catanf(float complex z);	Yes
long double complex catanl(long double complex z);	Yes
double complex ccos(double complex z);	Yes
float complex ccosf(float complex z);	Yes
long double complex ccosl(long double complex z);	Yes
double complex csin(double complex z);	Yes
float complex csinf(float complex z);	Yes
long double complex csinl(long double complex z);	Yes
double complex ctan(double complex z);	Yes
float complex ctanf(float complex z);	Yes
long double complex ctanl(long double complex z);	Yes
double complex cacosh(double complex z);	Yes
float complex cacoshf(float complex z);	Yes
long double complex cacoshl(long double complex z);	Yes
double complex casinh(double complex z);	Yes
float complex casinhf(float complex z);	Yes
long double complex casinhl(long double complex z);	Yes
double complex catanh(double complex z);	Yes
float complex catanhf(float complex z);	Yes
long double complex catanhl(long double complex z);	Yes
double complex ccosh(double complex z);	Yes
float complex ccoshf(float complex z);	Yes
long double complex ccoshl(long double complex z);	Yes
double complex csinh(double complex z);	Yes
float complex csinhf(float complex z);	Yes
long double complex csinhl(long double complex z);	Yes
double complex ctanh(double complex z);	Yes
float complex ctanhf(float complex z);	Yes
long double complex ctanhl(long double complex z);	Yes
double complex cexp(double complex z);	Yes
float complex cexpf(float complex z);	Yes
long double complex cexpl(long double complex z);	Yes
double complex clog(double complex z);	Yes
float complex clogf(float complex z);	Yes
long double complex clogl(long double complex z);	Yes
double cabs(double complex z);	Yes
float cabsf(float complex z);	Yes
long double cabsl(long double complex z);	Yes
double complex cpow(double complex x, double complex y);	Yes
float complex cpowf(float complex x, float complex y);	Yes
long double complex cpowl(long double complex x, long double complex y);	Yes
double complex csqrt(double complex z);	Yes
float complex csqrtf(float complex z);	Yes
long double complex csqrtl(long double complex z);	Yes
double carg(double complex z);	Yes
float cargf(float complex z);	Yes
long double cargl(long double complex z);	Yes
double cimag(double complex z);	Yes
float cimagf(float complex z);	Yes
long double cimagl(long double complex z);	Yes
double complex CMPLX(double x, double y);	No
float complex CMPLXF(float x, float y);	No
long double complex CMPLXL(long double x, long double y);	No
double complex conj(double complex z);	Yes
float complex conjf(float complex z);	Yes
long double complex conjl(long double complex z);	Yes
double complex cproj(double complex z);	Yes
float complex cprojf(float complex z);	Yes
long double complex cprojl(long double complex z);	Yes
double creal(double complex z);	Yes
float crealf(float complex z);	Yes
long double creall(long double complex z);	Yes

B.3 Character handling <ctype.h>

Function	Supported
int isalnum(int c);	Yes
int isalpha(int c);	Yes
int isblank(int c);	Yes
int iscntrl(int c);	Yes
int isdigit(int c);	Yes
int isgraph(int c);	Yes
int islower(int c);	Yes
int isprint(int c);	Yes
int ispunct(int c);	Yes
int isspace(int c);	Yes
int isupper(int c);	Yes
int isxdigit(int c);	Yes
int tolower(int c);	Yes
int toupper(int c);	Yes

B.4 Errors <errno.h>

Function	Supported

B.5 Floating-point environment <fenv.h>

Function	Supported
int feclearexcept(int excepts);	No
int fegetexceptflag(fexcept_t *flagp, int excepts);	No
int feraiseexcept(int excepts);	No
int fesetexceptflag(const fexcept_t *flagp, int excepts);	No
int fetestexcept(int excepts);	No
int fegetround(void);	Yes
int fesetround(int round);	Yes
int fegetenv(fenv_t *envp);	No
int feholdexcept(fenv_t *envp);	No
int fesetenv(const fenv_t *envp);	No
int feupdateenv(const fenv_t *envp);	No

B.6 Characteristics of floating types <float.h>

Function	Supported

B.7 Format conversion of integer types <inttypes.h>

Function	Supported
intmax_t imaxabs(intmax_t j);	Yes
imaxdiv_t imaxdiv(intmax_t numer, intmax_t denom);	No
intmax_t strtoimax(const char * restrict nptr, char ** restrict endptr, int base);	Yes
uintmax_t strtoumax(const char * restrict nptr, char ** restrict endptr, int base);	Yes
intmax_t wcstoimax(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base);	No
uintmax_t wcstoumax(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base);	No

B.8 Alternative spellings <iso646.h>

Function	Supported

B.9 Sizes of integer types <limits.h>

Function	Supported

B.10 Localization <locale.h>

Function	Supported
char *setlocale(int category, const char *locale);	Yes
struct lconv *localeconv(void);	Yes

B.11 Mathematics <math.h>

Function	Supported
int fpclassify(real-floating x);	Yes
int isfinite(real-floating x);	Yes
int isinf(real-floating x);	Yes
int isnan(real-floating x);	Yes
int isnormal(real-floating x);	Yes
int signbit(real-floating x);	Yes
double acos(double x);	Yes
float acosf(float x);	Yes
long double acosl(long double x);	Yes
double asin(double x);	Yes
float asinf(float x);	Yes
long double asinl(long double x);	Yes
double atan(double x);	Yes
float atanf(float x);	Yes
long double atanl(long double x);	Yes
double atan2(double y, double x);	Yes
float atan2f(float y, float x);	Yes
long double atan2l(long double y, long double x);	Yes
double cos(double x);	Yes
float cosf(float x);	Yes
long double cosl(long double x);	Yes
double sin(double x);	Yes
float sinf(float x);	Yes
long double sinl(long double x);	Yes
double tan(double x);	Yes
float tanf(float x);	Yes
long double tanl(long double x);	Yes
double acosh(double x);	Yes
float acoshf(float x);	Yes
long double acoshl(long double x);	Yes
double asinh(double x);	Yes
float asinhf(float x);	Yes
long double asinhl(long double x);	Yes
double atanh(double x);	Yes
float atanhf(float x);	Yes
long double atanhl(long double x);	Yes
double cosh(double x);	Yes
float coshf(float x);	Yes
long double coshl(long double x);	Yes
double sinh(double x);	Yes
float sinhf(float x);	Yes
long double sinhl(long double x);	Yes
double tanh(double x);	Yes
float tanhf(float x);	Yes
long double tanhl(long double x);	Yes
double exp(double x);	Yes
float expf(float x);	Yes
long double expl(long double x);	Yes
double exp2(double x);	Yes
float exp2f(float x);	Yes
long double exp2l(long double x);	Yes
double expm1(double x);	Yes
float expm1f(float x);	Yes
long double expm1l(long double x);	Yes
double frexp(double value, int *exp);	Yes
float frexpf(float value, int *exp);	Yes
long double frexpl(long double value, int *exp);	Yes
int ilogb(double x);	Yes
int ilogbf(float x);	Yes
int ilogbl(long double x);	Yes
double ldexp(double x, int exp);	Yes
float ldexpf(float x, int exp);	Yes
long double ldexpl(long double x, int exp);	Yes
double log(double x);	Yes
float logf(float x);	Yes
long double logl(long double x);	Yes
double log10(double x);	Yes
float log10f(float x);	Yes
long double log10l(long double x);	Yes
double log1p(double x);	Yes
float log1pf(float x);	Yes
long double log1pl(long double x);	Yes
double log2(double x);	Yes
float log2f(float x);	Yes
long double log2l(long double x);	Yes
double logb(double x);	Yes
float logbf(float x);	Yes
long double logbl(long double x);	Yes
double modf(double value, double *iptr);	Yes
float modff(float value, float *iptr);	Yes
long double modfl(long double value, long double *iptr);	Yes
double scalbn(double x, int n);	Yes
float scalbnf(float x, int n);	Yes
long double scalbnl(long double x, int n);	Yes
double scalbln(double x, long int n);	Yes
float scalblnf(float x, long int float cbrtf(float x);	Yes
long double cbrtl(long double x);	Yes
double fabs(double x);	Yes
float fabsf(float x);	Yes
long double fabsl(long double x);	Yes
double hypot(double x, double y);	Yes
float hypotf(float x, float y);	Yes
long double hypotl(long double x, long double y);	Yes
double pow(double x, double y);	Yes
float powf(float x, float y);	Yes
long double powl(long double x, long double y);	Yes
double sqrt(double x);	Yes
float sqrtf(float x);	Yes
long double sqrtl(long double x);	Yes
double erf(double x);	Yes
float erff(float x);	Yes
long double erfl(long double x);	Yes
double erfc(double x);	Yes
float erfcf(float x);	Yes
long double erfcl(long double x);	Yes
double lgamma(double x);	Yes
float lgammaf(float x);	Yes
long double lgammal(long double x);	Yes
double tgamma(double x);	Yes
float tgammaf(float x);	Yes
long double tgammal(long double x);	Yes
double ceil(double x);	Yes
float ceilf(float x);	Yes
long double ceill(long double x);	Yes
double floor(double x);	Yes
float floorf(float x);	Yes
long double floorl(long double x);	Yes
double nearbyint(double x);	Yes
float nearbyintf(float x);	Yes
long double nearbyintl(long double x);	Yes
double rint(double x);	Yes
float rintf(float x);	Yes
long double rintl(long double x);	Yes
long int lrint(double x);	Yes
long int lrintf(float x);	Yes
long int lrintl(long double x);	Yes
long long int llrint(double x);	Yes
long long int llrintf(float x);	Yes
long long int llrintl(long double x);	Yes
double round(double x);	Yes
float roundf(float x);	Yes
long double roundl(long double x);	Yes
long int lround(double x);	Yes
long int lroundf(float x);	Yes
long int lroundl(long double x);	Yes
long long int llround(double x);	Yes
long long int llroundf(float x);	Yes
long long int llroundl(long double x);	Yes
double trunc(double x);	Yes
float truncf(float x);	Yes
long double truncl(long double x);	Yes
double fmod(double x, double y);	Yes
float fmodf(float x, float y);	Yes
long double fmodl(long double x, long double y);	Yes
double remainder(double x, double y);	Yes
float remainderf(float x, float y);	Yes
long double remainderl(long double x, long double y);	Yes
double remquo(double x, double y, int *quo);	Yes
float remquof(float x, float y, int *quo);	Yes
long double remquol(long double x, long double y, int *quo);	Yes
double copysign(double x, double y);	Yes
float copysignf(float x, float y);	Yes
long double copysignl(long double x, long double y);	Yes
double nan(const char *tagp);	Yes
float nanf(const char *tagp);	Yes
long double nanl(const char *tagp);	Yes
double nextafter(double x, double y);	Yes
float nextafterf(float x, float y);	Yes
long double nextafterl(long double x, long double y);	Yes
double nexttoward(double x, long double y);	Yes
float nexttowardf(float x, long double y);	Yes
long double nexttowardl(long double x, long double y);	Yes
double fdim(double x, double y);	Yes
float fdimf(float x, float y);	Yes
long double fdiml(long double x, long double y);	Yes
double fmax(double x, double y);	Yes
float fmaxf(float x, float y);	Yes
long double fmaxl(long double x, long double y);	Yes
double fmin(double x, double y);	Yes
float fminf(float x, float y);	Yes
long double fminl(long double x, long double y);	Yes
double fma(double x, double y, double z);	Yes
float fmaf(float x, float y, float z);	Yes
long double fmal(long double x, long double y, long double z);	Yes
int isgreater(real-floating x, real-floating y);	Yes
int isgreaterequal(real-floating x, real-floating y);	Yes
int isless(real-floating x, real-floating y);	Yes
int islessequal(real-floating x, real-floating y);	Yes
int islessgreater(real-floating x, real-floating y);	Yes
int isunordered(real-floating x, real-floating y);	Yes

B.12 Nonlocal jumps <setjmp.h>

Function	Supported
int setjmp(jmp_buf env);	Yes
_Noreturn void longjmp(jmp_buf env, int val);	Yes

B.13 Signal handling <signal.h>

Function	Supported
void (*signal(int sig, void (*func)(int)))(int);	Yes
int raise(int sig);	Yes

B.14 Alignment <stdalign.h>

Function	Supported

B.15 Variable arguments <stdarg.h>

Function	Supported
type va_arg(va_list ap, type);	Yes
void va_copy(va_list dest, va_list src);	Yes
void va_end(va_list ap);	Yes
void va_start(va_list ap, parmN);	Yes

B.16 Atomics <stdatomic.h>

Function	Supported
void atomic_init(volatile A *obj, C value);	Yes
type kill_dependency(type y);	Yes
void atomic_thread_fence(memory_order order);	Yes
void atomic_signal_fence(memory_order order);	Yes
_Bool atomic_is_lock_free(const volatile A *obj);	Yes
void atomic_store(volatile A *object, C desired);	Yes
void atomic_store_explicit(volatile A *object, C desired, memory_order order);	Yes
C atomic_load(volatile A *object);	Yes
C atomic_load_explicit(volatile A *object, memory_order order);	Yes
C atomic_exchange(volatile A *object, C desired);	Yes
C atomic_exchange_explicit(volatile A *object, C desired, memory_order order);	Yes
_Bool atomic_compare_exchange_strong(volatile A *object, C *expected, C desired);	Yes
_Bool atomic_compare_exchange_strong_explicit(volatile A *object, C *expected, C desired, memory_order success, memory_order failure);	Yes
_Bool atomic_compare_exchange_weak(volatile A *object, C *expected, C desired);	Yes
_Bool atomic_compare_exchange_weak_explicit(volatile A *object, C *expected, C desired, memory_order success, memory_order failure);	Yes
C atomic_fetch_key(volatile A *object, M operand);	Yes
C atomic_fetch_key_explicit(volatile A *object, M operand, memory_order order);	Yes
_Bool atomic_flag_test_and_set(volatile atomic_flag *object);	Yes
_Bool atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order);	Yes
void atomic_flag_clear(volatile atomic_flag *object);	Yes
void atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order);	Yes

B.17 Boolean type and values <stdbool.h>

Function	Supported

B.18 Common definitions <stddef.h>

Function	Supported

B.19 Integer types <stdint.h>

Function	Supported

B.20 Input/output <stdio.h>

Function	Supported
int remove(const char *filename);	Yes
int rename(const char *old, const char *new);	Yes
FILE *tmpfile(void);	Yes
char *tmpnam(char *s);	Yes
int fclose(FILE *stream);	Yes
int fflush(FILE *stream);	Yes
FILE *fopen(const char * restrict filename, const char * restrict mode);	Yes
FILE *freopen(const char * restrict filename, const char * restrict mode, FILE * restrict stream);	Yes
void setbuf(FILE * restrict stream, char * restrict buf);	Yes
int setvbuf(FILE * restrict stream, char * restrict buf, int mode, size_t size);	Yes
int fprintf(FILE * restrict stream, const char * restrict format, ...);	Yes
int fscanf(FILE * restrict stream, const char * restrict format, ...);	Yes
int printf(const char * restrict format, ...);	Yes
int scanf(const char * restrict format, ...);	Yes
int snprintf(char * restrict s, size_t n, const char * restrict format, ...);	Yes
int sprintf(char * restrict s, const char * restrict format, ...);	Yes
int sscanf(const char * restrict s, const char * restrict format, ...);	Yes
int vfprintf(FILE * restrict stream, const char * restrict format, va_list arg);	Yes
int vfscanf(FILE * restrict stream, const char * restrict format, va_list arg);	No
int vprintf(const char * restrict format, va_list arg);	Yes
int vscanf(const char * restrict format, va_list arg);	No
int vsnprintf(char * restrict s, size_t n, const char * restrict format, va_list arg);	Yes
int vsprintf(char * restrict s, const char * restrict format, va_list arg);	Yes
int vsscanf(const char * restrict s, const char * restrict format, va_list arg);	Yes
int fgetc(FILE *stream);	Yes
char *fgets(char * restrict s, int n, FILE * restrict stream);	Yes
int fputc(int c, FILE *stream);	Yes
int fputs(const char * restrict s, FILE * restrict stream);	Yes
int getc(FILE *stream);	Yes
int getchar(void);	Yes
int putc(int c, FILE *stream);	Yes
int putchar(int c);	Yes
int puts(const char *s);	Yes
int ungetc(int c, FILE *stream);	Yes
size_t fread(void * restrict ptr, size_t size, size_t nmemb, FILE * restrict stream);	Yes
size_t fwrite(const void * restrict ptr, size_t size, size_t nmemb, FILE * restrict stream);	Yes
int fgetpos(FILE * restrict stream, fpos_t * restrict pos);	No
int fseek(FILE *stream, long int offset, int whence);	Yes
int fsetpos(FILE *stream, const fpos_t *pos);	No
long int ftell(FILE *stream);	Yes
void rewind(FILE *stream);	Yes
void clearerr(FILE *stream);	Yes
int feof(FILE *stream);	Yes
int ferror(FILE *stream);	Yes
void perror(const char *s);	Yes
errno_t tmpfile_s(FILE * restrict * restrict streamptr);	No
errno_t tmpnam_s(char *s, rsize_t maxsize);	No
errno_t fopen_s(FILE * restrict * restrict streamptr, const char * restrict filename, const char * restrict mode);	No
errno_t freopen_s(FILE * restrict * restrict newstreamptr, const char * restrict filename, const char * restrict mode, FILE * restrict stream);	No
int fprintf_s(FILE * restrict stream, const char * restrict format, ...);	No
int fscanf_s(FILE * restrict stream, const char * restrict format, ...);	No
int printf_s(const char * restrict format, ...);	No
int scanf_s(const char * restrict format, ...);	No
int snprintf_s(char * restrict s, rsize_t n, const char * restrict format, ...);	No
int sprintf_s(char * restrict s, rsize_t n, const char * restrict format, ...);	No
int sscanf_s(const char * restrict s, const char * restrict format, ...);	No
int vfprintf_s(FILE * restrict stream, const char * restrict format, va_list arg);	No
int vfscanf_s(FILE * restrict stream, const char * restrict format, va_list arg);	No
int vprintf_s(const char * restrict format, va_list arg);	No
int vscanf_s(const char * restrict format, va_list arg);	No
int vsnprintf_s(char * restrict s, rsize_t n, const char * restrict format, va_list arg);	No
int vsprintf_s(char * restrict s, rsize_t n, const char * restrict format, va_list arg);	No
int vsscanf_s(const char * restrict s, const char * restrict format, va_list arg);	No
char *gets_s(char *s, rsize_t n);	No

B.21 General utilities <stdlib.h>

Function	Supported
double atof(const char *nptr);	Yes
int atoi(const char *nptr);	Yes
long int atol(const char *nptr);	Yes
long long int atoll(const char *nptr);	Yes
double strtod(const char * restrict nptr, char ** restrict endptr);	Yes
float strtof(const char * restrict nptr, char ** restrict endptr);	Yes
long double strtold(const char * restrict nptr, char ** restrict endptr);	Yes
long int strtol(const char * restrict nptr, char ** restrict endptr, int base);	Yes
long long int strtoll(const char * restrict nptr, char ** restrict endptr, int base);	Yes
unsigned long int strtoul(const char * restrict nptr, char ** restrict endptr, int base);	Yes
unsigned long long int strtoull(const char * restrict nptr, char ** restrict endptr, int base);	Yes
int rand(void);	Yes
void srand(unsigned int seed);	Yes
void *aligned_alloc(size_t alignment, size_t size);	Yes
void *calloc(size_t nmemb, size_t size);	Yes
void free(void *ptr);	Yes
void *malloc(size_t size);	Yes
void *realloc(void *ptr, size_t size);	Yes
_Noreturn void abort(void);	Yes
int atexit(void (*func)(void));	Yes
int at_quick_exit(void (*func)(void));	No
_Noreturn void exit(int status);	Yes
_Noreturn void _Exit(int status);	No
char *getenv(const char *name);	Yes
_Noreturn void quick_exit(int status);	No
int system(const char *string);	Yes
void *bsearch(const void *key, const void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));	Yes
void qsort(void *base, size_t nmemb, size_t size, int (*compar)(const void *, const void *));	Yes
int abs(int j);	Yes
long int labs(long int j);	Yes
long long int llabs(long long int j);	Yes
div_t div(int numer, int denom);	Yes
ldiv_t ldiv(long int numer, long int denom);	Yes
lldiv_t lldiv(long long int numer, long long int denom);	Yes
int mblen(const char *s, size_t n);	Yes
int mbtowc(wchar_t * restrict pwc, const char * restrict s, size_t n);	Yes
int wctomb(char *s, wchar_t wchar);	Yes
size_t mbstowcs(wchar_t * restrict pwcs, const char * restrict s, size_t n);	Yes
size_t wcstombs(char * restrict s, const wchar_t * restrict pwcs, size_t n);	Yes
constraint_handler_t set_constraint_handler_s(constraint_handler_t handler);	No
void abort_handler_s(const char * restrict msg, void * restrict ptr, errno_t error);	No
void ignore_handler_s(const char * restrict msg, void * restrict ptr, errno_t error);	No
errno_t getenv_s(size_t * restrict len, char * restrict value, rsize_t maxsize, const char * restrict name);	No
void *bsearch_s(const void *key, const void *base, rsize_t nmemb, rsize_t size, int (*compar)(const void *k, const void *y, void *context), void *context);	No
errno_t qsort_s(void *base, rsize_t nmemb, rsize_t size, int (*compar)(const void *x, const void *y, void *context), void *context);	No
errno_t wctomb_s(int * restrict status, char * restrict s, rsize_t smax, wchar_t wc);	No
errno_t mbstowcs_s(size_t * restrict retval, wchar_t * restrict dst, rsize_t dstmax, const char * restrict src, rsize_t len);	No
errno_t wcstombs_s(size_t * restrict retval, char * restrict dst, rsize_t dstmax, const wchar_t * restrict src, rsize_t len);	No

B.22 _Noreturn <stdnoreturn.h>

Function	Supported

B.23 String handling <string.h>

Function	Supported
void *memcpy(void * restrict s1, const void * restrict s2, size_t n);	Yes
void *memmove(void *s1, const void *s2, size_t n);	Yes
char *strcpy(char * restrict s1, const char * restrict s2);	Yes
char *strncpy(char * restrict s1, const char * restrict s2, size_t n);	Yes
char *strcat(char * restrict s1, const char * restrict s2);	Yes
char *strncat(char * restrict s1, const char * restrict s2, size_t n);	Yes
int memcmp(const void *s1, const void *s2, size_t n);	Yes
int strcmp(const char *s1, const char *s2);	Yes
int strcoll(const char *s1, const char *s2);	Yes
int strncmp(const char *s1, const char *s2, size_t n);	Yes
size_t strxfrm(char * restrict s1, const char * restrict s2, size_t n);	Yes
void *memchr(const void *s, int c, size_t n);	Yes
char *strchr(const char *s, int c);	Yes
size_t strcspn(const char *s1, const char *s2);	Yes
char *strpbrk(const char *s1, const char *s2);	Yes
char *strrchr(const char *s, int c);	Yes
size_t strspn(const char *s1, const char *s2);	Yes
char *strstr(const char *s1, const char *s2);	Yes
char *strtok(char * restrict s1, const char * restrict s2);	Yes
void *memset(void *s, int c, size_t n);	Yes
char *strerror(int errnum);	Yes
size_t strlen(const char *s);	Yes
errno_t memcpy_s(void * restrict s1, rsize_t s1max, const void * restrict s2, rsize_t n);	No
errno_t memmove_s(void *s1, rsize_t s1max, const void *s2, rsize_t n);	No
errno_t strcpy_s(char * restrict s1, rsize_t s1max, const char * restrict s2);	No
errno_t strncpy_s(char * restrict s1, rsize_t s1max, const char * restrict s2, rsize_t n);	No
errno_t strcat_s(char * restrict s1, rsize_t s1max, const char * restrict s2);	No
errno_t strncat_s(char * restrict s1, rsize_t s1max, const char * restrict s2, rsize_t n);	No
char *strtok_s(char * restrict s1, rsize_t * restrict s1max, const char * restrict s2, char ** restrict ptr);	No
errno_t memset_s(void *s, rsize_t smax, int c, rsize_t n);	No
errno_t strerror_s(char *s, rsize_t maxsize, errno_t errnum);	No
size_t strerrorlen_s(errno_t errnum);	No
size_t strnlen_s(const char *s, size_t maxsize);	No

B.24 Type-generic math <tgmath.h>

Function	Supported

B.25 Threads <threads.h>

Function	Supported
void call_once(once_flag *flag, void (*func)(void));	No
int cnd_broadcast(cnd_t *cond);	Yes
void cnd_destroy(cnd_t *cond);	Yes
int cnd_init(cnd_t *cond);	Yes
int cnd_signal(cnd_t *cond);	Yes
int cnd_timedwait(cnd_t *restrict cond, mtx_t *restrict mtx, const struct timespec *restrict ts);	Yes
int cnd_wait(cnd_t *cond, mtx_t *mtx);	Yes
void mtx_destroy(mtx_t *mtx);	Yes
int mtx_init(mtx_t *mtx, int type);	Yes
int mtx_lock(mtx_t *mtx);	Yes
int mtx_timedlock(mtx_t *restrict mtx, const struct timespec *restrict ts);	Yes
int mtx_trylock(mtx_t *mtx);	Yes
int mtx_unlock(mtx_t *mtx);	Yes
int thrd_create(thrd_t *thr, thrd_start_t func, void *arg);	Yes
thrd_t thrd_current(void);	Yes
int thrd_detach(thrd_t thr);	Yes
int thrd_equal(thrd_t thr0, thrd_t thr1);	No
_Noreturn void thrd_exit(int res);	No
int thrd_join(thrd_t thr, int *res);	Yes
int thrd_sleep(const struct timespec *duration, struct timespec *remaining);	No
void thrd_yield(void);	Yes
int tss_create(tss_t *key, tss_dtor_t dtor);	No
void tss_delete(tss_t key);	No
void *tss_get(tss_t key);	No
int tss_set(tss_t key, void *val);	No

B.26 Date and time <time.h>

Function	Supported
clock_t clock(void);	Yes
double difftime(time_t time1, time_t time0);	Yes
time_t mktime(struct tm *timeptr);	Yes
time_t time(time_t *timer);	Yes
int timespec_get(timespec *ts, int base);	Yes
char *asctime(const struct tm *timeptr);	No
char *ctime(const time_t *timer);	Yes
struct tm *gmtime(const time_t *timer);	Yes
struct tm *localtime(const time_t *timer);	Yes
size_t strftime(char * restrict s, size_t maxsize, const char * restrict format, const struct tm * restrict timeptr);	Yes
errno_t asctime_s(char *s, rsize_t maxsize, const struct tm *timeptr);	No
errno_t ctime_s(char *s, rsize_t maxsize, const time_t *timer);	No
struct tm *gmtime_s(const time_t * restrict timer, struct tm * restrict result);	No
struct tm *localtime_s(const time_t * restrict timer, struct tm * restrict result);	No

B.27 Unicode utilities <uchar.h>

Function	Supported
size_t mbrtoc16(char16_t * restrict pc16, const char * restrict s, size_t n, mbstate_t * restrict ps);	No
size_t c16rtomb(char * restrict s, char16_t c16, mbstate_t * restrict ps);	No
size_t mbrtoc32(char32_t * restrict pc32, const char * restrict s, size_t n, mbstate_t * restrict ps);	No
size_t c32rtomb(char * restrict s, char32_t c32, mbstate_t * restrict ps);	No

B.28 Extended multibyte/wide character utilities <wchar.h>

Function	Supported
int fwprintf(FILE * restrict stream, const wchar_t * restrict format, ...);	No
int fwscanf(FILE * restrict stream, const wchar_t * restrict format, ...);	No
int swprintf(wchar_t * restrict s, size_t n, const wchar_t * restrict format, ...);	Yes
int swscanf(const wchar_t * restrict s, const wchar_t * restrict format, ...);	No
int vfwprintf(FILE * restrict stream, const wchar_t * restrict format, va_list arg);	No
int vfwscanf(FILE * restrict stream, const wchar_t * restrict format, va_list arg);	No
int vswprintf(wchar_t * restrict s, size_t n, const wchar_t * restrict format, va_list arg);	No
int vswscanf(const wchar_t * restrict s, const wchar_t * restrict format, va_list arg);	No
int vwprintf(const wchar_t * restrict format, va_list arg);	No
int vwscanf(const wchar_t * restrict format, va_list arg);	No
int wprintf(const wchar_t * restrict format, ...);	No
int wscanf(const wchar_t * restrict format, ...);	No
wint_t fgetwc(FILE *stream);	Yes
wchar_t *fgetws(wchar_t * restrict s, int n, FILE * restrict stream);	No
wint_t fputwc(wchar_t c, FILE *stream);	No
int fputws(const wchar_t * restrict s, FILE * restrict stream);	No
int fwide(FILE *stream, int mode);	No
wint_t getwc(FILE *stream);	No
wint_t getwchar(void);	No
wint_t putwc(wchar_t c, FILE *stream);	No
wint_t putwchar(wchar_t c);	No
wint_t ungetwc(wint_t c, FILE *stream);	No
double wcstod(const wchar_t * restrict nptr, wchar_t ** restrict endptr);	Yes
float wcstof(const wchar_t * restrict nptr, wchar_t ** restrict endptr);	Yes
long double wcstold(const wchar_t * restrict nptr, wchar_t ** restrict endptr);	Yes
long int wcstol(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base);	Yes
long long int wcstoll(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base);	Yes
unsigned long int wcstoul(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base);	Yes
unsigned long long int wcstoull(const wchar_t * restrict nptr, wchar_t ** restrict endptr, int base);	Yes
wchar_t *wcscpy(wchar_t * restrict s1, const wchar_t * restrict s2);	Yes
wchar_t *wcsncpy(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n);	Yes
wchar_t *wmemcpy(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n);	Yes
wchar_t *wmemmove(wchar_t *s1, const wchar_t *s2, size_t n);	Yes
wchar_t *wcscat(wchar_t * restrict s1, const wchar_t * restrict s2);	Yes
wchar_t *wcsncat(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n);	Yes
int wcscmp(const wchar_t *s1, const wchar_t *s2);	Yes
int wcscoll(const wchar_t *s1, const wchar_t *s2);	Yes
int wcsncmp(const wchar_t *s1, const wchar_t *s2, size_t n);	Yes
size_t wcsxfrm(wchar_t * restrict s1, const wchar_t * restrict s2, size_t n);	Yes
int wmemcmp(const wchar_t *s1, const wchar_t *s2, size_t n);	Yes
wchar_t *wcschr(const wchar_t *s, wchar_t c);	Yes
size_t wcscspn(const wchar_t *s1, const wchar_t *s2);	Yes
wchar_t *wcspbrk(const wchar_t *s1, const wchar_t *s2);	Yes
wchar_t *wcsrchr(const wchar_t *s, wchar_t c);	Yes
size_t wcsspn(const wchar_t *s1, const wchar_t *s2);	Yes
wchar_t *wcsstr(const wchar_t *s1, const wchar_t *s2);	Yes
wchar_t *wcstok(wchar_t * restrict s1, const wchar_t * restrict s2, wchar_t ** restrict ptr);	Yes
wchar_t *wmemchr(const wchar_t *s, wchar_t c, size_t n);	Yes
size_t wcslen(const wchar_t *s);	Yes
wchar_t *wmemset(wchar_t *s, wchar_t c, size_t n);	Yes
size_t wcsftime(wchar_t * restrict s, size_t maxsize, const wchar_t * restrict format, const struct tm * restrict timeptr);	No
wint_t btowc(int c);	Yes
int wctob(wint_t c);	Yes
int mbsinit(const mbstate_t *ps);	Yes
size_t mbrlen(const char * restrict s, size_t n, mbstate_t * restrict ps);	Yes
size_t mbrtowc(wchar_t * restrict pwc, const char * restrict s, size_t n, mbstate_t * restrict ps);	Yes
size_t wcrtomb(char * restrict s, wchar_t wc, mbstate_t * restrict ps);	Yes
size_t mbsrtowcs(wchar_t * restrict dst, const char ** restrict src, size_t len, mbstate_t * restrict ps);	Yes
size_t wcsrtombs(char * restrict dst, const wchar_t ** restrict src, size_t len, mbstate_t * restrict ps);	Yes
int fwprintf_s(FILE * restrict stream, const wchar_t * restrict format, ...);	No
int fwscanf_s(FILE * restrict stream, const wchar_t * restrict format, ...);	No
int snwprintf_s(wchar_t * restrict s, rsize_t n, const wchar_t * restrict format, ...);	No
int swprintf_s(wchar_t * restrict s, rsize_t n, const wchar_t * restrict format, ...);	No
int swscanf_s(const wchar_t * restrict s, const wchar_t * restrict format, ...);	No
int vfwprintf_s(FILE * restrict stream, const wchar_t * restrict format, va_list arg);	No
int vfwscanf_s(FILE * restrict stream, const wchar_t * restrict format, va_list arg);	No
int vsnwprintf_s(wchar_t * restrict s, rsize_t n, const wchar_t * restrict format, va_list arg);	No
int vswprintf_s(wchar_t * restrict s, rsize_t n, const wchar_t * restrict format, va_list arg);	No
int vswscanf_s(const wchar_t * restrict s, const wchar_t * restrict format, va_list arg);	No
int vwprintf_s(const wchar_t * restrict format, va_list arg);	No
int vwscanf_s(const wchar_t * restrict format, va_list arg);	No
int wprintf_s(const wchar_t * restrict format, ...);	No
int wscanf_s(const wchar_t * restrict format, ...);	No
errno_t wcscpy_s(wchar_t * restrict s1, rsize_t s1max, const wchar_t * restrict s2);	No
errno_t wcsncpy_s(wchar_t * restrict s1, rsize_t s1max, const wchar_t * restrict s2, rsize_t n);	No
errno_t wmemcpy_s(wchar_t * restrict s1, rsize_t s1max, const wchar_t * restrict s2, rsize_t n);	No
errno_t wmemmove_s(wchar_t *s1, rsize_t s1max, const wchar_t *s2, rsize_t n);	No
errno_t wcscat_s(wchar_t * restrict s1, rsize_t s1max, const wchar_t * restrict s2);	No
errno_t wcsncat_s(wchar_t * restrict s1, rsize_t s1max, const wchar_t * restrict s2, rsize_t n);	No
wchar_t *wcstok_s(wchar_t * restrict s1, rsize_t * restrict s1max, const wchar_t * restrict s2, wchar_t ** restrict ptr);	No
size_t wcsnlen_s(const wchar_t *s, size_t maxsize);	No
errno_t wcrtomb_s(size_t * restrict retval, char * restrict s, rsize_t smax, wchar_t wc, mbstate_t * restrict ps);	No
errno_t mbsrtowcs_s(size_t * restrict retval, wchar_t * restrict dst, rsize_t dstmax, const char ** restrict src, rsize_t len, mbstate_t * restrict ps);	No
errno_t wcsrtombs_s(size_t * restrict retval, char * restrict dst, rsize_t dstmax, const wchar_t ** restrict src, rsize_t len, mbstate_t * restrict ps);	No

B.29 Wide character classification and mapping utilities <wctype.h>

Function	Supported
int iswalnum(wint_t wc);	No
int iswalpha(wint_t wc);	Yes
int iswblank(wint_t wc);	Yes
int iswcntrl(wint_t wc);	Yes
int iswdigit(wint_t wc);	Yes
int iswgraph(wint_t wc);	No
int iswlower(wint_t wc);	Yes
int iswprint(wint_t wc);	Yes
int iswpunct(wint_t wc);	Yes
int iswspace(wint_t wc);	Yes
int iswupper(wint_t wc);	Yes
int iswxdigit(wint_t wc);	Yes
int iswctype(wint_t wc, wctype_t desc);	No
wctype_t wctype(const char *property);	No
wint_t towlower(wint_t wc);	Yes
wint_t towupper(wint_t wc);	Yes
wint_t towctrans(wint_t wc, wctrans_t desc);	No
wctrans_t wctrans(const char *property);	No