SDL_error.c File Reference

#include "./SDL_internal.h"
#include "SDL_log.h"
#include "SDL_error.h"
#include "SDL_error_c.h"

Include dependency graph for SDL_error.c:

Go to the source code of this file.

Macros
#define	SDL_ERRBUFIZE   1024

Functions
SDL_error *	SDL_GetErrBuf (void)
static const char *	SDL_LookupString (const char *key)
static char *	SDL_GetErrorMsg (char *errstr, int maxlen)
int	SDL_SetError (SDL_PRINTF_FORMAT_STRING const char *fmt,...)
const char *	SDL_GetError (void)
void	SDL_ClearError (void)
int	SDL_Error (SDL_errorcode code)

Macro Definition Documentation

#define SDL_ERRBUFIZE   1024

Definition at line 39 of file SDL_error.c.

Referenced by SDL_GetError(), and SDL_SetError().

Function Documentation

void SDL_ClearError

(

void

)

Definition at line 148 of file SDL_error.c.

References SDL_error::error, and SDL_GetErrBuf().

{
    SDL_error *error;

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

int SDL_Error

(

SDL_errorcode

code

)

Definition at line 158 of file SDL_error.c.

References SDL_EFREAD, SDL_EFSEEK, SDL_EFWRITE, SDL_ENOMEM, SDL_SetError, and SDL_UNSUPPORTED.

{
    switch (code) {
    case SDL_ENOMEM:
        return SDL_SetError("Out of memory");
    case SDL_EFREAD:
        return SDL_SetError("Error reading from datastream");
    case SDL_EFWRITE:
        return SDL_SetError("Error writing to datastream");
    case SDL_EFSEEK:
        return SDL_SetError("Error seeking in datastream");
    case SDL_UNSUPPORTED:
        return SDL_SetError("That operation is not supported");
    default:
        return SDL_SetError("Unknown SDL error");
    }
}

SDL_error* SDL_GetErrBuf

(

void

)

Definition at line 206 of file SDL_thread.c.

Referenced by SDL_ClearError(), SDL_GetErrorMsg(), and SDL_SetError().

{
    static SDL_SpinLock tls_lock;
    static SDL_bool tls_being_created;
    static SDL_TLSID tls_errbuf;
    static SDL_error SDL_global_errbuf;
    const SDL_error *ALLOCATION_IN_PROGRESS = (SDL_error *)-1;
    SDL_error *errbuf;

    /* tls_being_created is there simply to prevent recursion if SDL_TLSCreate() fails.
       It also means it's possible for another thread to also use SDL_global_errbuf,
       but that's very unlikely and hopefully won't cause issues.
     */
    if (!tls_errbuf && !tls_being_created) {
        SDL_AtomicLock(&tls_lock);
        if (!tls_errbuf) {
            SDL_TLSID slot;
            tls_being_created = SDL_TRUE;
            slot = SDL_TLSCreate();
            tls_being_created = SDL_FALSE;
            SDL_MemoryBarrierRelease();
            tls_errbuf = slot;
        }
        SDL_AtomicUnlock(&tls_lock);
    }
    if (!tls_errbuf) {
        return &SDL_global_errbuf;
    }

    SDL_MemoryBarrierAcquire();
    errbuf = (SDL_error *)SDL_TLSGet(tls_errbuf);
    if (errbuf == ALLOCATION_IN_PROGRESS) {
        return &SDL_global_errbuf;
    }
    if (!errbuf) {
        /* Mark that we're in the middle of allocating our buffer */
        SDL_TLSSet(tls_errbuf, ALLOCATION_IN_PROGRESS, NULL);
        errbuf = (SDL_error *)SDL_malloc(sizeof(*errbuf));
        if (!errbuf) {
            SDL_TLSSet(tls_errbuf, NULL, NULL);
            return &SDL_global_errbuf;
        }
        SDL_zerop(errbuf);
        SDL_TLSSet(tls_errbuf, errbuf, SDL_free);
    }
    return errbuf;
}

const char* SDL_GetError

(

void

)

Definition at line 140 of file SDL_error.c.

References SDL_ERRBUFIZE, and SDL_GetErrorMsg().

{
    static char errmsg[SDL_ERRBUFIZE];

    return SDL_GetErrorMsg(errmsg, SDL_ERRBUFIZE);
}

static char * SDL_GetErrorMsg ( char *  errstr, int  maxlen  )

static

Definition at line 206 of file SDL_error.c.

References SDL_error::args, SDL_error::error, SDL_error::key, SDL_arraysize, SDL_GetErrBuf(), SDL_LookupString(), SDL_snprintf, SDL_error::value_f, SDL_error::value_i, SDL_error::value_l, and SDL_error::value_ptr.

Referenced by SDL_GetError(), and SDL_SetError().

{
    SDL_error *error;

    /* Clear the error string */
    *errstr = '\0';
    --maxlen;

    /* 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':
                      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 */
    }
    return (errstr);
}

static const char* SDL_LookupString ( const char *  key )

static

Definition at line 44 of file SDL_error.c.

Referenced by SDL_GetErrorMsg().

{
    /* FIXME: Add code to lookup key in language string hash-table */
    return key;
}

int SDL_SetError	(	SDL_PRINTF_FORMAT_STRING const char *	fmt,
			...
	)

Definition at line 55 of file SDL_error.c.

References SDL_error::argc, SDL_error::args, SDL_error::buf, ERR_MAX_ARGS, ERR_MAX_STRLEN, SDL_error::error, i, SDL_error::key, NULL, SDL_ERRBUFIZE, SDL_GetErrBuf(), SDL_GetErrorMsg(), SDL_LOG_CATEGORY_ERROR, SDL_LOG_PRIORITY_DEBUG, SDL_LogDebug, SDL_LogGetPriority, SDL_strlcpy, SDL_error::value_f, SDL_error::value_i, SDL_error::value_l, and SDL_error::value_ptr.

{
    va_list ap;
    SDL_error *error;

    /* Ignore call if invalid format pointer was passed */
    if (fmt == NULL) return -1;

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

    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':
                    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_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;
}