X-Git-Url: https://git.draconx.ca/gitweb/cdecl99.git/blobdiff_plain/9abf0eb2e74d0fb3a4f652499571cb35697d3036..4c819e9466a0573afae0f9787a4704a479517624:/src/error.c diff --git a/src/error.c b/src/error.c index 8b9f04e..e07a410 100644 --- a/src/error.c +++ b/src/error.c @@ -1,6 +1,6 @@ /* * Error handling for libcdecl. - * Copyright © 2011-2012, 2021, 2023 Nick Bowler + * Copyright © 2011-2012, 2021, 2023-2024 Nick Bowler * * This program is free software: you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -19,43 +19,69 @@ #include #include #include -#include #include -#include +#include #include "cdecl.h" #include "cdecl-internal.h" - -#include -#include - -gl_once_define(static, tls_initialized); -static gl_tls_key_t tls_key; - -struct err_state { - struct cdecl_error err; - size_t nstr; - char str[FLEXIBLE_ARRAY_MEMBER]; -}; +#include "errmsg.h" /* This pre-initialized error is reserved for dire out-of-memory conditions. */ static struct cdecl_error err_no_mem; -static void free_err(void *err) +static void set_err(unsigned code, struct cdecl_error *err) { - if (err == &err_no_mem) - return; + static const char _Alignas(1) errmsgs[] = STRTAB_INITIALIZER; + + switch (code) { + case CDECL__ENOMEM: + err->code = CDECL_ENOMEM; + break; + default: + err->code = CDECL_ENOPARSE; + break; + } - free(err); + err->str = _(&errmsgs[code]); } -static void initialize(void) +static void init_once_cb(void) { - cdecl__init_i18n(); - err_no_mem.str = _("failed to allocate memory"); - gl_tls_key_init(tls_key, free_err); +#if ENABLE_NLS + bindtextdomain(PACKAGE, LOCALEDIR); + bindtextdomain("bison-runtime", BISON_LOCALEDIR); +#endif + set_err(CDECL__ENOMEM, &err_no_mem); } +#if USE_POSIX_THREADS +# include "thread-posix.h" +#elif USE_ISOC_THREADS || USE_ISOC_AND_POSIX_THREADS +# include "thread-stdc.h" +#elif USE_WINDOWS_THREADS +# include "thread-w32.h" +#else +static void *tls_key; +enum { tls_key_valid = 1 }; + +#define tls_get() tls_key +#define tls_set(a) ((tls_key = (a)), 1) + +static int init_once(void) +{ + if (!err_no_mem.code) + init_once_cb(); + return 1; +} + +#endif + +struct err_state { + struct cdecl_error err; + size_t nstr; + char str[FLEXIBLE_ARRAY_MEMBER]; +}; + static void *alloc_err_state(void *old, size_t buf_size) { struct err_state *state; @@ -64,62 +90,110 @@ static void *alloc_err_state(void *old, size_t buf_size) state = p = realloc(old, offsetof(struct err_state, str) + buf_size); if (state) { state->nstr = buf_size; + if (!tls_set(state)) { + /* + * We have to presume that pthread_setspecific etc. + * cannot fail after the key has been successfully + * assigned once, because there seems to be no + * reasonable recovery from such a scenario. + */ + free(p); + p = NULL; + } } else if (old) { /* Failed allocation, but existing state is still good */ p = old; - } else { - /* Failed allocation, no existing state */ - p = &err_no_mem; } - gl_tls_set(tls_key, p); - return state; + return p; } static struct err_state *get_err_state(void) { void *state; - gl_once(tls_initialized, initialize); + if (!init_once()) + return NULL; - state = gl_tls_get(tls_key); - if (state == &err_no_mem) - state = NULL; - if (!state) + if (!(state = tls_get())) return alloc_err_state(state, 100); return state; } + +#if ENABLE_NLS +/* + * Initialize gettext indirectly via get_err_state. + */ +void cdecl__init_i18n(void) +{ + get_err_state(); +} +#endif + /* - * cdecl__err(CDECL_ENOMEM); - * cdecl__err(code, fmt, ...); - * - * Sets the library error to code, with a printf-style error string. + * Set the library error to one of the preset messages defined in errmsg.h + * (CDECL__Exxx). */ -void cdecl__err(unsigned code, ...) +void cdecl__errmsg(unsigned msg) { - const char *fmt; struct err_state *state; - int rc, try = 0; - va_list ap; state = get_err_state(); if (!state) return; - if (code == CDECL_ENOMEM) { - state->err.code = code; - state->err.str = err_no_mem.str; + set_err(msg, &state->err); +} + +/* + * In the NLS-disabled case, all format strings are of the form + * + * "blah blah %s" + * + * so we exploit this to implement a simple snprintf workalike using the + * libcdecl output helpers directly. + * + * In the NLS-enabled case, we have to use snprintf as format strings may + * be translated. GNU libintl ensures a suitable version is available. + */ +static size_t +fmt_err(struct err_state *state, const char *fmt, const char *arg) +{ +#if ENABLE_NLS + snprintf(state->str, state->nstr, fmt, arg); + return strlen(fmt) + strlen(arg); +#else + struct output_state dst = { state->str, state->nstr }; + size_t rc; + + rc = cdecl__strlcpy(dst.dst, fmt, dst.dstlen); + cdecl__advance(&dst, rc-2); + cdecl__emit(&dst, arg); + + return dst.accum; +#endif +} + +/* + * Sets the library error to code; fmt is a printf-style string that may use + * up to one %s directive, to refer to arg. + */ +void cdecl__err(const char *fmt, const char *arg) +{ + struct err_state *state; + unsigned try = 0; + size_t rc; + + state = get_err_state(); + if (!state) return; - } + retry: - va_start(ap, code); - fmt = va_arg(ap, const char *); - rc = vsnprintf(state->str, state->nstr, fmt, ap); - va_end(ap); + rc = fmt_err(state, fmt, arg); + if (rc >= state->nstr) { + assert(try++ == 0 && rc < (size_t)-1 / 4); - if (rc > 0 && rc >= state->nstr) { - assert(try++ == 0 && rc < SIZE_MAX / 4); state = alloc_err_state(state, (size_t)(rc+1u) * 3 / 2); if (!state) return; @@ -127,13 +201,13 @@ retry: goto retry; } + state->err.code = CDECL_ENOPARSE; state->err.str = state->str; - state->err.code = code; } const struct cdecl_error *cdecl_get_error(void) { struct err_state *state = get_err_state(); - return state ? &state->err : NULL; + return state ? &state->err : &err_no_mem; }