mesa: fix formatting of messages printed using _mesa_log
[mesa.git] / src / mesa / main / errors.c
1 /**
2 * \file errors.c
3 * Mesa debugging and error handling functions.
4 */
5
6 /*
7 * Mesa 3-D graphics library
8 *
9 * Copyright (C) 1999-2007 Brian Paul All Rights Reserved.
10 *
11 * Permission is hereby granted, free of charge, to any person obtaining a
12 * copy of this software and associated documentation files (the "Software"),
13 * to deal in the Software without restriction, including without limitation
14 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
15 * and/or sell copies of the Software, and to permit persons to whom the
16 * Software is furnished to do so, subject to the following conditions:
17 *
18 * The above copyright notice and this permission notice shall be included
19 * in all copies or substantial portions of the Software.
20 *
21 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
22 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
23 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
24 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR
25 * OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
26 * ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
27 * OTHER DEALINGS IN THE SOFTWARE.
28 */
29
30
31 #include <stdarg.h>
32 #include <stdio.h>
33 #include "errors.h"
34 #include "enums.h"
35
36 #include "context.h"
37 #include "debug_output.h"
38
39
40 static FILE *LogFile = NULL;
41
42
43 static void
44 output_if_debug(const char *prefixString, const char *outputString,
45 GLboolean newline)
46 {
47 static int debug = -1;
48
49 /* Init the local 'debug' var once.
50 * Note: the _mesa_init_debug() function should have been called
51 * by now so MESA_DEBUG_FLAGS will be initialized.
52 */
53 if (debug == -1) {
54 /* If MESA_LOG_FILE env var is set, log Mesa errors, warnings,
55 * etc to the named file. Otherwise, output to stderr.
56 */
57 const char *logFile = getenv("MESA_LOG_FILE");
58 if (logFile)
59 LogFile = fopen(logFile, "w");
60 if (!LogFile)
61 LogFile = stderr;
62 #ifndef NDEBUG
63 /* in debug builds, print messages unless MESA_DEBUG="silent" */
64 if (MESA_DEBUG_FLAGS & DEBUG_SILENT)
65 debug = 0;
66 else
67 debug = 1;
68 #else
69 /* in release builds, be silent unless MESA_DEBUG is set */
70 debug = getenv("MESA_DEBUG") != NULL;
71 #endif
72 }
73
74 /* Now only print the string if we're required to do so. */
75 if (debug) {
76 if (prefixString)
77 fprintf(LogFile, "%s: %s", prefixString, outputString);
78 else
79 fprintf(LogFile, "%s", outputString);
80 if (newline)
81 fprintf(LogFile, "\n");
82 fflush(LogFile);
83
84 #if defined(_WIN32)
85 /* stderr from windows applications without console is not usually
86 * visible, so communicate with the debugger instead */
87 {
88 char buf[4096];
89 if (prefixString)
90 snprintf(buf, sizeof(buf), "%s: %s%s", prefixString, outputString, newline ? "\n" : "");
91 else
92 snprintf(buf, sizeof(buf), "%s%s", outputString, newline ? "\n" : "");
93 OutputDebugStringA(buf);
94 }
95 #endif
96 }
97 }
98
99
100 /**
101 * Return the file handle to use for debug/logging. Defaults to stderr
102 * unless MESA_LOG_FILE is defined.
103 */
104 FILE *
105 _mesa_get_log_file(void)
106 {
107 assert(LogFile);
108 return LogFile;
109 }
110
111
112 /**
113 * When a new type of error is recorded, print a message describing
114 * previous errors which were accumulated.
115 */
116 static void
117 flush_delayed_errors( struct gl_context *ctx )
118 {
119 char s[MAX_DEBUG_MESSAGE_LENGTH];
120
121 if (ctx->ErrorDebugCount) {
122 snprintf(s, MAX_DEBUG_MESSAGE_LENGTH, "%d similar %s errors",
123 ctx->ErrorDebugCount,
124 _mesa_enum_to_string(ctx->ErrorValue));
125
126 output_if_debug("Mesa", s, GL_TRUE);
127
128 ctx->ErrorDebugCount = 0;
129 }
130 }
131
132
133 /**
134 * Report a warning (a recoverable error condition) to stderr if
135 * either DEBUG is defined or the MESA_DEBUG env var is set.
136 *
137 * \param ctx GL context.
138 * \param fmtString printf()-like format string.
139 */
140 void
141 _mesa_warning( struct gl_context *ctx, const char *fmtString, ... )
142 {
143 char str[MAX_DEBUG_MESSAGE_LENGTH];
144 va_list args;
145 va_start( args, fmtString );
146 (void) vsnprintf( str, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args );
147 va_end( args );
148
149 if (ctx)
150 flush_delayed_errors( ctx );
151
152 output_if_debug("Mesa warning", str, GL_TRUE);
153 }
154
155
156 /**
157 * Report an internal implementation problem.
158 * Prints the message to stderr via fprintf().
159 *
160 * \param ctx GL context.
161 * \param fmtString problem description string.
162 */
163 void
164 _mesa_problem( const struct gl_context *ctx, const char *fmtString, ... )
165 {
166 va_list args;
167 char str[MAX_DEBUG_MESSAGE_LENGTH];
168 static int numCalls = 0;
169
170 (void) ctx;
171
172 if (numCalls < 50) {
173 numCalls++;
174
175 va_start( args, fmtString );
176 vsnprintf( str, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args );
177 va_end( args );
178 fprintf(stderr, "Mesa " PACKAGE_VERSION " implementation error: %s\n",
179 str);
180 fprintf(stderr, "Please report at " PACKAGE_BUGREPORT "\n");
181 }
182 }
183
184
185 static GLboolean
186 should_output(struct gl_context *ctx, GLenum error, const char *fmtString)
187 {
188 static GLint debug = -1;
189
190 /* Check debug environment variable only once:
191 */
192 if (debug == -1) {
193 const char *debugEnv = getenv("MESA_DEBUG");
194
195 #ifndef NDEBUG
196 if (debugEnv && strstr(debugEnv, "silent"))
197 debug = GL_FALSE;
198 else
199 debug = GL_TRUE;
200 #else
201 if (debugEnv)
202 debug = GL_TRUE;
203 else
204 debug = GL_FALSE;
205 #endif
206 }
207
208 if (debug) {
209 if (ctx->ErrorValue != error ||
210 ctx->ErrorDebugFmtString != fmtString) {
211 flush_delayed_errors( ctx );
212 ctx->ErrorDebugFmtString = fmtString;
213 ctx->ErrorDebugCount = 0;
214 return GL_TRUE;
215 }
216 ctx->ErrorDebugCount++;
217 }
218 return GL_FALSE;
219 }
220
221
222 void
223 _mesa_gl_vdebugf(struct gl_context *ctx,
224 GLuint *id,
225 enum mesa_debug_source source,
226 enum mesa_debug_type type,
227 enum mesa_debug_severity severity,
228 const char *fmtString,
229 va_list args)
230 {
231 char s[MAX_DEBUG_MESSAGE_LENGTH];
232 int len;
233
234 _mesa_debug_get_id(id);
235
236 len = vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args);
237 if (len >= MAX_DEBUG_MESSAGE_LENGTH)
238 /* message was truncated */
239 len = MAX_DEBUG_MESSAGE_LENGTH - 1;
240
241 _mesa_log_msg(ctx, source, type, *id, severity, len, s);
242 }
243
244
245 void
246 _mesa_gl_debugf(struct gl_context *ctx,
247 GLuint *id,
248 enum mesa_debug_source source,
249 enum mesa_debug_type type,
250 enum mesa_debug_severity severity,
251 const char *fmtString, ...)
252 {
253 va_list args;
254 va_start(args, fmtString);
255 _mesa_gl_vdebugf(ctx, id, source, type, severity, fmtString, args);
256 va_end(args);
257 }
258
259 size_t
260 _mesa_gl_debug(struct gl_context *ctx,
261 GLuint *id,
262 enum mesa_debug_source source,
263 enum mesa_debug_type type,
264 enum mesa_debug_severity severity,
265 const char *msg)
266 {
267 _mesa_debug_get_id(id);
268
269 size_t len = strnlen(msg, MAX_DEBUG_MESSAGE_LENGTH);
270 if (len < MAX_DEBUG_MESSAGE_LENGTH) {
271 _mesa_log_msg(ctx, source, type, *id, severity, len, msg);
272 return len;
273 }
274
275 /* limit the message to fit within KHR_debug buffers */
276 char s[MAX_DEBUG_MESSAGE_LENGTH];
277 strncpy(s, msg, MAX_DEBUG_MESSAGE_LENGTH);
278 s[MAX_DEBUG_MESSAGE_LENGTH - 1] = '\0';
279 len = MAX_DEBUG_MESSAGE_LENGTH - 1;
280 _mesa_log_msg(ctx, source, type, *id, severity, len, s);
281
282 /* report the number of characters that were logged */
283 return len;
284 }
285
286
287 /**
288 * Record an OpenGL state error. These usually occur when the user
289 * passes invalid parameters to a GL function.
290 *
291 * If debugging is enabled (either at compile-time via the DEBUG macro, or
292 * run-time via the MESA_DEBUG environment variable), report the error with
293 * _mesa_debug().
294 *
295 * \param ctx the GL context.
296 * \param error the error value.
297 * \param fmtString printf() style format string, followed by optional args
298 */
299 void
300 _mesa_error( struct gl_context *ctx, GLenum error, const char *fmtString, ... )
301 {
302 GLboolean do_output, do_log;
303 /* Ideally this would be set up by the caller, so that we had proper IDs
304 * per different message.
305 */
306 static GLuint error_msg_id = 0;
307
308 _mesa_debug_get_id(&error_msg_id);
309
310 do_output = should_output(ctx, error, fmtString);
311
312 simple_mtx_lock(&ctx->DebugMutex);
313 if (ctx->Debug) {
314 do_log = _mesa_debug_is_message_enabled(ctx->Debug,
315 MESA_DEBUG_SOURCE_API,
316 MESA_DEBUG_TYPE_ERROR,
317 error_msg_id,
318 MESA_DEBUG_SEVERITY_HIGH);
319 }
320 else {
321 do_log = GL_FALSE;
322 }
323 simple_mtx_unlock(&ctx->DebugMutex);
324
325 if (do_output || do_log) {
326 char s[MAX_DEBUG_MESSAGE_LENGTH], s2[MAX_DEBUG_MESSAGE_LENGTH];
327 int len;
328 va_list args;
329
330 va_start(args, fmtString);
331 len = vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args);
332 va_end(args);
333
334 if (len >= MAX_DEBUG_MESSAGE_LENGTH) {
335 /* Too long error message. Whoever calls _mesa_error should use
336 * shorter strings.
337 */
338 assert(0);
339 return;
340 }
341
342 len = snprintf(s2, MAX_DEBUG_MESSAGE_LENGTH, "%s in %s",
343 _mesa_enum_to_string(error), s);
344 if (len >= MAX_DEBUG_MESSAGE_LENGTH) {
345 /* Same as above. */
346 assert(0);
347 return;
348 }
349
350 /* Print the error to stderr if needed. */
351 if (do_output) {
352 output_if_debug("Mesa: User error", s2, GL_TRUE);
353 }
354
355 /* Log the error via ARB_debug_output if needed.*/
356 if (do_log) {
357 _mesa_log_msg(ctx, MESA_DEBUG_SOURCE_API, MESA_DEBUG_TYPE_ERROR,
358 error_msg_id, MESA_DEBUG_SEVERITY_HIGH, len, s2);
359 }
360 }
361
362 /* Set the GL context error state for glGetError. */
363 if (ctx->ErrorValue == GL_NO_ERROR)
364 ctx->ErrorValue = error;
365 }
366
367 void
368 _mesa_error_no_memory(const char *caller)
369 {
370 GET_CURRENT_CONTEXT(ctx);
371 _mesa_error(ctx, GL_OUT_OF_MEMORY, "out of memory in %s", caller);
372 }
373
374 /**
375 * Report debug information. Print error message to stderr via fprintf().
376 * No-op if DEBUG mode not enabled.
377 *
378 * \param ctx GL context.
379 * \param fmtString printf()-style format string, followed by optional args.
380 */
381 void
382 _mesa_debug( const struct gl_context *ctx, const char *fmtString, ... )
383 {
384 #ifndef NDEBUG
385 char s[MAX_DEBUG_MESSAGE_LENGTH];
386 va_list args;
387 va_start(args, fmtString);
388 vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args);
389 va_end(args);
390 output_if_debug("Mesa", s, GL_FALSE);
391 #endif /* DEBUG */
392 (void) ctx;
393 (void) fmtString;
394 }
395
396
397 void
398 _mesa_log(const char *fmtString, ...)
399 {
400 char s[MAX_DEBUG_MESSAGE_LENGTH];
401 va_list args;
402 va_start(args, fmtString);
403 vsnprintf(s, MAX_DEBUG_MESSAGE_LENGTH, fmtString, args);
404 va_end(args);
405 output_if_debug(NULL, s, GL_FALSE);
406 }
407
408
409 /**
410 * Report debug information from the shader compiler via GL_ARB_debug_output.
411 *
412 * \param ctx GL context.
413 * \param type The namespace to which this message belongs.
414 * \param id The message ID within the given namespace.
415 * \param msg The message to output. Must be null-terminated.
416 */
417 void
418 _mesa_shader_debug(struct gl_context *ctx, GLenum type, GLuint *id,
419 const char *msg)
420 {
421 enum mesa_debug_source source = MESA_DEBUG_SOURCE_SHADER_COMPILER;
422 enum mesa_debug_severity severity = MESA_DEBUG_SEVERITY_HIGH;
423 int len;
424
425 _mesa_debug_get_id(id);
426
427 len = strlen(msg);
428
429 /* Truncate the message if necessary. */
430 if (len >= MAX_DEBUG_MESSAGE_LENGTH)
431 len = MAX_DEBUG_MESSAGE_LENGTH - 1;
432
433 _mesa_log_msg(ctx, source, type, *id, severity, len, msg);
434 }