Subversion Repositories Kolibri OS

/**

 * \file errors.c

 * Mesa debugging and error handling functions.

 */

/*

 * Mesa 3-D graphics library

 *

 * Copyright (C) 1999-2007  Brian Paul   All Rights Reserved.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included

 * in all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS

 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL

 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR

 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,

 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR

 * OTHER DEALINGS IN THE SOFTWARE.

 */

#include "errors.h"

#include "enums.h"

#include "imports.h"

#include "context.h"

#include "dispatch.h"

#include "hash.h"

#include "mtypes.h"

#include "version.h"

#include "hash_table.h"

#include "glapi/glthread.h"

_glthread_DECLARE_STATIC_MUTEX(DynamicIDMutex);

static GLuint NextDynamicID = 1;

struct gl_debug_severity

{

   struct simple_node link;

   GLuint ID;

};

static char out_of_memory[] = "Debugging error: out of memory";

static const GLenum debug_source_enums[] = {

   GL_DEBUG_SOURCE_API,

   GL_DEBUG_SOURCE_WINDOW_SYSTEM,

   GL_DEBUG_SOURCE_SHADER_COMPILER,

   GL_DEBUG_SOURCE_THIRD_PARTY,

   GL_DEBUG_SOURCE_APPLICATION,

   GL_DEBUG_SOURCE_OTHER,

};

static const GLenum debug_type_enums[] = {

   GL_DEBUG_TYPE_ERROR,

   GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR,

   GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR,

   GL_DEBUG_TYPE_PORTABILITY,

   GL_DEBUG_TYPE_PERFORMANCE,

   GL_DEBUG_TYPE_OTHER,

};

static const GLenum debug_severity_enums[] = {

   GL_DEBUG_SEVERITY_LOW,

   GL_DEBUG_SEVERITY_MEDIUM,

   GL_DEBUG_SEVERITY_HIGH,

};

static enum mesa_debug_source

gl_enum_to_debug_source(GLenum e)

{

   int i;

   for (i = 0; i < Elements(debug_source_enums); i++) {

      if (debug_source_enums[i] == e)

         break;

   }

   return i;

}

static enum mesa_debug_type

gl_enum_to_debug_type(GLenum e)

{

   int i;

   for (i = 0; i < Elements(debug_type_enums); i++) {

      if (debug_type_enums[i] == e)

         break;

   }

   return i;

}

static enum mesa_debug_severity

gl_enum_to_debug_severity(GLenum e)

{

   int i;

   for (i = 0; i < Elements(debug_severity_enums); i++) {

      if (debug_severity_enums[i] == e)

         break;

   }

   return i;

}

/**

 * Handles generating a GL_ARB_debug_output message ID generated by the GL or

 * GLSL compiler.

 *

 * The GL API has this "ID" mechanism, where the intention is to allow a

 * client to filter in/out messages based on source, type, and ID.  Of course,

 * building a giant enum list of all debug output messages that Mesa might

 * generate is ridiculous, so instead we have our caller pass us a pointer to

 * static storage where the ID should get stored.  This ID will be shared

 * across all contexts for that message (which seems like a desirable

 * property, even if it's not expected by the spec), but note that it won't be

 * the same between executions if messages aren't generated in the same order.

 */

static void

debug_get_id(GLuint *id)

{

   if (!(*id)) {

      _glthread_LOCK_MUTEX(DynamicIDMutex);

      if (!(*id))

         *id = NextDynamicID++;

      _glthread_UNLOCK_MUTEX(DynamicIDMutex);

   }

}

/*

 * We store a bitfield in the hash table, with five possible values total.

 *

 * The ENABLED_BIT's purpose is self-explanatory.

 *

 * The FOUND_BIT is needed to differentiate the value of DISABLED from

 * the value returned by HashTableLookup() when it can't find the given key.

 *

 * The KNOWN_SEVERITY bit is a bit complicated:

 *

 * A client may call Control() with an array of IDs, then call Control()

 * on all message IDs of a certain severity, then Insert() one of the

 * previously specified IDs, giving us a known severity level, then call

 * Control() on all message IDs of a certain severity level again.

 *

 * After the first call, those IDs will have a FOUND_BIT, but will not

 * exist in any severity-specific list, so the second call will not

 * impact them. This is undesirable but unavoidable given the API:

 * The only entrypoint that gives a severity for a client-defined ID

 * is the Insert() call.

 *

 * For the sake of Control(), we want to maintain the invariant

 * that an ID will either appear in none of the three severity lists,

 * or appear once, to minimize pointless duplication and potential surprises.

 *

 * Because Insert() is the only place that will learn an ID's severity,

 * it should insert an ID into the appropriate list, but only if the ID

 * doesn't exist in it or any other list yet. Because searching all three

 * lists at O(n) is needlessly expensive, we store KNOWN_SEVERITY.

 */

enum {

   FOUND_BIT = 1 << 0,

   ENABLED_BIT = 1 << 1,

   KNOWN_SEVERITY = 1 << 2,

   /* HashTable reserves zero as a return value meaning 'not found' */

   NOT_FOUND = 0,

   DISABLED = FOUND_BIT,

   ENABLED = ENABLED_BIT | FOUND_BIT

};

/**

 * Returns the state of the given message source/type/ID tuple.

 */

static GLboolean

should_log(struct gl_context *ctx,

           enum mesa_debug_source source,

           enum mesa_debug_type type,

           GLuint id,

           enum mesa_debug_severity severity)

{

   struct gl_debug_namespace *nspace =

         &ctx->Debug.Namespaces[source][type];

   uintptr_t state;

   /* In addition to not being able to store zero as a value, HashTable also

      can't use zero as a key. */

   if (id)

      state = (uintptr_t)_mesa_HashLookup(nspace->IDs, id);

   else

      state = nspace->ZeroID;

   /* Only do this once for each ID. This makes sure the ID exists in,

      at most, one list, and does not pointlessly appear multiple times. */

   if (!(state & KNOWN_SEVERITY)) {

      struct gl_debug_severity *entry;

      if (state == NOT_FOUND) {

         if (ctx->Debug.Defaults[severity][source][type])

            state = ENABLED;

         else

            state = DISABLED;

      }

      entry = malloc(sizeof *entry);

      if (!entry)

         goto out;

      state |= KNOWN_SEVERITY;

      if (id)

         _mesa_HashInsert(nspace->IDs, id, (void*)state);

      else

         nspace->ZeroID = state;

      entry->ID = id;

      insert_at_tail(&nspace->Severity[severity], &entry->link);

   }

out:

   return !!(state & ENABLED_BIT);

}

/**

 * Sets the state of the given message source/type/ID tuple.

 */

static void

set_message_state(struct gl_context *ctx,

                  enum mesa_debug_source source,

                  enum mesa_debug_type type,

                  GLuint id, GLboolean enabled)

{

   struct gl_debug_namespace *nspace =

         &ctx->Debug.Namespaces[source][type];

   uintptr_t state;

   /* In addition to not being able to store zero as a value, HashTable also

      can't use zero as a key. */

   if (id)

      state = (uintptr_t)_mesa_HashLookup(nspace->IDs, id);

   else

      state = nspace->ZeroID;

   if (state == NOT_FOUND)

      state = enabled ? ENABLED : DISABLED;

   else {

      if (enabled)

         state |= ENABLED_BIT;

      else

         state &= ~ENABLED_BIT;

   }

   if (id)

      _mesa_HashInsert(nspace->IDs, id, (void*)state);

   else

      nspace->ZeroID = state;

}

/**

 * 'buf' is not necessarily a null-terminated string. When logging, copy

 * 'len' characters from it, store them in a new, null-terminated string,

 * and remember the number of bytes used by that string, *including*

 * the null terminator this time.

 */

static void

_mesa_log_msg(struct gl_context *ctx, enum mesa_debug_source source,

              enum mesa_debug_type type, GLuint id,

              enum mesa_debug_severity severity, GLint len, const char *buf)

{

   GLint nextEmpty;

   struct gl_debug_msg *emptySlot;

   assert(len >= 0 && len < MAX_DEBUG_MESSAGE_LENGTH);

   if (!should_log(ctx, source, type, id, severity))

      return;

   if (ctx->Debug.Callback) {

      ctx->Debug.Callback(debug_source_enums[source],

                          debug_type_enums[type],

                          id,

                          debug_severity_enums[severity],

                          len, buf, ctx->Debug.CallbackData);

      return;

   }

   if (ctx->Debug.NumMessages == MAX_DEBUG_LOGGED_MESSAGES)

      return;

   nextEmpty = (ctx->Debug.NextMsg + ctx->Debug.NumMessages)

                          % MAX_DEBUG_LOGGED_MESSAGES;

   emptySlot = &ctx->Debug.Log[nextEmpty];

   assert(!emptySlot->message && !emptySlot->length);

   emptySlot->message = malloc(len+1);

   if (emptySlot->message) {

      (void) strncpy(emptySlot->message, buf, (size_t)len);

      emptySlot->message[len] = '\0';

      emptySlot->length = len+1;

      emptySlot->source = source;

      emptySlot->type = type;

      emptySlot->id = id;

      emptySlot->severity = severity;

   } else {

      static GLuint oom_msg_id = 0;

      debug_get_id(&oom_msg_id);

      /* malloc failed! */

      emptySlot->message = out_of_memory;

      emptySlot->length = strlen(out_of_memory)+1;

      emptySlot->source = MESA_DEBUG_SOURCE_OTHER;

      emptySlot->type = MESA_DEBUG_TYPE_ERROR;

      emptySlot->id = oom_msg_id;

      emptySlot->severity = MESA_DEBUG_SEVERITY_HIGH;

   }

   if (ctx->Debug.NumMessages == 0)

      ctx->Debug.NextMsgLength = ctx->Debug.Log[ctx->Debug.NextMsg].length;

   ctx->Debug.NumMessages++;

}

/**

 * Pop the oldest debug message out of the log.

 * Writes the message string, including the null terminator, into 'buf',

 * using up to 'bufSize' bytes. If 'bufSize' is too small, or

 * if 'buf' is NULL, nothing is written.

 *

 * Returns the number of bytes written on success, or when 'buf' is NULL,

 * the number that would have been written. A return value of 0

 * indicates failure.

 */

static GLsizei

_mesa_get_msg(struct gl_context *ctx, GLenum *source, GLenum *type,

              GLuint *id, GLenum *severity, GLsizei bufSize, char *buf)

{

   struct gl_debug_msg *msg;

   GLsizei length;

   if (ctx->Debug.NumMessages == 0)

      return 0;

   msg = &ctx->Debug.Log[ctx->Debug.NextMsg];

   length = msg->length;

   assert(length > 0 && length == ctx->Debug.NextMsgLength);

   if (bufSize < length && buf != NULL)

      return 0;

   if (severity)

      *severity = debug_severity_enums[msg->severity];

   if (source)

      *source = debug_source_enums[msg->source];

   if (type)

      *type = debug_type_enums[msg->type];

   if (id)

      *id = msg->id;

   if (buf) {

      assert(msg->message[length-1] == '\0');

      (void) strncpy(buf, msg->message, (size_t)length);

   }

   if (msg->message != (char*)out_of_memory)

      free(msg->message);

   msg->message = NULL;

   msg->length = 0;

   ctx->Debug.NumMessages--;

   ctx->Debug.NextMsg++;

   ctx->Debug.NextMsg %= MAX_DEBUG_LOGGED_MESSAGES;

   ctx->Debug.NextMsgLength = ctx->Debug.Log[ctx->Debug.NextMsg].length;

   return length;

}

/**

 * Verify that source, type, and severity are valid enums.

 * glDebugMessageInsertARB only accepts two values for 'source',

 * and glDebugMessageControlARB will additionally accept GL_DONT_CARE

 * in any parameter, so handle those cases specially.

 */

static GLboolean

validate_params(struct gl_context *ctx, unsigned caller,

                GLenum source, GLenum type, GLenum severity)

{

#define INSERT 1

#define CONTROL 2

   switch(source) {

   case GL_DEBUG_SOURCE_APPLICATION_ARB:

   case GL_DEBUG_SOURCE_THIRD_PARTY_ARB:

      break;

   case GL_DEBUG_SOURCE_API_ARB:

   case GL_DEBUG_SOURCE_SHADER_COMPILER_ARB:

   case GL_DEBUG_SOURCE_WINDOW_SYSTEM_ARB:

   case GL_DEBUG_SOURCE_OTHER_ARB:

      if (caller != INSERT)

         break;

   case GL_DONT_CARE:

      if (caller == CONTROL)

         break;

   default:

      goto error;

   }

   switch(type) {

   case GL_DEBUG_TYPE_ERROR_ARB:

   case GL_DEBUG_TYPE_DEPRECATED_BEHAVIOR_ARB:

   case GL_DEBUG_TYPE_UNDEFINED_BEHAVIOR_ARB:

   case GL_DEBUG_TYPE_PERFORMANCE_ARB:

   case GL_DEBUG_TYPE_PORTABILITY_ARB:

   case GL_DEBUG_TYPE_OTHER_ARB:

      break;

   case GL_DONT_CARE:

      if (caller == CONTROL)

         break;

   default:

      goto error;

   }

   switch(severity) {

   case GL_DEBUG_SEVERITY_HIGH_ARB:

   case GL_DEBUG_SEVERITY_MEDIUM_ARB:

   case GL_DEBUG_SEVERITY_LOW_ARB:

      break;

   case GL_DONT_CARE:

      if (caller == CONTROL)

         break;

   default:

      goto error;

   }

   return GL_TRUE;

error:

   {

      const char *callerstr;

      if (caller == INSERT)

         callerstr = "glDebugMessageInsertARB";

      else if (caller == CONTROL)

         callerstr = "glDebugMessageControlARB";

      else

         return GL_FALSE;

      _mesa_error( ctx, GL_INVALID_ENUM, "bad values passed to %s"

                  "(source=0x%x, type=0x%x, severity=0x%x)", callerstr,

                  source, type, severity);

   }

   return GL_FALSE;

}

void GLAPIENTRY

_mesa_DebugMessageInsertARB(GLenum source, GLenum type, GLuint id,

                            GLenum severity, GLint length,

                            const GLcharARB* buf)

{

   GET_CURRENT_CONTEXT(ctx);

   if (!validate_params(ctx, INSERT, source, type, severity))

      return; /* GL_INVALID_ENUM */

   if (length < 0)

      length = strlen(buf);

   if (length >= MAX_DEBUG_MESSAGE_LENGTH) {

      _mesa_error(ctx, GL_INVALID_VALUE, "glDebugMessageInsertARB"

                 "(length=%d, which is not less than "

                 "GL_MAX_DEBUG_MESSAGE_LENGTH_ARB=%d)", length,

                 MAX_DEBUG_MESSAGE_LENGTH);

      return;

   }

   _mesa_log_msg(ctx,

                 gl_enum_to_debug_source(source),

                 gl_enum_to_debug_type(type), id,

                 gl_enum_to_debug_severity(severity), length, buf);

}

GLuint GLAPIENTRY

_mesa_GetDebugMessageLogARB(GLuint count, GLsizei logSize, GLenum* sources,

                            GLenum* types, GLenum* ids, GLenum* severities,

                            GLsizei* lengths, GLcharARB* messageLog)

{

   GET_CURRENT_CONTEXT(ctx);

   GLuint ret;

   if (!messageLog)

      logSize = 0;

   if (logSize < 0) {

      _mesa_error(ctx, GL_INVALID_VALUE, "glGetDebugMessageLogARB"

                 "(logSize=%d : logSize must not be negative)", logSize);

      return 0;

   }

   for (ret = 0; ret < count; ret++) {

      GLsizei written = _mesa_get_msg(ctx, sources, types, ids, severities,

                                      logSize, messageLog);

      if (!written)

         break;

      if (messageLog) {

         messageLog += written;

         logSize -= written;

      }

      if (lengths) {

         *lengths = written;

         lengths++;

      }

      if (severities)

         severities++;

      if (sources)

         sources++;

      if (types)

         types++;

      if (ids)

         ids++;

   }

   return ret;

}

/**

 * Set the state of all message IDs found in the given intersection of

 * 'source', 'type', and 'severity'.  The _COUNT enum can be used for

 * GL_DONT_CARE (include all messages in the class).

 *

 * This requires both setting the state of all previously seen message

 * IDs in the hash table, and setting the default state for all

 * applicable combinations of source/type/severity, so that all the

 * yet-unknown message IDs that may be used in the future will be

 * impacted as if they were already known.

 */

static void

control_messages(struct gl_context *ctx,

                 enum mesa_debug_source source,

                 enum mesa_debug_type type,

                 enum mesa_debug_severity severity,

                 GLboolean enabled)

{

   int s, t, sev, smax, tmax, sevmax;

   if (source == MESA_DEBUG_SOURCE_COUNT) {

      source = 0;

      smax = MESA_DEBUG_SOURCE_COUNT;

   } else {

      smax = source+1;

   }

   if (type == MESA_DEBUG_TYPE_COUNT) {

      type = 0;

      tmax = MESA_DEBUG_TYPE_COUNT;

   } else {

      tmax = type+1;

   }

   if (severity == MESA_DEBUG_SEVERITY_COUNT) {

      severity = 0;

      sevmax = MESA_DEBUG_SEVERITY_COUNT;

   } else {

      sevmax = severity+1;

   }

   for (sev = severity; sev < sevmax; sev++)

      for (s = source; s < smax; s++)

         for (t = type; t < tmax; t++) {

            struct simple_node *node;

            struct gl_debug_severity *entry;

            /* change the default for IDs we've never seen before. */

            ctx->Debug.Defaults[sev][s][t] = enabled;

            /* Now change the state of IDs we *have* seen... */

            foreach(node, &ctx->Debug.Namespaces[s][t].Severity[sev]) {

               entry = (struct gl_debug_severity *)node;

               set_message_state(ctx, s, t, entry->ID, enabled);

            }

         }

}

/**

 * Debugging-message namespaces with the source APPLICATION or THIRD_PARTY

 * require special handling, since the IDs in them are controlled by clients,

 * not the OpenGL implementation.

 *

 * 'count' is the length of the array 'ids'. If 'count' is nonzero, all

 * the given IDs in the namespace defined by 'esource' and 'etype'

 * will be affected.

 *

 * If 'count' is zero, this sets the state of all IDs that match

 * the combination of 'esource', 'etype', and 'eseverity'.

 */

static void

control_app_messages(struct gl_context *ctx, GLenum esource, GLenum etype,

                     GLenum eseverity, GLsizei count, const GLuint *ids,

                     GLboolean enabled)

{

   GLsizei i;

   enum mesa_debug_source source = gl_enum_to_debug_source(esource);

   enum mesa_debug_type type = gl_enum_to_debug_type(etype);

   enum mesa_debug_severity severity = gl_enum_to_debug_severity(eseverity);

   for (i = 0; i < count; i++)

      set_message_state(ctx, source, type, ids[i], enabled);

   if (count)

      return;

   control_messages(ctx, source, type, severity, enabled);

}

void GLAPIENTRY

_mesa_DebugMessageControlARB(GLenum gl_source, GLenum gl_type,

                             GLenum gl_severity,

                             GLsizei count, const GLuint *ids,

                             GLboolean enabled)

{

   GET_CURRENT_CONTEXT(ctx);

   if (count < 0) {

      _mesa_error(ctx, GL_INVALID_VALUE, "glDebugMessageControlARB"

                 "(count=%d : count must not be negative)", count);

      return;

   }

   if (!validate_params(ctx, CONTROL, gl_source, gl_type, gl_severity))

      return; /* GL_INVALID_ENUM */

   if (count && (gl_severity != GL_DONT_CARE || gl_type == GL_DONT_CARE

                 || gl_source == GL_DONT_CARE)) {

      _mesa_error(ctx, GL_INVALID_OPERATION, "glDebugMessageControlARB"

                 "(When passing an array of ids, severity must be"

         " GL_DONT_CARE, and source and type must not be GL_DONT_CARE.");

      return;

   }

   control_app_messages(ctx, gl_source, gl_type, gl_severity,

                        count, ids, enabled);

}

void GLAPIENTRY

_mesa_DebugMessageCallbackARB(GLDEBUGPROCARB callback, const void *userParam)

{

   GET_CURRENT_CONTEXT(ctx);

   ctx->Debug.Callback = callback;

   ctx->Debug.CallbackData = userParam;

}

void

_mesa_init_errors(struct gl_context *ctx)

{

   int s, t, sev;

   ctx->Debug.Callback = NULL;

   ctx->Debug.SyncOutput = GL_FALSE;

   ctx->Debug.Log[0].length = 0;

   ctx->Debug.NumMessages = 0;

   ctx->Debug.NextMsg = 0;

   ctx->Debug.NextMsgLength = 0;

   /* Enable all the messages with severity HIGH or MEDIUM by default. */

   memset(ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_HIGH], GL_TRUE,

          sizeof ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_HIGH]);

   memset(ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_MEDIUM], GL_TRUE,

          sizeof ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_MEDIUM]);

   memset(ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_LOW], GL_FALSE,

          sizeof ctx->Debug.Defaults[MESA_DEBUG_SEVERITY_LOW]);

   /* Initialize state for filtering known debug messages. */

   for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++)

      for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) {

         ctx->Debug.Namespaces[s][t].IDs = _mesa_NewHashTable();

         assert(ctx->Debug.Namespaces[s][t].IDs);

         for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++)

            make_empty_list(&ctx->Debug.Namespaces[s][t].Severity[sev]);

      }

}

static void

do_nothing(GLuint key, void *data, void *userData)

{

}

void

_mesa_free_errors_data(struct gl_context *ctx)

{

   enum mesa_debug_type t;

   enum mesa_debug_source s;

   enum mesa_debug_severity sev;

   /* Tear down state for filtering debug messages. */

   for (s = 0; s < MESA_DEBUG_SOURCE_COUNT; s++)

      for (t = 0; t < MESA_DEBUG_TYPE_COUNT; t++) {

         _mesa_HashDeleteAll(ctx->Debug.Namespaces[s][t].IDs, do_nothing, NULL);

         _mesa_DeleteHashTable(ctx->Debug.Namespaces[s][t].IDs);

         for (sev = 0; sev < MESA_DEBUG_SEVERITY_COUNT; sev++) {

            struct simple_node *node, *tmp;

            struct gl_debug_severity *entry;

            foreach_s(node, tmp, &ctx->Debug.Namespaces[s][t].Severity[sev]) {

               entry = (struct gl_debug_severity *)node;

               free(entry);

            }

         }

      }

}

/**********************************************************************/

/** \name Diagnostics */

/*@{*/

static void

output_if_debug(const char *prefixString, const char *outputString,

                GLboolean newline)

{

   static int debug = -1;

   static FILE *fout = NULL;

   /* Init the local 'debug' var once.

    * Note: the _mesa_init_debug() function should have been called

    * by now so MESA_DEBUG_FLAGS will be initialized.

    */

   if (debug == -1) {

      /* If MESA_LOG_FILE env var is set, log Mesa errors, warnings,

       * etc to the named file.  Otherwise, output to stderr.

       */

      const char *logFile = _mesa_getenv("MESA_LOG_FILE");

      if (logFile)

         fout = fopen(logFile, "w");

      if (!fout)

         fout = stderr;

#ifdef DEBUG

      /* in debug builds, print messages unless MESA_DEBUG="silent" */

      if (MESA_DEBUG_FLAGS & DEBUG_SILENT)

         debug = 0;

      else

         debug = 1;

#else

      /* in release builds, be silent unless MESA_DEBUG is set */

      debug = _mesa_getenv("MESA_DEBUG") != NULL;

#endif

   }

   /* Now only print the string if we're required to do so. */

   if (debug) {

      fprintf(fout, "%s: %s", prefixString, outputString);

      if (newline)

         fprintf(fout, "\n");

      fflush(fout);

#if defined(_WIN32) && !defined(_WIN32_WCE)

      /* stderr from windows applications without console is not usually

       * visible, so communicate with the debugger instead */

      {

         char buf[4096];

         _mesa_snprintf(buf, sizeof(buf), "%s: %s%s", prefixString, outputString, newline ? "\n" : "");

         OutputDebugStringA(buf);

      }

#endif

   }

}

/**

 * When a new type of error is recorded, print a message describing

 * previous errors which were accumulated.

 */

static void

flush_delayed_errors( struct gl_context *ctx )

{

   char s[MAX_DEBUG_MESSAGE_LENGTH];

   if (ctx->ErrorDebugCount) {

      _mesa_snprintf(s, MAX_DEBUG_MESSAGE_LENGTH, "%d similar %s errors",

                     ctx->ErrorDebugCount,

                     _mesa_lookup_enum_by_nr(ctx->ErrorValue));

      output_if_debug("Mesa", s, GL_TRUE);

      ctx->ErrorDebugCount = 0;

   }

}

/**

 * Report a warning (a recoverable error condition) to stderr if

 * either DEBUG is defined or the MESA_DEBUG env var is set.

 *

 * \param ctx GL context.

 * \param fmtString printf()-like format string.

 */

void

_mesa_warning( struct gl_context *ctx, const char *fmtString, ... )

{

   char str[MAX_DEBUG_MESSAGE_LENGTH];

   va_list args;

   va_start( args, fmtString );

   (void) _mesa_vsnprintf( str, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args );

   va_end( args );

   if (ctx)

      flush_delayed_errors( ctx );

   output_if_debug("Mesa warning", str, GL_TRUE);

}

/**

 * Report an internal implementation problem.

 * Prints the message to stderr via fprintf().

 *

 * \param ctx GL context.

 * \param fmtString problem description string.

 */

void

_mesa_problem( const struct gl_context *ctx, const char *fmtString, ... )

{

   va_list args;

   char str[MAX_DEBUG_MESSAGE_LENGTH];

   static int numCalls = 0;

   (void) ctx;

   if (numCalls < 50) {

      numCalls++;

      va_start( args, fmtString );

      _mesa_vsnprintf( str, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args );

      va_end( args );

      fprintf(stderr, "Mesa %s implementation error: %s\n",

              PACKAGE_VERSION, str);

      fprintf(stderr, "Please report at " PACKAGE_BUGREPORT "\n");

   }

}

static GLboolean

should_output(struct gl_context *ctx, GLenum error, const char *fmtString)

{

   static GLint debug = -1;

   /* Check debug environment variable only once:

    */

   if (debug == -1) {

      const char *debugEnv = _mesa_getenv("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) {

      if (ctx->ErrorValue != error ||

          ctx->ErrorDebugFmtString != fmtString) {

         flush_delayed_errors( ctx );

         ctx->ErrorDebugFmtString = fmtString;

         ctx->ErrorDebugCount = 0;

         return GL_TRUE;

      }

      ctx->ErrorDebugCount++;

   }

   return GL_FALSE;

}

void

_mesa_gl_debug(struct gl_context *ctx,

               GLuint *id,

               enum mesa_debug_type type,

               enum mesa_debug_severity severity,

               const char *fmtString, ...)

{

   char s[MAX_DEBUG_MESSAGE_LENGTH];

   int len;

   va_list args;

   debug_get_id(id);

   va_start(args, fmtString);

   len = _mesa_vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args);

   va_end(args);

   _mesa_log_msg(ctx, MESA_DEBUG_SOURCE_API, type,

                 *id, severity, len, s);

}

/**

 * Record an OpenGL state error.  These usually occur when the user

 * passes invalid parameters to a GL function.

 *

 * If debugging is enabled (either at compile-time via the DEBUG macro, or

 * run-time via the MESA_DEBUG environment variable), report the error with

 * _mesa_debug().

 *

 * \param ctx the GL context.

 * \param error the error value.

 * \param fmtString printf() style format string, followed by optional args

 */

void

_mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... )

{

   GLboolean do_output, do_log;

   /* Ideally this would be set up by the caller, so that we had proper IDs

    * per different message.

    */

   static GLuint error_msg_id = 0;

   debug_get_id(&error_msg_id);

   do_output = should_output(ctx, error, fmtString);

   do_log = should_log(ctx,

                       MESA_DEBUG_SOURCE_API,

                       MESA_DEBUG_TYPE_ERROR,

                       error_msg_id,

                       MESA_DEBUG_SEVERITY_HIGH);

   if (do_output || do_log) {

      char s[MAX_DEBUG_MESSAGE_LENGTH], s2[MAX_DEBUG_MESSAGE_LENGTH];

      int len;

      va_list args;

      va_start(args, fmtString);

      len = _mesa_vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args);

      va_end(args);

      if (len >= MAX_DEBUG_MESSAGE_LENGTH) {

         /* Too long error message. Whoever calls _mesa_error should use

          * shorter strings. */

         ASSERT(0);

         return;

      }

      len = _mesa_snprintf(s2, MAX_DEBUG_MESSAGE_LENGTH, "%s in %s",

                           _mesa_lookup_enum_by_nr(error), s);

      if (len >= MAX_DEBUG_MESSAGE_LENGTH) {

         /* Same as above. */

         ASSERT(0);

         return;

      }

      /* Print the error to stderr if needed. */

      if (do_output) {

         output_if_debug("Mesa: User error", s2, GL_TRUE);

      }

      /* Log the error via ARB_debug_output if needed.*/

      if (do_log) {

         _mesa_log_msg(ctx,

                       MESA_DEBUG_SOURCE_API,

                       MESA_DEBUG_TYPE_ERROR,

                       error_msg_id,

                       MESA_DEBUG_SEVERITY_HIGH, len, s2);

      }

   }

   /* Set the GL context error state for glGetError. */

   _mesa_record_error(ctx, error);

}

/**

 * Report debug information.  Print error message to stderr via fprintf().

 * No-op if DEBUG mode not enabled.

 *

 * \param ctx GL context.

 * \param fmtString printf()-style format string, followed by optional args.

 */

void

_mesa_debug( const struct gl_context *ctx, const char *fmtString, ... )

{

#ifdef DEBUG

   char s[MAX_DEBUG_MESSAGE_LENGTH];

   va_list args;

   va_start(args, fmtString);

   _mesa_vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args);

   va_end(args);

   output_if_debug("Mesa", s, GL_FALSE);

#endif /* DEBUG */

   (void) ctx;

   (void) fmtString;

}

/**

 * Report debug information from the shader compiler via GL_ARB_debug_output.

 *

 * \param ctx GL context.

 * \param type The namespace to which this message belongs.

 * \param id The message ID within the given namespace.

 * \param msg The message to output. Need not be null-terminated.

 * \param len The length of 'msg'. If negative, 'msg' must be null-terminated.

 */

void

_mesa_shader_debug( struct gl_context *ctx, GLenum type, GLuint *id,

                    const char *msg, int len )

{

   enum mesa_debug_source source = MESA_DEBUG_SOURCE_SHADER_COMPILER;

   enum mesa_debug_severity severity = MESA_DEBUG_SEVERITY_HIGH;

   debug_get_id(id);

   if (len < 0)

      len = strlen(msg);

   /* Truncate the message if necessary. */

   if (len >= MAX_DEBUG_MESSAGE_LENGTH)

      len = MAX_DEBUG_MESSAGE_LENGTH - 1;

   _mesa_log_msg(ctx, source, type, *id, severity, len, msg);

}

/*@}*/