2 * Management of the debugging channels
4 * Copyright 2000 Alexandre Julliard
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
22 #include "wine/port.h"
30 #include "wine/debug.h"
31 #include "wine/library.h"
32 #include "wine/unicode.h"
36 struct dll *next; /* linked list of dlls */
38 char * const *channels; /* array of channels */
39 int nb_channels; /* number of channels in array */
42 static struct dll *first_dll;
46 struct debug_option *next; /* next option in list */
47 unsigned char set; /* bits to set */
48 unsigned char clear; /* bits to clear */
49 char name[14]; /* channel name, or empty for "all" */
52 static struct debug_option *first_option;
53 static struct debug_option *last_option;
55 static const char * const debug_classes[] = { "fixme", "err", "warn", "trace" };
57 static int cmp_name( const void *p1, const void *p2 )
59 const char *name = p1;
60 const char * const *chan = p2;
61 return strcmp( name, *chan + 1 );
64 /* apply a debug option to the channels of a given dll */
65 static void apply_option( struct dll *dll, const struct debug_option *opt )
69 char **dbch = bsearch( opt->name, dll->channels, dll->nb_channels,
70 sizeof(*dll->channels), cmp_name );
71 if (dbch) **dbch = (**dbch & ~opt->clear) | opt->set;
76 for (i = 0; i < dll->nb_channels; i++)
77 dll->channels[i][0] = (dll->channels[i][0] & ~opt->clear) | opt->set;
81 /* register a new set of channels for a dll */
82 void *__wine_dbg_register( char * const *channels, int nb )
84 struct debug_option *opt = first_option;
85 struct dll *dll = malloc( sizeof(*dll) );
88 dll->channels = channels;
89 dll->nb_channels = nb;
91 if ((dll->next = first_dll)) dll->next->prev = dll;
94 /* apply existing options to this dll */
97 apply_option( dll, opt );
105 /* unregister a set of channels; must pass the pointer obtained from wine_dbg_register */
106 void __wine_dbg_unregister( void *channel )
108 struct dll *dll = channel;
111 if (dll->next) dll->next->prev = dll->prev;
112 if (dll->prev) dll->prev->next = dll->next;
113 else first_dll = dll->next;
119 /* add a new debug option at the end of the option list */
120 void wine_dbg_add_option( const char *name, unsigned char set, unsigned char clear )
122 struct dll *dll = first_dll;
123 struct debug_option *opt;
124 size_t len = strlen(name);
126 if (!(opt = malloc( sizeof(*opt) ))) return;
130 if (len >= sizeof(opt->name)) len = sizeof(opt->name) - 1;
131 memcpy( opt->name, name, len );
133 if (last_option) last_option->next = opt;
134 else first_option = opt;
137 /* apply option to all existing dlls */
140 apply_option( dll, opt );
145 /* parse a set of debugging option specifications and add them to the option list */
146 int wine_dbg_parse_options( const char *str )
148 char *opt, *next, *options;
152 if (!(options = strdup(str))) return -1;
153 for (opt = options; opt; opt = next)
156 unsigned char set = 0, clear = 0;
158 if ((next = strchr( opt, ',' ))) *next++ = 0;
160 p = opt + strcspn( opt, "+-" );
161 if (!p[0]) p = opt; /* assume it's a debug channel name */
165 for (i = 0; i < sizeof(debug_classes)/sizeof(debug_classes[0]); i++)
167 int len = strlen(debug_classes[i]);
168 if (len != (p - opt)) continue;
169 if (!memcmp( opt, debug_classes[i], len )) /* found it */
171 if (*p == '+') set |= 1 << i;
172 else clear |= 1 << i;
176 if (i == sizeof(debug_classes)/sizeof(debug_classes[0])) /* bad class name, skip it */
184 if (*p == '-') clear = ~0;
187 if (*p == '+' || *p == '-') p++;
193 if (!strcmp( p, "all" )) p = ""; /* empty string means all */
194 wine_dbg_add_option( p, set, clear );
200 /* varargs wrapper for __wine_dbg_vprintf */
201 int wine_dbg_printf( const char *format, ... )
206 va_start(valist, format);
207 ret = __wine_dbg_vprintf( format, valist );
213 /* varargs wrapper for __wine_dbg_vsprintf */
214 const char *wine_dbg_sprintf( const char *format, ... )
219 va_start(valist, format);
220 ret = __wine_dbg_vsprintf( format, valist );
226 /* varargs wrapper for __wine_dbg_vlog */
227 int wine_dbg_log( unsigned int cls, const char *channel, const char *func, const char *format, ... )
232 va_start(valist, format);
233 ret = __wine_dbg_vlog( cls, channel, func, format, valist );
239 /* allocate some tmp string space */
240 /* FIXME: this is not 100% thread-safe */
241 static char *get_tmp_space( int size )
243 static char *list[32];
248 idx = interlocked_xchg_add( &pos, 1 ) % (sizeof(list)/sizeof(list[0]));
249 if ((ret = realloc( list[idx], size ))) list[idx] = ret;
254 /* default implementation of wine_dbgstr_an */
255 static const char *default_dbgstr_an( const char *str, int n )
261 if (!str) return "(null)";
262 res = get_tmp_space( 6 );
263 sprintf( res, "#%04x", LOWORD(str) );
266 if (n == -1) n = strlen(str);
268 else if (n > 200) n = 200;
269 dst = res = get_tmp_space( n * 4 + 6 );
273 unsigned char c = *str++;
276 case '\n': *dst++ = '\\'; *dst++ = 'n'; break;
277 case '\r': *dst++ = '\\'; *dst++ = 'r'; break;
278 case '\t': *dst++ = '\\'; *dst++ = 't'; break;
279 case '"': *dst++ = '\\'; *dst++ = '"'; break;
280 case '\\': *dst++ = '\\'; *dst++ = '\\'; break;
282 if (c >= ' ' && c <= 126)
287 *dst++ = '0' + ((c >> 6) & 7);
288 *dst++ = '0' + ((c >> 3) & 7);
289 *dst++ = '0' + ((c >> 0) & 7);
305 /* default implementation of wine_dbgstr_wn */
306 static const char *default_dbgstr_wn( const WCHAR *str, int n )
312 if (!str) return "(null)";
313 res = get_tmp_space( 6 );
314 sprintf( res, "#%04x", LOWORD(str) );
317 if (n == -1) n = strlenW(str);
319 else if (n > 200) n = 200;
320 dst = res = get_tmp_space( n * 5 + 7 );
328 case '\n': *dst++ = '\\'; *dst++ = 'n'; break;
329 case '\r': *dst++ = '\\'; *dst++ = 'r'; break;
330 case '\t': *dst++ = '\\'; *dst++ = 't'; break;
331 case '"': *dst++ = '\\'; *dst++ = '"'; break;
332 case '\\': *dst++ = '\\'; *dst++ = '\\'; break;
334 if (c >= ' ' && c <= 126)
339 sprintf(dst,"%04x",c);
356 /* default implementation of wine_dbg_vsprintf */
357 static const char *default_dbg_vsprintf( const char *format, va_list args )
359 static const int max_size = 200;
361 char *res = get_tmp_space( max_size );
362 int len = vsnprintf( res, max_size, format, args );
363 if (len == -1 || len >= max_size) res[max_size-1] = 0;
367 /* default implementation of wine_dbg_vprintf */
368 static int default_dbg_vprintf( const char *format, va_list args )
370 return vfprintf( stderr, format, args );
374 /* default implementation of wine_dbg_vlog */
375 static int default_dbg_vlog( unsigned int cls, const char *channel, const char *func,
376 const char *format, va_list args )
380 if (cls < sizeof(debug_classes)/sizeof(debug_classes[0]))
381 ret += wine_dbg_printf( "%s:%s:%s ", debug_classes[cls], channel + 1, func );
383 ret += __wine_dbg_vprintf( format, args );
388 /* exported function pointers so that debugging functions can be redirected at run-time */
390 const char * (*__wine_dbgstr_an)( const char * s, int n ) = default_dbgstr_an;
391 const char * (*__wine_dbgstr_wn)( const WCHAR *s, int n ) = default_dbgstr_wn;
392 const char * (*__wine_dbg_vsprintf)( const char *format, va_list args ) = default_dbg_vsprintf;
393 int (*__wine_dbg_vprintf)( const char *format, va_list args ) = default_dbg_vprintf;
394 int (*__wine_dbg_vlog)( unsigned int cls, const char *channel, const char *function,
395 const char *format, va_list args ) = default_dbg_vlog;
397 /* wrappers to use the function pointers */
399 const char *wine_dbgstr_an( const char * s, int n )
401 return __wine_dbgstr_an(s, n);
404 const char *wine_dbgstr_wn( const WCHAR *s, int n )
406 return __wine_dbgstr_wn(s, n);
409 const char *wine_dbgstr_a( const char *s )
411 return __wine_dbgstr_an( s, -1 );
414 const char *wine_dbgstr_w( const WCHAR *s )
416 return __wine_dbgstr_wn( s, -1 );