From: Szabolcs Nagy <nsz@port70.net>
To: musl@lists.openwall.com
Subject: C11 api coverage
Date: Tue, 4 Sep 2012 22:38:37 +0200 [thread overview]
Message-ID: <20120904203837.GX1104@port70.net> (raw)
[-- Attachment #1: Type: text/plain, Size: 263 bytes --]
based on annex B (library summary) i created a diff
between the symbols of c99 and c11 to help the c11
implementation effort once we get there
(format is [+-]symbol,prototype,header separated by tabs)
the c11 api coverage table is linked from
wiki.musl-libc.org
[-- Attachment #2: c11.diff --]
[-- Type: text/x-diff, Size: 15175 bytes --]
+static_assert assert.h
+CMPLX double complex CMPLX(double x, double y); complex.h
+CMPLXF float complex CMPLXF(float x, float y); complex.h
+CMPLXL long double complex CMPLXL(long double x, long double y); complex.h
+errno_t errno.h
+DBL_DECIMAL_DIG float.h
+DBL_HAS_SUBNORM float.h
+DBL_TRUE_MIN float.h
+FLT_DECIMAL_DIG float.h
+FLT_HAS_SUBNORM float.h
+FLT_TRUE_MIN float.h
+LDBL_DECIMAL_DIG float.h
+LDBL_HAS_SUBNORM float.h
+LDBL_TRUE_MIN float.h
-longjmp void longjmp(jmp_buf env, int val); setjmp.h
+longjmp _Noreturn void longjmp(jmp_buf env, int val); setjmp.h
+__alignas_is_defined stdalign.h
+alignas stdalign.h
+ATOMIC_BOOL_LOCK_FREE stdatomic.h
+ATOMIC_CHAR16_T_LOCK_FREE stdatomic.h
+ATOMIC_CHAR32_T_LOCK_FREE stdatomic.h
+ATOMIC_CHAR_LOCK_FREE stdatomic.h
+ATOMIC_FLAG_INIT stdatomic.h
+ATOMIC_INT_LOCK_FREE stdatomic.h
+ATOMIC_LLONG_LOCK_FREE stdatomic.h
+ATOMIC_LONG_LOCK_FREE stdatomic.h
+ATOMIC_POINTER_LOCK_FREE stdatomic.h
+ATOMIC_SHORT_LOCK_FREE stdatomic.h
+ATOMIC_VAR_INIT ATOMIC_VAR_INIT(C value) stdatomic.h
+ATOMIC_WCHAR_T_LOCK_FREE stdatomic.h
+atomic_bool stdatomic.h
+atomic_char stdatomic.h
+atomic_char16_t stdatomic.h
+atomic_char32_t stdatomic.h
+atomic_compare_exchange_strong _Bool atomic_compare_exchange_strong(volatile A *object, C *expected, C desired); stdatomic.h
+atomic_compare_exchange_strong_explicit _Bool atomic_compare_exchange_strong_explicit(volatile A *object, C *expected, C desired, memory_order success, memory_order failure); stdatomic.h
+atomic_compare_exchange_weak _Bool atomic_compare_exchange_weak(volatile A *object, C *expected, C desired); stdatomic.h
+atomic_compare_exchange_weak_explicit _Bool atomic_compare_exchange_weak_explicit(volatile A *object, C *expected, C desired, memory_order success, memory_order failure); stdatomic.h
+atomic_exchange C atomic_exchange(volatile A *object, C desired); stdatomic.h
+atomic_exchange_explicit C atomic_exchange_explicit(volatile A *object, C desired, memory_order order); stdatomic.h
+atomic_fetch_key C atomic_fetch_key(volatile A *object, M operand); stdatomic.h
+atomic_fetch_key_explicit C atomic_fetch_key_explicit(volatile A *object, M operand, memory_order order); stdatomic.h
+atomic_flag stdatomic.h
+atomic_flag_clear void atomic_flag_clear(volatile atomic_flag *object); stdatomic.h
+atomic_flag_clear_explicit void atomic_flag_clear_explicit(volatile atomic_flag *object, memory_order order); stdatomic.h
+atomic_flag_test_and_set _Bool atomic_flag_test_and_set(volatile atomic_flag *object); stdatomic.h
+atomic_flag_test_and_set_explicit _Bool atomic_flag_test_and_set_explicit(volatile atomic_flag *object, memory_order order); stdatomic.h
+atomic_init void atomic_init(volatile A *obj, C value); stdatomic.h
+atomic_int stdatomic.h
+atomic_int_fast16_t stdatomic.h
+atomic_int_fast32_t stdatomic.h
+atomic_int_fast64_t stdatomic.h
+atomic_int_fast8_t stdatomic.h
+atomic_int_least16_t stdatomic.h
+atomic_int_least32_t stdatomic.h
+atomic_int_least64_t stdatomic.h
+atomic_int_least8_t stdatomic.h
+atomic_intmax_t stdatomic.h
+atomic_intptr_t stdatomic.h
+atomic_is_lock_free _Bool atomic_is_lock_free(const volatile A *obj); stdatomic.h
+atomic_llong stdatomic.h
+atomic_load C atomic_load(volatile A *object); stdatomic.h
+atomic_load_explicit C atomic_load_explicit(volatile A *object, memory_order order); stdatomic.h
+atomic_long stdatomic.h
+atomic_ptrdiff_t stdatomic.h
+atomic_schar stdatomic.h
+atomic_short stdatomic.h
+atomic_signal_fence void atomic_signal_fence(memory_order order); stdatomic.h
+atomic_size_t stdatomic.h
+atomic_store void atomic_store(volatile A *object, C desired); stdatomic.h
+atomic_store_explicit void atomic_store_explicit(volatile A *object, C desired, memory_order order); stdatomic.h
+atomic_thread_fence void atomic_thread_fence(memory_order order); stdatomic.h
+atomic_uchar stdatomic.h
+atomic_uint stdatomic.h
+atomic_uint_fast16_t stdatomic.h
+atomic_uint_fast32_t stdatomic.h
+atomic_uint_fast64_t stdatomic.h
+atomic_uint_fast8_t stdatomic.h
+atomic_uint_least16_t stdatomic.h
+atomic_uint_least32_t stdatomic.h
+atomic_uint_least64_t stdatomic.h
+atomic_uint_least8_t stdatomic.h
+atomic_uintmax_t stdatomic.h
+atomic_uintptr_t stdatomic.h
+atomic_ullong stdatomic.h
+atomic_ulong stdatomic.h
+atomic_ushort stdatomic.h
+atomic_wchar_t stdatomic.h
+kill_dependency type kill_dependency(type y); stdatomic.h
+memory_order stdatomic.h
+memory_order_acq_rel stdatomic.h
+memory_order_acquire stdatomic.h
+memory_order_consume stdatomic.h
+memory_order_relaxed stdatomic.h
+memory_order_release stdatomic.h
+memory_order_seq_cst stdatomic.h
+max_align_t stddef.h
+rsize_t stddef.h
+RSIZE_MAX stdint.h
+L_tmpnam_s stdio.h
+TMP_MAX_S stdio.h
+errno_t stdio.h
+fopen_s errno_t fopen_s(FILE * restrict * restrict streamptr, const char * restrict filename, const char * restrict mode); stdio.h
+fprintf_s int fprintf_s(FILE * restrict stream, const char * restrict format, ...); stdio.h
+freopen_s errno_t freopen_s(FILE * restrict * restrict newstreamptr, const char * restrict filename, const char * restrict mode, FILE * restrict stream); stdio.h
+fscanf_s int fscanf_s(FILE * restrict stream, const char * restrict format, ...); stdio.h
-gets char *gets(char *s); stdio.h
+gets_s char *gets_s(char *s, rsize_t n); stdio.h
+printf_s int printf_s(const char * restrict format, ...); stdio.h
+rsize_t stdio.h
+scanf_s int scanf_s(const char * restrict format, ...); stdio.h
+snprintf_s int snprintf_s(char * restrict s, rsize_t n, const char * restrict format, ...); stdio.h
+sprintf_s int sprintf_s(char * restrict s, rsize_t n, const char * restrict format, ...); stdio.h
+sscanf_s int sscanf_s(const char * restrict s, const char * restrict format, ...); stdio.h
+tmpfile_s errno_t tmpfile_s(FILE * restrict * restrict streamptr); stdio.h
+tmpnam_s errno_t tmpnam_s(char *s, rsize_t maxsize); stdio.h
+vfprintf_s int vfprintf_s(FILE * restrict stream, const char * restrict format, va_list arg); stdio.h
+vfscanf_s int vfscanf_s(FILE * restrict stream, const char * restrict format, va_list arg); stdio.h
+vprintf_s int vprintf_s(const char * restrict format, va_list arg); stdio.h
+vscanf_s int vscanf_s(const char * restrict format, va_list arg); stdio.h
+vsnprintf_s int vsnprintf_s(char * restrict s, rsize_t n, const char * restrict format, va_list arg); stdio.h
+vsprintf_s int vsprintf_s(char * restrict s, rsize_t n, const char * restrict format, va_list arg); stdio.h
+vsscanf_s int vsscanf_s(const char * restrict s, const char * restrict format, va_list arg); stdio.h
-_Exit void _Exit(int status); stdlib.h
-abort void abort(void); stdlib.h
+_Exit _Noreturn void _Exit(int status); stdlib.h
+abort _Noreturn void abort(void); stdlib.h
+abort_handler_s void abort_handler_s(const char * restrict msg, void * restrict ptr, errno_t error); stdlib.h
+aligned_alloc void *aligned_alloc(size_t alignment, size_t size); stdlib.h
+at_quick_exit int at_quick_exit(void (*func)(void)); stdlib.h
+bsearch_s 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); stdlib.h
+constraint_handler_t stdlib.h
-exit void exit(int status); stdlib.h
+errno_t stdlib.h
+exit _Noreturn void exit(int status); stdlib.h
+getenv_s errno_t getenv_s(size_t * restrict len, char * restrict value, rsize_t maxsize, const char * restrict name); stdlib.h
+ignore_handler_s void ignore_handler_s(const char * restrict msg, void * restrict ptr, errno_t error); stdlib.h
+mbstowcs_s errno_t mbstowcs_s(size_t * restrict retval, wchar_t * restrict dst, rsize_t dstmax, const char * restrict src, rsize_t len); stdlib.h
+qsort_s errno_t qsort_s(void *base, rsize_t nmemb, rsize_t size, int (*compar)(const void *x, const void *y, void *context), void *context); stdlib.h
+quick_exit _Noreturn void quick_exit(int status); stdlib.h
+rsize_t stdlib.h
+set_constraint_handler_s constraint_handler_t set_constraint_handler_s(constraint_handler_t handler); stdlib.h
+wcstombs_s errno_t wcstombs_s(size_t * restrict retval, char * restrict dst, rsize_t dstmax, const wchar_t * restrict src, rsize_t len); stdlib.h
+wctomb_s errno_t wctomb_s(int * restrict status, char * restrict s, rsize_t smax, wchar_t wc); stdlib.h
+noreturn stdnoreturn.h
+errno_t string.h
+memcpy_s errno_t memcpy_s(void * restrict s1, rsize_t s1max, const void * restrict s2, rsize_t n); string.h
+memmove_s errno_t memmove_s(void *s1, rsize_t s1max, const void *s2, rsize_t n); string.h
+memset_s errno_t memset_s(void *s, rsize_t smax, int c, rsize_t n) string.h
+rsize_t string.h
+strcat_s errno_t strcat_s(char * restrict s1, rsize_t s1max, const char * restrict s2); string.h
+strcpy_s errno_t strcpy_s(char * restrict s1, rsize_t s1max, const char * restrict s2); string.h
+strerror_s errno_t strerror_s(char *s, rsize_t maxsize, errno_t errnum); string.h
+strerrorlen_s size_t strerrorlen_s(errno_t errnum); string.h
+strncat_s errno_t strncat_s(char * restrict s1, rsize_t s1max, const char * restrict s2, rsize_t n); string.h
+strncpy_s errno_t strncpy_s(char * restrict s1, rsize_t s1max, const char * restrict s2, rsize_t n); string.h
+strnlen_s size_t strnlen_s(const char *s, size_t maxsize); string.h
+strtok_s char *strtok_s(char * restrict s1, rsize_t * restrict s1max, const char * restrict s2, char ** restrict ptr); string.h
+ONCE_FLAG_INIT threads.h
+TSS_DTOR_ITERATIONS threads.h
+call_once void call_once(once_flag *flag, void (*func)(void)); threads.h
+cnd_broadcast int cnd_broadcast(cnd_t *cond); threads.h
+cnd_destroy void cnd_destroy(cnd_t *cond); threads.h
+cnd_init int cnd_init(cnd_t *cond); threads.h
+cnd_signal int cnd_signal(cnd_t *cond); threads.h
+cnd_t threads.h
+cnd_timedwait int cnd_timedwait(cnd_t *restrict cond, mtx_t *restrict mtx, const struct timespec *restrict ts); threads.h
+cnd_wait int cnd_wait(cnd_t *cond, mtx_t *mtx); threads.h
+mtx_destroy void mtx_destroy(mtx_t *mtx); threads.h
+mtx_init int mtx_init(mtx_t *mtx, int type); threads.h
+mtx_lock int mtx_lock(mtx_t *mtx); threads.h
+mtx_plain threads.h
+mtx_recursive threads.h
+mtx_t threads.h
+mtx_timed threads.h
+mtx_timedlock int mtx_timedlock(mtx_t *restrict mtx, const struct timespec *restrict ts); threads.h
+mtx_trylock int mtx_trylock(mtx_t *mtx); threads.h
+mtx_unlock int mtx_unlock(mtx_t *mtx); threads.h
+once_flag threads.h
+thrd_busy threads.h
+thrd_create int thrd_create(thrd_t *thr, thrd_start_t func, void *arg); threads.h
+thrd_current thrd_t thrd_current(void); threads.h
+thrd_detach int thrd_detach(thrd_t thr); threads.h
+thrd_equal int thrd_equal(thrd_t thr0, thrd_t thr1); threads.h
+thrd_error threads.h
+thrd_exit _Noreturn void thrd_exit(int res); threads.h
+thrd_join int thrd_join(thrd_t thr, int *res); threads.h
+thrd_nomem threads.h
+thrd_sleep int thrd_sleep(const struct timespec *duration, struct timespec *remaining); threads.h
+thrd_start_t threads.h
+thrd_success threads.h
+thrd_t threads.h
+thrd_timedout threads.h
+thrd_yield void thrd_yield(void); threads.h
+thread_local threads.h
+tss_create int tss_create(tss_t *key, tss_dtor_t dtor); threads.h
+tss_delete void tss_delete(tss_t key); threads.h
+tss_dtor_t threads.h
+tss_get void *tss_get(tss_t key); threads.h
+tss_set int tss_set(tss_t key, void *val); threads.h
+tss_t threads.h
+TIME_UTC time.h
+asctime_s errno_t asctime_s(char *s, rsize_t maxsize, const struct tm *timeptr); time.h
+ctime_s errno_t ctime_s(char *s, rsize_t maxsize, const time_t *timer); time.h
+errno_t time.h
+gmtime_s struct tm *gmtime_s(const time_t * restrict timer, struct tm * restrict result); time.h
+localtime_s struct tm *localtime_s(const time_t * restrict timer, struct tm * restrict result); time.h
+rsize_t time.h
+struct timespec time.h
+timespec_get int timespec_get(timespec *ts, int base); time.h
+c16rtomb size_t c16rtomb(char * restrict s, char16_t c16, mbstate_t * restrict ps); uchar.h
+c32rtomb size_t c32rtomb(char * restrict s, char32_t c32, mbstate_t * restrict ps); uchar.h
+char16_t uchar.h
+char32_t uchar.h
+mbrtoc16 size_t mbrtoc16(char16_t * restrict pc16, const char * restrict s, size_t n, mbstate_t * restrict ps); uchar.h
+mbrtoc32 size_t mbrtoc32(char32_t * restrict pc32, const char * restrict s, size_t n, mbstate_t * restrict ps); uchar.h
+mbstate_t uchar.h
+size_t uchar.h
+errno_t wchar.h
+fwprintf_s int fwprintf_s(FILE * restrict stream, const wchar_t * restrict format, ...); wchar.h
+fwscanf_s int fwscanf_s(FILE * restrict stream, const wchar_t * restrict format, ...); wchar.h
+mbsrtowcs_s 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); wchar.h
+rsize_t wchar.h
+snwprintf_s int snwprintf_s(wchar_t * restrict s, rsize_t n, const wchar_t * restrict format, ...); wchar.h
+swprintf_s int swprintf_s(wchar_t * restrict s, rsize_t n, const wchar_t * restrict format, ...); wchar.h
+swscanf_s int swscanf_s(const wchar_t * restrict s, const wchar_t * restrict format, ...); wchar.h
+vfwprintf_s int vfwprintf_s(FILE * restrict stream, const wchar_t * restrict format, va_list arg); wchar.h
+vfwscanf_s int vfwscanf_s(FILE * restrict stream, const wchar_t * restrict format, va_list arg); wchar.h
+vsnwprintf_s int vsnwprintf_s(wchar_t * restrict s, rsize_t n, const wchar_t * restrict format, va_list arg); wchar.h
+vswprintf_s int vswprintf_s(wchar_t * restrict s, rsize_t n, const wchar_t * restrict format, va_list arg); wchar.h
+vswscanf_s int vswscanf_s(const wchar_t * restrict s, const wchar_t * restrict format, va_list arg); wchar.h
+vwprintf_s int vwprintf_s(const wchar_t * restrict format, va_list arg); wchar.h
+vwscanf_s int vwscanf_s(const wchar_t * restrict format, va_list arg); wchar.h
+wcrtomb_s errno_t wcrtomb_s(size_t * restrict retval, char * restrict s, rsize_t smax, wchar_t wc, mbstate_t * restrict ps); wchar.h
+wcscat_s errno_t wcscat_s(wchar_t * restrict s1, rsize_t s1max, const wchar_t * restrict s2); wchar.h
+wcscpy_s errno_t wcscpy_s(wchar_t * restrict s1, rsize_t s1max, const wchar_t * restrict s2); wchar.h
+wcsncat_s errno_t wcsncat_s(wchar_t * restrict s1, rsize_t s1max, const wchar_t * restrict s2, rsize_t n); wchar.h
+wcsncpy_s errno_t wcsncpy_s(wchar_t * restrict s1, rsize_t s1max, const wchar_t * restrict s2, rsize_t n); wchar.h
+wcsnlen_s size_t wcsnlen_s(const wchar_t *s, size_t maxsize); wchar.h
+wcsrtombs_s 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); wchar.h
+wcstok_s wchar_t *wcstok_s(wchar_t * restrict s1, rsize_t * restrict s1max, const wchar_t * restrict s2, wchar_t ** restrict ptr); wchar.h
+wmemcpy_s errno_t wmemcpy_s(wchar_t * restrict s1, rsize_t s1max, const wchar_t * restrict s2, rsize_t n); wchar.h
+wmemmove_s errno_t wmemmove_s(wchar_t *s1, rsize_t s1max, const wchar_t *s2, rsize_t n); wchar.h
+wprintf_s int wprintf_s(const wchar_t * restrict format, ...); wchar.h
+wscanf_s int wscanf_s(const wchar_t * restrict format, ...); wchar.h
next reply other threads:[~2012-09-04 20:38 UTC|newest]
Thread overview: 5+ messages / expand[flat|nested] mbox.gz Atom feed top
2012-09-04 20:38 Szabolcs Nagy [this message]
2012-09-05 6:22 ` Rich Felker
2012-09-05 6:40 ` Szabolcs Nagy
2012-09-07 18:47 ` Isaac Dunham
2012-09-07 21:17 ` Rich Felker
Reply instructions:
You may reply publicly to this message via plain-text email
using any one of the following methods:
* Save the following mbox file, import it into your mail client,
and reply-to-all from there: mbox
Avoid top-posting and favor interleaved quoting:
https://en.wikipedia.org/wiki/Posting_style#Interleaved_style
* Reply using the --to, --cc, and --in-reply-to
switches of git-send-email(1):
git send-email \
--in-reply-to=20120904203837.GX1104@port70.net \
--to=nsz@port70.net \
--cc=musl@lists.openwall.com \
/path/to/YOUR_REPLY
https://kernel.org/pub/software/scm/git/docs/git-send-email.html
* If your mail client supports setting the In-Reply-To header
via mailto: links, try the mailto: link
Be sure your reply has a Subject: header at the top and a blank line
before the message body.
Code repositories for project(s) associated with this public inbox
https://git.vuxu.org/mirror/musl/
This is a public inbox, see mirroring instructions
for how to clone and mirror all data and code used for this inbox;
as well as URLs for NNTP newsgroup(s).