Applied Matt Sealey's patch to remove/isolate all stdio.h function calls.

Instead of mstdio.[ch], use imports.[ch] to isolate these functions.

1 files changed, 184 insertions, 29 deletions

diff --git a/src/mesa/main/imports.c b/src/mesa/main/imports.c
index 40c02c246c1..dbe88a9724e 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 <stdio.h>, <stdlib.h>, 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;