From 4e9676fb13f60ecdbc247b120031f18cd3febcb0 Mon Sep 17 00:00:00 2001 From: Brian Paul Date: Sat, 29 Jun 2002 19:48:15 +0000 Subject: Applied Matt Sealey's patch to remove/isolate all stdio.h function calls. Instead of mstdio.[ch], use imports.[ch] to isolate these functions. --- src/mesa/main/imports.c | 213 +++++++++++++++++++++++++++++++++++++++++------- 1 file changed, 184 insertions(+), 29 deletions(-) (limited to 'src/mesa/main/imports.c') diff --git a/src/mesa/main/imports.c b/src/mesa/main/imports.c index 40c02c246c..dbe88a9724 100644 --- a/src/mesa/main/imports.c +++ b/src/mesa/main/imports.c @@ -1,4 +1,4 @@ -/* $Id: imports.c,v 1.14 2002/06/18 08:35:25 joukj Exp $ */ +/* $Id: imports.c,v 1.15 2002/06/29 19:48:16 brianp Exp $ */ /* * Mesa 3-D graphics library @@ -26,31 +26,24 @@ /* - * Imports are functions which the device driver or window system or + * Imports are services which the device driver or window system or * operating system provides to the core renderer. The core renderer (Mesa) * will call these functions in order to do memory allocation, simple I/O, * etc. * - * Some drivers will want to provide a specialed __GLimport object, but - * most Mesa drivers will be able to call _mesa_init_default_imports() - * and go with that. + * Some drivers will want to override/replace this file with something + * specialized, but most Mesa drivers will be able to call + *_mesa_init_default_imports() and go with what's here. * - * A server-side GL renderer will likely not use these functions since - * the renderer should use the XFree86-wrapped system calls. - */ - -/* - * XXX when we fully implement the __GLimports mechanism in Mesa, that - * should mean that we can remove , , etc, from - * glheader.h. Strictly speaking, all system includes should be done - * from this file, and not glheader to ensure that core Mesa has no - * dependencies on external libraries. Someday... + * Eventually, I'd like to move most of the stuff in glheader.h and mem.[ch] + * into imports.[ch]. Then we'll really have one, single place where + * all OS-related dependencies are isolated. */ - #include "glheader.h" #include "mtypes.h" +#include "context.h" #include "imports.h" #include "mem.h" @@ -79,46 +72,49 @@ _mesa_Free(__GLcontext *gc, void *addr) FREE(addr); } + /* Must be before '#undef getenv' for inclusion in XFree86. */ static char * CAPI _mesa_getenv(__GLcontext *gc, const char *var) { (void) gc; +/* Whacko XFree86 macro: + */ +#ifdef getenv +#undef getenv +#endif return getenv(var); } + static void -_mesa_warning(__GLcontext *gc, char *str) +warning(__GLcontext *gc, char *str) { GLboolean debug; #ifdef DEBUG debug = GL_TRUE; #else -/* Whacko XFree86 macro: - */ -#ifdef getenv -#undef getenv -#endif - if (gc->imports.getenv(gc, "MESA_DEBUG")) { + if (_mesa_getenv(gc "MESA_DEBUG")) debug = GL_TRUE; - } - else { + else debug = GL_FALSE; - } #endif if (debug) { fprintf(stderr, "Mesa warning: %s\n", str); } } -static void + +void _mesa_fatal(__GLcontext *gc, char *str) { + (void) gc; fprintf(stderr, "%s\n", str); abort(); } + static int CAPI _mesa_atoi(__GLcontext *gc, const char *str) { @@ -126,7 +122,8 @@ _mesa_atoi(__GLcontext *gc, const char *str) return atoi(str); } -static int CAPI + +int CAPI _mesa_sprintf(__GLcontext *gc, char *str, const char *fmt, ...) { int r; @@ -137,18 +134,21 @@ _mesa_sprintf(__GLcontext *gc, char *str, const char *fmt, ...) return r; } + static void * CAPI _mesa_fopen(__GLcontext *gc, const char *path, const char *mode) { return fopen(path, mode); } + static int CAPI _mesa_fclose(__GLcontext *gc, void *stream) { return fclose((FILE *) stream); } + static int CAPI _mesa_fprintf(__GLcontext *gc, void *stream, const char *fmt, ...) { @@ -160,6 +160,7 @@ _mesa_fprintf(__GLcontext *gc, void *stream, const char *fmt, ...) return r; } + /* XXX this really is driver-specific and can't be here */ static __GLdrawablePrivate * _mesa_GetDrawablePrivate(__GLcontext *gc) @@ -168,6 +169,160 @@ _mesa_GetDrawablePrivate(__GLcontext *gc) } + +void +_mesa_warning(__GLcontext *gc, const char *fmtString, ...) +{ + char str[1000]; + va_list args; + va_start( args, fmtString ); + (void) vsprintf( str, fmtString, args ); + va_end( args ); + warning(gc, str); +} + + +/* + * This function is called when the Mesa user has stumbled into a code + * path which may not be implemented fully or correctly. + */ +void +_mesa_problem( const GLcontext *ctx, const char *s ) +{ + if (ctx) { + ctx->imports.fprintf((GLcontext *) ctx, stderr, "Mesa implementation error: %s\n", s); +#ifdef XF86DRI + ctx->imports.fprintf((GLcontext *) ctx, stderr, "Please report to the DRI bug database at dri.sourceforge.net\n"); +#else + ctx->imports.fprintf((GLcontext *) ctx, stderr, "Please report to the Mesa bug database at www.mesa3d.org\n" ); +#endif + } + else { + /* what can we do if we don't have a context???? */ + fprintf( stderr, "Mesa implementation error: %s\n", s ); +#ifdef XF86DRI + fprintf( stderr, "Please report to the DRI bug database at dri.sourceforge.net\n"); +#else + fprintf( stderr, "Please report to the Mesa bug database at www.mesa3d.org\n" ); +#endif + } +} + + +/* + * If in debug mode, print error message to stdout. + * Also, record the error code by calling _mesa_record_error(). + * Input: ctx - the GL context + * error - the error value + * fmtString - printf-style format string, followed by optional args + */ +void +_mesa_error( GLcontext *ctx, GLenum error, const char *fmtString, ... ) +{ + const char *debugEnv; + GLboolean debug; + + debugEnv = _mesa_getenv(ctx, "MESA_DEBUG"); + +#ifdef DEBUG + if (debugEnv && strstr(debugEnv, "silent")) + debug = GL_FALSE; + else + debug = GL_TRUE; +#else + if (debugEnv) + debug = GL_TRUE; + else + debug = GL_FALSE; +#endif + + if (debug) { + va_list args; + char where[1000]; + const char *errstr; + + va_start( args, fmtString ); + vsprintf( where, fmtString, args ); + va_end( args ); + + switch (error) { + case GL_NO_ERROR: + errstr = "GL_NO_ERROR"; + break; + case GL_INVALID_VALUE: + errstr = "GL_INVALID_VALUE"; + break; + case GL_INVALID_ENUM: + errstr = "GL_INVALID_ENUM"; + break; + case GL_INVALID_OPERATION: + errstr = "GL_INVALID_OPERATION"; + break; + case GL_STACK_OVERFLOW: + errstr = "GL_STACK_OVERFLOW"; + break; + case GL_STACK_UNDERFLOW: + errstr = "GL_STACK_UNDERFLOW"; + break; + case GL_OUT_OF_MEMORY: + errstr = "GL_OUT_OF_MEMORY"; + break; + case GL_TABLE_TOO_LARGE: + errstr = "GL_TABLE_TOO_LARGE"; + break; + default: + errstr = "unknown"; + break; + } + _mesa_debug(ctx, "Mesa user error: %s in %s\n", errstr, where); + } + + _mesa_record_error(ctx, error); +} + + +/* + * Call this to report debug information. Uses stderr. + */ +void +_mesa_debug( const GLcontext *ctx, const char *fmtString, ... ) +{ + char s[1000]; + va_list args; + va_start(args, fmtString); + vsprintf(s, fmtString, args); + if (ctx) + (void) ctx->imports.fprintf( (__GLcontext *) ctx, stderr, s ); + else + fprintf( stderr, s ); + va_end(args); +} + + +/* + * A wrapper for printf. Uses stdout. + */ +void +_mesa_printf( const GLcontext *ctx, const char *fmtString, ... ) +{ + char s[1000]; + va_list args; + va_start( args, fmtString ); + vsprintf(s, fmtString, args); + if (ctx) + (void) ctx->imports.fprintf( (__GLcontext *) ctx, stdout, s ); + else + printf( s ); + va_end( args ); +} + + +/* + * Initialize a __GLimports object to point to the functions in + * this file. This is to be called from device drivers. + * Input: imports - the object to init + * driverCtx - pointer to device driver-specific data + */ void _mesa_init_default_imports(__GLimports *imports, void *driverCtx) { @@ -175,7 +330,7 @@ _mesa_init_default_imports(__GLimports *imports, void *driverCtx) imports->calloc = _mesa_Calloc; imports->realloc = _mesa_Realloc; imports->free = _mesa_Free; - imports->warning = _mesa_warning; + imports->warning = warning; imports->fatal = _mesa_fatal; imports->getenv = _mesa_getenv; imports->atoi = _mesa_atoi; -- cgit v1.2.3