Skip to content

Commit

Permalink
SDL_error: simplified error string management.
Browse files Browse the repository at this point in the history 
This patch removes deferred error string formatting: now we do it during
SDL_SetError(), so there's no limit on printf-style arguments used.

Also removes stub for managing error string translations; we don't have the
facilities to maintain that and the way we set arbitrary error strings
doesn't really make this practical anyhow.

Since the final error string is set right away and unique to the thread,
we no longer need a static buffer for legacy SDL_GetError(), and we don't
have to allocate 5x 128-byte argument fields per-thread. Also, since we now
use SDL_vsnprintf instead of parsing the format string ourselves, there's a
lot of code deleted and we have access to more robust formatting powers now.

This does mean the final error strings can't be more than 128 bytes, down
from the theoretical maximum of around 768, but I think this is probably okay.
They might truncate but they will always be null-terminated!

Fixes Bugzilla #5092.
  • Loading branch information
@icculus
icculus committed Apr 21, 2020
1 parent 67760f0 commit 09ca66b
Show file tree
Hide file tree
Showing 2 changed files with 22 additions and 231 deletions.
227 changes: 20 additions & 207 deletions src/SDL_error.c
View file
Expand Up @@ -27,117 +27,41 @@

#define SDL_ERRBUFIZE 1024

/* Private functions */

static const char *
SDL_LookupString(const char *key)
{
/* FIXME: Add code to lookup key in language string hash-table */
return key;
}

/* Public functions */

int
SDL_SetError(SDL_PRINTF_FORMAT_STRING const char *fmt, ...)
{
va_list ap;
SDL_error *error;

/* Ignore call if invalid format pointer was passed */
if (fmt == NULL) return -1;
if (fmt != NULL) {
va_list ap;
SDL_error *error = SDL_GetErrBuf();

/* Copy in the key, mark error as valid */
error = SDL_GetErrBuf();
error->error = 1;
SDL_strlcpy((char *) error->key, fmt, sizeof(error->key));
error->error = 1; /* mark error as valid */

va_start(ap, fmt);
error->argc = 0;
while (*fmt) {
if (*fmt++ == '%') {
while (*fmt == '.' || (*fmt >= '0' && *fmt <= '9')) {
++fmt;
}
switch (*fmt++) {
case 0: /* Malformed format string.. */
--fmt;
break;
case 'l':
switch (*fmt++) {
case 0: /* Malformed format string.. */
--fmt;
break;
case 'i': case 'd': case 'u': case 'x': case 'X':
error->args[error->argc++].value_l = va_arg(ap, long);
break;
}
break;
case 'c':
case 'i':
case 'd':
case 'u':
case 'o':
case 'x':
case 'X':
error->args[error->argc++].value_i = va_arg(ap, int);
break;
case 'f':
error->args[error->argc++].value_f = va_arg(ap, double);
break;
case 'p':
error->args[error->argc++].value_ptr = va_arg(ap, void *);
break;
case 's':
{
int i = error->argc;
const char *str = va_arg(ap, const char *);
if (str == NULL)
str = "(null)";
SDL_strlcpy((char *) error->args[i].buf, str,
ERR_MAX_STRLEN);
error->argc++;
}
break;
default:
break;
}
if (error->argc >= ERR_MAX_ARGS) {
break;
}
va_start(ap, fmt);
SDL_vsnprintf(error->str, ERR_MAX_STRLEN, fmt, ap);
va_end(ap);

if (SDL_LogGetPriority(SDL_LOG_CATEGORY_ERROR) <= SDL_LOG_PRIORITY_DEBUG) {
/* If we are in debug mode, print out the error message */
SDL_LogDebug(SDL_LOG_CATEGORY_ERROR, "%s", error->str);
}
}
va_end(ap);

if (SDL_LogGetPriority(SDL_LOG_CATEGORY_ERROR) <= SDL_LOG_PRIORITY_DEBUG) {
/* If we are in debug mode, print out an error message
* Avoid stomping on the static buffer in GetError, just
* in case this is called while processing a ShowMessageBox to
* show an error already in that static buffer.
*/
char errmsg[SDL_ERRBUFIZE];
SDL_GetErrorMsg(errmsg, sizeof(errmsg));
SDL_LogDebug(SDL_LOG_CATEGORY_ERROR, "%s", errmsg);
}
return -1;
}

/* Available for backwards compatibility */
const char *
SDL_GetError(void)
{
static char errmsg[SDL_ERRBUFIZE];

return SDL_GetErrorMsg(errmsg, SDL_ERRBUFIZE);
const SDL_error *error = SDL_GetErrBuf();
return error->error ? error->str : "";
}

void
SDL_ClearError(void)
{
SDL_error *error;

error = SDL_GetErrBuf();
error->error = 0;
SDL_GetErrBuf()->error = 0;
}

/* Very common errors go here */
Expand Down Expand Up @@ -178,129 +102,18 @@ main(int argc, char *argv[])
#endif


/* keep this at the end of the file so it works with GCC builds that don't
support "#pragma GCC diagnostic push" ... we'll just leave the warning
disabled after this. */
/* this pragma arrived in GCC 4.2 and causes a warning on older GCCs! Sigh. */
#if defined(__clang__) || (defined(__GNUC__) && ((__GNUC__ > 4) || (__GNUC__ == 4 && (__GNUC_MINOR__ >= 2))))
#pragma GCC diagnostic ignored "-Wformat-nonliteral"
#endif

/* This function has a bit more overhead than most error functions
so that it supports internationalization and thread-safe errors.
*/
char *
SDL_GetErrorMsg(char *errstr, int maxlen)
{
SDL_error *error;

/* Clear the error string */
*errstr = '\0';
--maxlen;
const SDL_error *error = SDL_GetErrBuf();

/* Get the thread-safe error, and print it out */
error = SDL_GetErrBuf();
if (error->error) {
const char *fmt;
char *msg = errstr;
int len;
int argi;

fmt = SDL_LookupString(error->key);
argi = 0;
while (*fmt && (maxlen > 0)) {
if (*fmt == '%') {
char tmp[32], *spot = tmp;
*spot++ = *fmt++;
while ((*fmt == '.' || (*fmt >= '0' && *fmt <= '9'))
&& spot < (tmp + SDL_arraysize(tmp) - 2)) {
*spot++ = *fmt++;
}
if (*fmt == 'l') {
*spot++ = *fmt++;
*spot++ = *fmt++;
*spot++ = '\0';
switch (spot[-2]) {
case 'i': case 'd': case 'u': case 'x': case 'X':
len = SDL_snprintf(msg, maxlen, tmp,
error->args[argi++].value_l);
if (len > 0) {
msg += len;
maxlen -= len;
}
break;
}
continue;
}
*spot++ = *fmt++;
*spot++ = '\0';
switch (spot[-2]) {
case '%':
*msg++ = '%';
maxlen -= 1;
break;
case 'c':
case 'i':
case 'd':
case 'u':
case 'o':
case 'x':
case 'X':
len =
SDL_snprintf(msg, maxlen, tmp,
error->args[argi++].value_i);
if (len > 0) {
msg += len;
maxlen -= len;
}
break;

case 'f':
len =
SDL_snprintf(msg, maxlen, tmp,
error->args[argi++].value_f);
if (len > 0) {
msg += len;
maxlen -= len;
}
break;

case 'p':
len =
SDL_snprintf(msg, maxlen, tmp,
error->args[argi++].value_ptr);
if (len > 0) {
msg += len;
maxlen -= len;
}
break;

case 's':
len =
SDL_snprintf(msg, maxlen, tmp,
SDL_LookupString(error->args[argi++].
buf));
if (len > 0) {
msg += len;
maxlen -= len;
}
break;

}
} else {
*msg++ = *fmt++;
maxlen -= 1;
}
}

/* slide back if we've overshot the end of our buffer. */
if (maxlen < 0) {
msg -= (-maxlen) + 1;
}

*msg = 0; /* NULL terminate the string */
SDL_strlcpy(errstr, error->str, maxlen);
} else {
*errstr = '\0';
}
return (errstr);

return errstr;
}

/* vi: set ts=4 sw=4 expandtab: */
26 changes: 2 additions & 24 deletions src/SDL_error_c.h
View file
Expand Up @@ -28,33 +28,11 @@
#define SDL_error_c_h_

#define ERR_MAX_STRLEN 128
#define ERR_MAX_ARGS 5

typedef struct SDL_error
{
/* This is a numeric value corresponding to the current error */
int error;

/* This is a key used to index into a language hashtable containing
internationalized versions of the SDL error messages. If the key
is not in the hashtable, or no hashtable is available, the key is
used directly as an error message format string.
*/
char key[ERR_MAX_STRLEN];

/* These are the arguments for the error functions */
int argc;
union
{
void *value_ptr;
#if 0 /* What is a character anyway? (UNICODE issues) */
unsigned char value_c;
#endif
int value_i;
long value_l;
double value_f;
char buf[ERR_MAX_STRLEN];
} args[ERR_MAX_ARGS];
int error; /* This is a numeric value corresponding to the current error */
char str[ERR_MAX_STRLEN];
} SDL_error;

/* Defined in SDL_thread.c */
Expand Down

0 comments on commit 09ca66b

Please sign in to comment.