X-Git-Url: https://git.draconx.ca/gitweb/cdecl99.git/blobdiff_plain/ad973d63e038f293f2b158f19b04c1582e616af0..898aa30bfb038ffeca54d6dea95f0f80fbc08f7f:/src/error.c diff --git a/src/error.c b/src/error.c index 9a91e4e..eb85b89 100644 --- a/src/error.c +++ b/src/error.c @@ -1,6 +1,6 @@ /* * Error handling for libcdecl. - * Copyright © 2011-2012, 2021 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,18 +19,62 @@ #include #include #include -#include #include -#include - -#include -#include +#include #include "cdecl.h" #include "cdecl-internal.h" +#include "errmsg.h" + +/* This pre-initialized error is reserved for dire out-of-memory conditions. */ +static struct cdecl_error err_no_mem; + +static void set_err(unsigned code, struct cdecl_error *err) +{ + static const char errmsgs[] = STRTAB_INITIALIZER; + + switch (code) { + case CDECL__ENOMEM: + err->code = CDECL_ENOMEM; + break; + default: + err->code = CDECL_ENOPARSE; + break; + } + + err->str = _(&errmsgs[code]); +} + +static void init_once_cb(void) +{ +#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; +} -gl_once_define(static, tls_initialized); -static gl_tls_key_t tls_key; +#endif struct err_state { struct cdecl_error err; @@ -38,99 +82,132 @@ struct err_state { char str[FLEXIBLE_ARRAY_MEMBER]; }; -/* This error is reserved for extremely dire out-of-memory conditions. */ -static struct err_state err_no_mem = { - .err = { - .code = CDECL_ENOMEM, - .str = NULL, - }, -}; - -static void free_err(void *err) +static void *alloc_err_state(void *old, size_t buf_size) { - if (err == &err_no_mem) - return; + struct err_state *state; + void *p; + + 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; + } - free(err); + return p; } -static void initialize(void) +static struct err_state *get_err_state(void) { - cdecl__init_i18n(); - err_no_mem.err.str = _("failed to allocate memory"); + void *state; - gl_tls_key_init(tls_key, free_err); + if (!init_once()) + return NULL; + + if (!(state = tls_get())) + return alloc_err_state(state, 100); + return state; } + +#if ENABLE_NLS /* - * cdecl__err(CDECL_ENOMEM); - * cdecl__err(code, fmt, ...); - * - * Sets the library error to code, with a printf-style error string. + * Initialize gettext indirectly via get_err_state. */ -void cdecl__err(unsigned code, ...) +void cdecl__init_i18n(void) +{ + get_err_state(); +} +#endif + +/* + * Set the library error to one of the preset messages defined in errmsg.h + * (CDECL__Exxx). + */ +void cdecl__errmsg(unsigned msg) { - const char *fmt; struct err_state *state; - int rc, try = 0; - va_list ap; - gl_once(tls_initialized, initialize); + state = get_err_state(); + if (!state) + return; - state = gl_tls_get(tls_key); - if (!state || state == &err_no_mem) { - void *tmp = malloc(sizeof *state + 100); + set_err(msg, &state->err); +} - if (!tmp) { - state = &err_no_mem; - return; - } +/* + * 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 +} - gl_tls_set(tls_key, (state = tmp)); - state->nstr = 100; - } +/* + * 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; - if (code == CDECL_ENOMEM) { - if (state != &err_no_mem) - state->err = err_no_mem.err; + 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); - - if (rc > 0 && rc >= state->nstr) { - void *tmp; - size_t n; - - assert(try == 0 && rc < SIZE_MAX / 4); - n = ((size_t)rc + 1) * 2; - tmp = realloc(state, sizeof *state + n); - if (tmp) { - state = tmp; - state->nstr = n; - try++; +retry: + rc = fmt_err(state, fmt, arg); + if (rc >= state->nstr) { + assert(try++ == 0 && rc < (size_t)-1 / 4); - goto retry; - } + state = alloc_err_state(state, (size_t)(rc+1u) * 3 / 2); + if (!state) + return; - state->err = err_no_mem.err; - return; + 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; - - gl_once(tls_initialized, initialize); + struct err_state *state = get_err_state(); - state = gl_tls_get(tls_key); - return state ? &state->err : NULL; + return state ? &state->err : &err_no_mem; }