1 /**
2 *
3 * $Header: /cvsroot/xbae/Xbae/src/DebugUtil.c,v 1.20 2005/12/19 14:59:32 tobiasoed Exp $
4 *
5 * Copyright (C) 1995 Free Software Foundation, Inc.
6 * Copyright � 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004 LessTif Development Team
7 *
8 * This file is part of the GNU LessTif Library.
9 *
10 * This library is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Library General Public
12 * License as published by the Free Software Foundation; either
13 * version 2 of the License, or (at your option) any later version.
14 *
15 * This library is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Library General Public License for more details.
19 *
20 * You should have received a copy of the GNU Library General Public
21 * License along with this library; if not, write to the Free
22 * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
23 *
24 **/
25
26 static const char rcsid[] =
27 "$Header: /cvsroot/xbae/Xbae/src/DebugUtil.c,v 1.20 2005/12/19 14:59:32 tobiasoed Exp $";
28
29 #include "XbaeConfig.h"
30
31 #include <stdlib.h>
32 #include <stdio.h>
33 #include <stdarg.h>
34 #include <string.h>
35 #include <strings.h>
36 #include <signal.h>
37 #ifdef HAVE_SYS_TYPES_H
38 #include <sys/types.h>
39 #endif
40 #include <unistd.h>
41
42 #include <X11/Intrinsic.h>
43 #include <X11/IntrinsicP.h>
44 #include <X11/Xresource.h>
45
46 #include <Xm/XmP.h>
47 #include <Xm/DrawingAP.h>
48 #include <Xm/Display.h>
49 #include <Xm/MwmUtil.h>
50
51 #include <Xbae/Utils.h>
52
53 #include <XbaeDebug.h>
54
55 #ifndef XmUNSPECIFIED
56 #define XmUNSPECIFIED (~0)
57 #endif
58
59 /*
60 * All external interfaces need to be in place for both,
61 * debug and production build. We may just reduce them
62 * to empty stubs ...
63 */
64
65 /*
66 * some #defines being used here
67 */
68 #undef DEBUGSIG /* debug the 'signal feature' */
69 #undef DEBUGVALIDATE /* debug the ValidateSource(), etc. routines */
70 #undef PRINT_STATE /* add info to __XbaeDebugPrintTree() output */
71
72
73 /*
74 * Functionality in this file is influenced at run time by these
75 * environment variables :
76 *
77 * - XBAE_DEBUG_SOURCES : colon-separated list of files from which debug output
78 * is generated.
79 * Special values "all" and "none" have obvious meaning.
80 * You may block file from the list by adding a "-" prefix,
81 * this is obviously only useful in conjunction with "all",
82 * e.g. XBAE_DEBUG_SOURCES=all:-Vendor.c:-XmString
83 * Using an asterisk as a wildcard is also supported, e.g.
84 * XBAE_DEBUG_SOURCES=Text*
85 * The code may not be failsafe for some pathological combinations,
86 * but we don't expect anyone to debug the debugging code ... ;-)
87 *
88 * - XBAE_DEBUG_PRINT_WIDGETID : if this variable exists, then all widgets printed
89 * with _XbaeDebug etc. will also print their widget ID. If the variable
90 * doesn't exist, then they only print their name for identification.
91 *
92 * - XBAE_DEBUG_FILE : if this variable exists, then the file is used for output.
93 * If "%p" is part of the value of XBAE_DEBUG_FILE, then it is replaced by the
94 * process id.
95 * "stdout" and "stderr" are recognized and have their special
96 * obvious meaning.
97 *
98 * - XBAE_DEBUG_SIGNAL: define to the macro which belongs to the signal which
99 * should be accepted by the program as a switch to toggle
100 * debugging on/off. No value or "none" will turn the feature off.
101 * Valid values are compile time dependent (WRT libXm),
102 * check below what's actually supported.
103 *
104 * - XBAE_DEBUG_TOGGLE: initial value whether debugging should be
105 * enabled or disabled upon program start. Valid Values are on/off.
106 * e.g. XBAE_DEBUG_TOGGLE=off
107 *
108 * If the C macro XBAE_PRODUCTION is defined, then _XbaeDebug etc. don't
109 * work. Note: this is a compile time option.
110 * To have maximum performance, sequences of _XbaeDebug statements should be
111 * surrounded by an if (_XbaeDebugInDebug(__FILE__, w)) statement.
112 * _XbaeDebugInDebug is False when XBAE_PRODUCTION is defined.
113 */
114
115 #ifndef XBAE_PRODUCTION
116 static Boolean _XbaeDebugFlag = True;
117 static Boolean _XbaeDebugPrintWidgetID = False;
118 static FILE *_XbaeDebugFile = NULL;
119 typedef void (*sighandler_t) (int);
120 #endif
121
122 #define _XbaeDebugNONE 0
123 #define _XbaeDebugINT 1
124 #define _XbaeDebugSTRING 2
125 #define _XbaeDebugXMSTRING 3
126 #define _XbaeDebugCHAR 4
127 #define _XbaeDebugSHORT 5
128 #define _XbaeDebugATTACHMENT 6
129 #define _XbaeDebugWIDGET 7
130 #define _XbaeDebugBOOLEAN 8
131 #define _XbaeDebugSELECTION_POLICY 9
132 #define _XbaeDebugXMSTRING_LIST 10 /* bingo */
133 #define _XbaeDebugDIALOG_STYLE 11
134 #define _XbaeDebugEDIT_MODE 12
135 #define _XbaeDebugALIGNMENT 13
136 #define _XbaeDebugSB_DISPLAY_POLICY 14
137 #define _XbaeDebugLIST_SIZE_POLICY 15
138 #define _XbaeDebugSB_PLACEMENT 16
139 #define _XbaeDebugRESIZE_POLICY 17
140 #define _XbaeDebugCOMBOBOX_TYPE 18
141 #define _XbaeDebugSCROLLING_POLICY 19
142 #define _XbaeDebugDRAG_TYPE 20
143 #define _XbaeDebugMWM_INPUT_MODE 21
144 #define _XbaeDebugDELETE_RESPONSE 22
145
146
147
148 /* *INDENT-OFF* */
149
150 static const struct
151 {
152 const char *name;
153 int t;
154 const char *related;
155 } _XbaeDebugTypes[] =
156 {
157 { XmNdragInitiatorProtocolStyle, _XbaeDebugDRAG_TYPE, NULL } ,
158 { XmNdragReceiverProtocolStyle, _XbaeDebugDRAG_TYPE, NULL } ,
159 { XmNscrollingPolicy, _XbaeDebugSCROLLING_POLICY, NULL } ,
160 { XmNmaximum, _XbaeDebugINT, NULL } ,
161 { XmNminimum, _XbaeDebugINT, NULL } ,
162 { XmNsliderSize, _XbaeDebugINT, NULL } ,
163 { XmNpageIncrement, _XbaeDebugINT, NULL } ,
164 { XmNincrement, _XbaeDebugINT, NULL } ,
165 { XmNx, _XbaeDebugINT, NULL } ,
166 { XmNy, _XbaeDebugINT, NULL } ,
167 { XmNwidth, _XbaeDebugINT, NULL } ,
168 { XmNheight, _XbaeDebugINT, NULL } ,
169 { XmNlabelString, _XbaeDebugXMSTRING, NULL } ,
170 { XmNmessageString, _XbaeDebugXMSTRING, NULL } ,
171 { XmNrowColumnType, _XbaeDebugNONE, NULL } ,
172 { XmNbuttonSet, _XbaeDebugNONE, NULL } ,
173 { XmNbuttonCount, _XbaeDebugINT, NULL } ,
174 { XmNoptionLabel, _XbaeDebugXMSTRING, NULL } ,
175 { XmNdirectory, _XbaeDebugXMSTRING, NULL } ,
176 { XmNoptionMnemonic, _XbaeDebugCHAR, NULL } ,
177 { XmNrows, _XbaeDebugSHORT, NULL } ,
178 { XmNcolumns, _XbaeDebugSHORT, NULL } ,
179 { XmNmarginWidth, _XbaeDebugINT, NULL } ,
180 { XmNmarginHeight, _XbaeDebugINT, NULL } ,
181 { XmNmarginTop, _XbaeDebugINT, NULL } ,
182 { XmNmarginBottom, _XbaeDebugINT, NULL } ,
183 { XmNmarginLeft, _XbaeDebugINT, NULL } ,
184 { XmNmarginRight, _XbaeDebugINT, NULL } ,
185 { XmNselectionArrayCount, _XbaeDebugINT, NULL } ,
186 { XmNshadowThickness, _XbaeDebugINT, NULL } ,
187 { XmNhighlightThickness, _XbaeDebugINT, NULL } ,
188 { XmNtopAttachment, _XbaeDebugATTACHMENT, NULL } ,
189 { XmNbottomAttachment, _XbaeDebugATTACHMENT, NULL } ,
190 { XmNleftAttachment, _XbaeDebugATTACHMENT, NULL } ,
191 { XmNrightAttachment, _XbaeDebugATTACHMENT, NULL } ,
192 { XmNtopOffset, _XbaeDebugINT, NULL } ,
193 { XmNbottomOffset, _XbaeDebugINT, NULL } ,
194 { XmNleftOffset, _XbaeDebugINT, NULL } ,
195 { XmNrightOffset, _XbaeDebugINT, NULL } ,
196 { XmNtopPosition, _XbaeDebugINT, NULL } ,
197 { XmNbottomPosition, _XbaeDebugINT, NULL } ,
198 { XmNleftPosition, _XbaeDebugINT, NULL } ,
199 { XmNrightPosition, _XbaeDebugINT, NULL } ,
200 { XmNdefaultButton, _XbaeDebugWIDGET, NULL } ,
201 { XmNmessageWindow, _XbaeDebugWIDGET, NULL } ,
202 { XmNtopWidget, _XbaeDebugWIDGET, NULL } ,
203 { XmNbottomWidget, _XbaeDebugWIDGET, NULL } ,
204 { XmNleftWidget, _XbaeDebugWIDGET, NULL } ,
205 { XmNrightWidget, _XbaeDebugWIDGET, NULL } ,
206 { XmNsensitive, _XbaeDebugBOOLEAN, NULL } ,
207 { XmNresizable, _XbaeDebugBOOLEAN, NULL } ,
208 { XmNmustMatch, _XbaeDebugBOOLEAN, NULL } ,
209 { XmNresizeHeight, _XbaeDebugBOOLEAN, NULL } ,
210 { XmNresizeWidth, _XbaeDebugBOOLEAN, NULL } ,
211 { XmNfractionBase, _XbaeDebugINT, NULL } ,
212 { XmNhorizontalSpacing, _XbaeDebugINT, NULL } ,
213 { XmNverticalSpacing, _XbaeDebugINT, NULL } ,
214 { XmNrubberPositioning, _XbaeDebugBOOLEAN, NULL } ,
215 { XmNitemCount, _XbaeDebugINT, NULL } ,
216 { XmNfileListItemCount, _XbaeDebugINT, NULL } ,
217 { XmNtextString, _XbaeDebugXMSTRING, NULL } ,
218 { XmNdirSpec, _XbaeDebugXMSTRING, NULL } ,
219 { XmNdirMask, _XbaeDebugXMSTRING, NULL } ,
220 { XmNitems, _XbaeDebugXMSTRING_LIST, XmNitemCount } , /* bingo */
221 { XmNselectionPolicy, _XbaeDebugSELECTION_POLICY, NULL } ,
222 { XmNautoUnmanage, _XbaeDebugBOOLEAN, NULL } ,
223 { XmNdialogStyle, _XbaeDebugDIALOG_STYLE, NULL } ,
224 { XmNshowAsDefault, _XbaeDebugSHORT, NULL } ,
225 { XmNeditable, _XbaeDebugBOOLEAN, NULL } ,
226 { XmNmaxLength, _XbaeDebugINT, NULL } ,
227 { XmNdirListItemCount, _XbaeDebugINT, NULL } ,
228 { XmNfileListItemCount, _XbaeDebugINT, NULL } ,
229 { XmNeditMode, _XbaeDebugEDIT_MODE, NULL } ,
230 { XmNalignment, _XbaeDebugALIGNMENT, NULL } ,
231 { XmNrecomputeSize, _XbaeDebugBOOLEAN, NULL } ,
232 { XmNdirectoryValid, _XbaeDebugBOOLEAN, NULL } ,
233 { XmNlistUpdated, _XbaeDebugBOOLEAN, NULL } ,
234 { XmNhorizontalScrollBar, _XbaeDebugWIDGET, NULL } ,
235 { XmNverticalScrollBar, _XbaeDebugWIDGET, NULL } ,
236 { XmNworkWindow, _XbaeDebugWIDGET, NULL } ,
237 { XmNmenuBar, _XbaeDebugWIDGET, NULL } ,
238 { XmNcommandWindow, _XbaeDebugWIDGET, NULL } ,
239 { XmNvisibleItemCount, _XbaeDebugSHORT, NULL } ,
240 { XmNdefaultButtonShadowThickness, _XbaeDebugSHORT, NULL } ,
241 { XmNset, _XbaeDebugBOOLEAN, NULL } ,
242 { XmNtraversalOn, _XbaeDebugBOOLEAN, NULL } ,
243 { XmNspacing, _XbaeDebugSHORT, NULL } ,
244 { XmNscrollBarDisplayPolicy, _XbaeDebugSB_DISPLAY_POLICY, NULL } ,
245 { XmNlistSizePolicy, _XbaeDebugLIST_SIZE_POLICY, NULL } ,
246 { XmNscrollBarPlacement, _XbaeDebugSB_PLACEMENT, NULL } ,
247 { XmNuserData, _XbaeDebugNONE, NULL } ,
248 { XmNallowShellResize, _XbaeDebugBOOLEAN, NULL } ,
249 { XmNresizePolicy, _XbaeDebugRESIZE_POLICY, NULL } ,
250 { XmNradioBehavior, _XbaeDebugBOOLEAN, NULL } ,
251 { XmNradioAlwaysOne, _XbaeDebugBOOLEAN, NULL } ,
252 { XmNnumColumns, _XbaeDebugSHORT, NULL } ,
253 { XmNinitialFocus, _XbaeDebugWIDGET, NULL } ,
254 { XmNmwmInputMode, _XbaeDebugMWM_INPUT_MODE, NULL } ,
255 { XmNmappedWhenManaged, _XbaeDebugBOOLEAN, NULL } ,
256 { XmNdeleteResponse, _XbaeDebugDELETE_RESPONSE, NULL } ,
257 { XmNwidthInc, _XbaeDebugSHORT, NULL } ,
258 { XmNheightInc, _XbaeDebugSHORT, NULL } ,
259 { XmNbaseWidth, _XbaeDebugSHORT, NULL } ,
260 { XmNbaseHeight, _XbaeDebugSHORT, NULL } ,
261 { XmNminWidth, _XbaeDebugSHORT, NULL } ,
262 { XmNminHeight, _XbaeDebugSHORT, NULL } ,
263 { XmNtitle, _XbaeDebugSTRING, NULL } ,
264 { XmNiconName, _XbaeDebugSTRING, NULL } ,
265 { XmNcancelLabelString, _XbaeDebugXMSTRING, NULL } ,
266 #if XmVERSION > 1
267 { XmNcomboBoxType, _XbaeDebugCOMBOBOX_TYPE, NULL } ,
268 { XmNlargeCellWidth, _XbaeDebugINT, NULL } ,
269 { XmNlargeCellHeight, _XbaeDebugINT, NULL } ,
270 #endif
271 { XmNacceleratorText, _XbaeDebugXMSTRING, NULL },
272 { NULL, 0, NULL }
273 /* the end */
274 };
275
276 /* *INDENT-ON* */
277
278 /**************************************************************************************************/
279
280 #ifndef XBAE_PRODUCTION
281 /* strcasecmp() is not always available */
xbaeStrcasecmp(const char * s1,const char * s2)282 static int xbaeStrcasecmp(const char *s1, const char *s2)
283 {
284 #ifdef HAVE_STRNCASECMP
285 return strcasecmp(s1, s2);
286 #else
287 #ifdef HAVE_STRNICMP
288 return stricmp(s1, s2);
289 #else
290 int c1, c2;
291
292 while (*s1 && *s2) {
293 c1 = tolower(*s1);
294 c2 = tolower(*s2);
295 if (c1 != c2) {
296 return (c1 - c2);
297 }
298 s1++;
299 s2++;
300 }
301 return (int) (*s1 - *s2);
302 #endif
303 #endif
304 }
305 #endif
306
307 #ifndef XBAE_PRODUCTION
308 /* catches the signal defined by XBAE_DEBUG_SIGNAL and toggles the
309 global debugging flag.
310 Avoid calling C-runtime functions from within here if possible
311 (which in turn might also raise signals) */
sighandler(int signo)312 static void sighandler(int signo)
313 {
314
315 #ifdef DEBUGSIG
316 fputs("sighandler(): signal caught\n", stderr);
317 #endif
318
319 /* switch debugging on/off */
320 _XbaeDebugToggle();
321 /* re-install ourselves: perhaps not always necessary, but OTOH
322 it shouldn't hurt!? */
323 signal(signo, sighandler);
324 }
325 #endif /* XBAE_PRODUCTION */
326
327
328 #ifndef XBAE_PRODUCTION
siginstall(void)329 static Boolean siginstall(void)
330 {
331 const char *ptr;
332 #define NOSIG -1
333 int signo = NOSIG;
334
335 ptr = getenv("XBAE_DEBUG_SIGNAL");
336 if (ptr) {
337 #ifdef DEBUGSIG
338 fprintf(stderr, "siginstall(): trying to catch %s\n", ptr);
339 #endif
340 if ((*ptr == '\0') || (xbaeStrcasecmp(ptr, "none") == 0)) {
341 fprintf(stderr, "siginstall(): empty value for XBAE_DEBUG_SIGNAL\n");
342 }
343 #if defined(SIGBREAK)
344 else if (strcmp(ptr, "SIGBREAK") == 0)
345 signo = SIGBREAK;
346 #endif
347 #if defined(SIGUNUSED)
348 else if (strcmp(ptr, "SIGUNUSED") == 0)
349 signo = SIGUNUSED;
350 #endif
351 #if defined(SIGUSR1)
352 else if (strcmp(ptr, "SIGUSR1") == 0)
353 signo = SIGUSR1;
354 #endif
355 #if defined(SIGUSR2)
356 else if (strcmp(ptr, "SIGUSR2") == 0)
357 signo = SIGUSR2;
358 #endif
359 #if defined(SIGUSR3)
360 else if (strcmp(ptr, "SIGUSR3") == 0)
361 signo = SIGUSR3;
362 #endif
363 else
364 fprintf(stderr, "siginstall(): unknown signal in XBAE_DEBUG_SIGNAL: %s\n", ptr);
365 }
366
367 if (signo == NOSIG) {
368 return False;
369 } else {
370 sighandler_t sigrc;
371
372 #ifdef DEBUGSIG
373 fprintf(stderr, "siginstall(): installing %p on signal %i\n", sighandler, signo);
374 #endif
375 sigrc = signal(signo, sighandler);
376 if (sigrc == SIG_ERR)
377 return False;
378 else
379 return True;
380 }
381 }
382 #endif /* XBAE_PRODUCTION */
383
384 /**************************************************************************************************/
385
386 #ifndef XBAE_PRODUCTION
_XbaeDebugOpenFile(void)387 static void _XbaeDebugOpenFile(void)
388 {
389 const char *s;
390 char *fn;
391
392 if (_XbaeDebugFile) {
393 /* already done */
394 return;
395 }
396
397 /* The rest here is the initialization code.
398 Might be slow and long, since it's done only once */
399
400 s = getenv("XBAE_DEBUG_FILE");
401 if ((s == NULL) || (*s == '\0') || ((strcmp(s, "stderr") == 0)))
402 _XbaeDebugFile = stderr; /* default/fallback value */
403 else if (strcmp(s, "stdout") == 0)
404 /* the user wants to mix our output with the stdout of the
405 * user application.
406 */
407 _XbaeDebugFile = stdout;
408
409 if (_XbaeDebugFile) {
410 /* disable buffering for stdout/stderr */
411 setbuf(_XbaeDebugFile, NULL);
412 return;
413 }
414 #ifdef HAVE_GETPID
415 if (strstr(s, "%p")) {
416 char *formatstr, *p;
417
418 fn = XtMalloc(strlen(s) + 10);
419 formatstr = XtMalloc(strlen(s) + 1);
420 strcpy(formatstr, s);
421 p = strstr(formatstr, "%p");
422 *(p + 1) = 'd';
423 sprintf(fn, s, getpid());
424 XtFree(formatstr);
425 } else
426 #endif /* HAVE_GETPID */
427 {
428 fn = XtMalloc(strlen(s) + 1);
429 strcpy(fn, s);
430 }
431
432 /* "a" means append, create if doesn't exist */
433 _XbaeDebugFile = fopen(fn, "a");
434 if (_XbaeDebugFile == NULL) {
435 /* if fopen() fails do something reasonable */
436 fprintf(stderr, "_XbaeDebugOpenFile(): Can't open file %s\n", fn);
437 _XbaeDebugFile = stderr;
438 /* disable buffering */
439 setbuf(_XbaeDebugFile, NULL);
440 } else {
441 /* disable buffering for file */
442 setbuf(_XbaeDebugFile, NULL);
443 }
444 XtFree(fn);
445 }
446 #endif /* XBAE_PRODUCTION */
447
448 /*
449 * See if 'fn' refers to a source file which is allowed to produce
450 * debugging output.
451 * The ".c" suffix for sources is not required (i.e. Form is equivalent
452 * to Form.c).
453 */
454 #ifndef XBAE_PRODUCTION
ValidateSource(const char * fn)455 static Boolean ValidateSource(const char *fn)
456 {
457 static Boolean init = False;
458
459 typedef struct {
460 char *fn;
461 Boolean shortmatch;
462 size_t len;
463 } list_entry_t;
464
465 static list_entry_t *poslist = NULL;
466 static list_entry_t *neglist = NULL;
467 static int positems = 0;
468 static int negitems = 0;
469 static Boolean flag_all = False;
470 static Boolean flag_none = False;
471
472 if (!init) {
473 const char *sourcelist;
474
475 /* Do initialization once and for all.
476 Might be a long, slow procedure, but should speed all
477 upcoming calls to this routine! */
478 sourcelist = getenv("XBAE_DEBUG_SOURCES");
479 if (sourcelist == NULL) {
480 /* for compatibility with earlier versions */
481 sourcelist = getenv("XBAE_DEBUGSOURCES");
482 }
483
484 /* set some flags to indicate situations where no explicit
485 search is later on required */
486
487 /* list does not exist, is empty or set to "none" */
488 if (sourcelist == NULL || sourcelist[0] =='\0' || (xbaeStrcasecmp(sourcelist, "none") == 0)) {
489 flag_none = True;
490 } else if (xbaeStrcasecmp(sourcelist, "all") == 0) {
491 flag_all = True;
492 } else {
493 const char *s, *p;
494
495 s = sourcelist;
496 while (s && *s) {
497 char *dotptr, *asteriskptr;
498 list_entry_t *newitem;
499 Cardinal len;
500
501 p = strchr(s, ':');
502 if (p)
503 len = (p - s);
504 else
505 len = strlen(s);
506
507 if (*s == '-') {
508 /* cut the '-' out: */
509 len--;
510 s++;
511
512 neglist =
513 (list_entry_t *) XtRealloc((char *) neglist,
514 sizeof(list_entry_t) * (negitems + 1));
515 newitem = neglist + negitems;
516 negitems++;
517 } else {
518 poslist =
519 (list_entry_t *) XtRealloc((char *) poslist,
520 sizeof(list_entry_t) * (positems + 1));
521 newitem = poslist + positems;
522 positems++;
523 }
524
525 newitem->fn = XtMalloc(len + 1);
526 strncpy(newitem->fn, s, len);
527 newitem->fn[len] = '\0';
528
529 /* Cut the file extensions */
530 if ((dotptr = strrchr(newitem->fn, '.')))
531 *dotptr = '\0';
532
533 /* Check for shortmatch, asterisk */
534 if ((asteriskptr = strchr(newitem->fn, '*'))) {
535 *asteriskptr = '\0';
536 newitem->shortmatch = True;
537 newitem->len = strlen(newitem->fn);
538 } else {
539 newitem->shortmatch = False;
540 newitem->len = 0;
541 }
542
543 /* proceed to next entry */
544 if (p)
545 s = p + 1;
546 else
547 s = p;
548 } /* while() */
549 }
550
551 init = True;
552
553 #ifdef DEBUGVALIDATE
554 {
555 int i;
556 fprintf(stderr, "VS() init\n");
557 for (i = 0; i < positems; i++) {
558 fprintf(stderr, "positem[%i]=%s # Short=%i\n",
559 i, poslist[i].fn, poslist[i].shortmatch);
560 }
561 for (i = 0; i < negitems; i++) {
562 fprintf(stderr, "negitem[%i]=%s # Short=%i\n",
563 i, neglist[i].fn, neglist[i].fn.shortmatch);
564 }
565 }
566 #endif
567 }
568
569 /* the most simple cases: */
570 if (flag_none) {
571 return False;
572 } else if (flag_all) {
573 return True;
574 } else {
575 /* OK, we need to check explicitly ... */
576 const char *lastslash;
577 char *lastdot;
578 char shortfn[256]; /* dynamic memory would be too 'expensive' */
579
580 /* First we have to prepare the file name as passed to this routine:
581 the __FILE__ macro as inserted from CPP may contain an optional path
582 and certainly features a file extension (".c").
583 Our XBAE_DEBUG_SOURCES shouldn't have this, so we have to strip that. */
584
585 lastslash = strrchr(fn, '/');
586 if (lastslash && *(lastslash + 1) != '\0')
587 strncpy(shortfn, lastslash + 1, sizeof(shortfn) - 1);
588 else
589 strncpy(shortfn, fn, sizeof(shortfn) - 1);
590 lastdot = strrchr(shortfn, '.');
591 if (lastdot)
592 *lastdot = '\0';
593
594 if (negitems > 0) {
595 /* we have a negative list -> return true unless the file is on the list */
596 int i;
597 for (i = 0; i < negitems; i++) {
598 if ( (neglist[i].shortmatch && strncmp(shortfn, neglist[i].fn, neglist[i].len) == 0)
599 || strcmp(shortfn, neglist[i].fn) == 0) {
600 return False;
601 }
602 }
603 return True;
604 } else {
605 /* we have a positive list -> return false unless the file is on the list */
606 int i;
607 for (i = 0; i < positems; i++) {
608 if ( (poslist[i].shortmatch && strncmp(shortfn, poslist[i].fn, poslist[i].len) == 0)
609 || strcmp(shortfn, poslist[i].fn) == 0) {
610 return True;
611 }
612 }
613 return False; /* no matching entry found */
614 }
615 }
616 }
617 #endif /* XBAE_PRODUCTION */
618
619 /**************************************************************************************************/
620
621 /* some initialization.
622 Does never fail; return value indicates whether debugging
623 is en- or disabled currently */
_XbaeDebugInit(void)624 extern Boolean _XbaeDebugInit(void)
625 {
626 #ifdef XBAE_PRODUCTION
627 return False;
628 #else
629 static Boolean init = False;
630
631 if (!init){
632 const char *ptr;
633
634 ptr = getenv("XBAE_DEBUG_TOGGLE");
635 if (ptr && (strcmp(ptr, "off") == 0))
636 _XbaeDebugFlag = False;
637
638 ptr = getenv("XBAE_DEBUG_PRINT_WIDGETID");
639 if (ptr)
640 _XbaeDebugPrintWidgetID = True;
641
642 _XbaeDebugOpenFile();
643 siginstall();
644 init = True;
645 }
646 return _XbaeDebugFlag;
647 #endif
648 }
649
650 /**************************************************************************************************/
651
652 /* amai: why does it take a widget here as an argument; any good
653 reason for it?? */
654
655 #ifdef _XbaeDebugInDebug
656 #undef _XbaeDebugInDebug
657 #endif
_XbaeDebugInDebug(const char * fn,Widget w)658 extern Boolean _XbaeDebugInDebug(const char *fn, Widget w)
659 {
660 #ifdef XBAE_PRODUCTION
661 return False;
662 #else
663 return ValidateSource(fn);
664 #endif
665 }
666
667
668 /* Allow user to query the state of Debugging System */
_XbaeDebugQueryState(void)669 extern Boolean _XbaeDebugQueryState(void)
670 {
671 #ifndef XBAE_PRODUCTION
672 return _XbaeDebugFlag;
673 #else
674 return False;
675 #endif
676 }
677
678
679 /* extern interface to turn on/off debugging output */
_XbaeDebugSet(Boolean flag)680 extern void _XbaeDebugSet(Boolean flag)
681 {
682 #ifndef XBAE_PRODUCTION
683 if (flag)
684 _XbaeDebugFlag = True;
685 else
686 _XbaeDebugFlag = False;
687 #endif
688 }
689
690
691 /* In rare circumstances when one can't afford to code in
692 arguments to a function call for _LtSetDebug() here's
693 an alternative call */
_XbaeDebugToggle(void)694 extern void _XbaeDebugToggle(void)
695 {
696 #ifndef XBAE_PRODUCTION
697 _XbaeDebugFlag = !_XbaeDebugFlag;
698 #endif
699 }
700
701 /**************************************************************************************************/
702
_XbaeDebug(const char * fn,Widget w,const char * fmt,...)703 extern void _XbaeDebug(const char *fn, Widget w, const char *fmt, ...)
704 {
705 #ifndef XBAE_PRODUCTION
706 va_list ap;
707
708 #ifdef DEBUGVALIDATE
709 fprintf(stderr, "ValidateSource(%s)=%s\n", fn, _XbaeDebugBoolean2String(ValidateSource(fn)));
710 #endif
711 if (_XbaeDebugInit() && ValidateSource(fn)) {
712 if (w) {
713 if (_XbaeDebugPrintWidgetID) {
714 fprintf(_XbaeDebugFile, "%s %s [%p]: ",
715 w->core.widget_class->core_class.class_name, XtName(w), w);
716 } else {
717 fprintf(_XbaeDebugFile, "%s %s: ",
718 w->core.widget_class->core_class.class_name, XtName(w));
719 }
720 } else {
721 fprintf(_XbaeDebugFile, "(null widget): ");
722 }
723
724 va_start(ap, fmt);
725 vfprintf(_XbaeDebugFile, fmt, ap);
726 va_end(ap);
727
728 fflush(_XbaeDebugFile);
729 }
730 #endif /* !XBAE_PRODUCTION */
731 }
732
733
_XbaeDebug2(const char * fn,Widget w,Widget c,const char * fmt,...)734 extern void _XbaeDebug2(const char *fn, Widget w, Widget c, const char *fmt, ...)
735 {
736 #ifndef XBAE_PRODUCTION
737 va_list ap;
738
739 if (_XbaeDebugInit() && ValidateSource(fn)) {
740 if (w && c) {
741 if (_XbaeDebugPrintWidgetID) {
742 fprintf(_XbaeDebugFile, "%s %s [%p] (child %s [%p]): ",
743 w->core.widget_class->core_class.class_name, XtName(w), w, XtName(c), c);
744 } else {
745 fprintf(_XbaeDebugFile, "%s %s (child %s): ",
746 w->core.widget_class->core_class.class_name, XtName(w), XtName(c));
747 }
748 } else if (w) {
749 if (_XbaeDebugPrintWidgetID) {
750 fprintf(_XbaeDebugFile, "%s %s [%p] (child NULL): ",
751 w->core.widget_class->core_class.class_name, XtName(w), w);
752 } else {
753 fprintf(_XbaeDebugFile, "%s %s (child NULL): ",
754 w->core.widget_class->core_class.class_name, XtName(w));
755 }
756 } else {
757 fprintf(_XbaeDebugFile, "(null widget): ");
758 }
759
760 va_start(ap, fmt);
761 vfprintf(_XbaeDebugFile, fmt, ap);
762 va_end(ap);
763 }
764 #endif /* !XBAE_PRODUCTION */
765 }
766
767
_XbaeDebug0(const char * fn,Widget w,const char * fmt,...)768 extern void _XbaeDebug0(const char *fn, Widget w, const char *fmt, ...)
769 {
770 #ifndef XBAE_PRODUCTION
771 va_list ap;
772
773 if (_XbaeDebugInit() && ValidateSource(fn)) {
774 va_start(ap, fmt);
775 vfprintf(_XbaeDebugFile, fmt, ap);
776 va_end(ap);
777 }
778 #endif /* !XBAE_PRODUCTION */
779 }
780
781
_XbaeDebugPrintArgList(const char * fn,Widget w,ArgList al,int n,Boolean Get)782 extern void _XbaeDebugPrintArgList(const char *fn, Widget w, ArgList al, int n, Boolean Get)
783 {
784 #ifndef XBAE_PRODUCTION
785 int i;
786 unsigned num;
787
788 if (_XbaeDebugInit() && ValidateSource(fn)) {
789
790 for (i = 0; i < n; i++) {
791 int at;
792
793 for (at = 0; _XbaeDebugTypes[at].name; at++) {
794 if (strcmp(al[i].name, _XbaeDebugTypes[at].name) == 0) {
795 break;
796 }
797 }
798
799 if (_XbaeDebugTypes[at].name == NULL) {
800 fprintf(_XbaeDebugFile, "Arg[%d] : %s (not handled FIX ME)\n", i, al[i].name);
801 continue;
802 }
803
804 switch (_XbaeDebugTypes[at].t) {
805 case _XbaeDebugNONE:
806 fprintf(_XbaeDebugFile, "Arg[%d] : %s\n", i, al[i].name);
807 break;
808
809 case _XbaeDebugINT:
810 fprintf(_XbaeDebugFile, "Arg[%d] : %s %d\n", i, al[i].name,
811 (Get) ? *(int *) al[i].value : (int) al[i].value);
812 break;
813
814 case _XbaeDebugSHORT:
815 fprintf(_XbaeDebugFile, "Arg[%d] : %s %d\n", i, al[i].name,
816 (Get) ? *(short *) al[i].value : (short) al[i].value);
817 break;
818
819 case _XbaeDebugSTRING:
820 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name, (char *) al[i].value);
821 break;
822
823 case _XbaeDebugXMSTRING:
824 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
825 _XbaeDebugXmString2String((XmString) al[i].value));
826 break;
827
828 case _XbaeDebugCHAR:
829 fprintf(_XbaeDebugFile, "Arg[%d] : %s %c\n", i, al[i].name, (char) al[i].value);
830 break;
831
832 case _XbaeDebugALIGNMENT:
833 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
834 (Get) ? _XbaeDebugAlignment2String(*(unsigned char *) al[i].value)
835 : _XbaeDebugAlignment2String((unsigned char) al[i].value));
836 break;
837
838 case _XbaeDebugRESIZE_POLICY:
839 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
840 (Get) ? _XbaeDebugResizePolicy2String(*(unsigned char *) al[i].value)
841 : _XbaeDebugResizePolicy2String((unsigned char) al[i].value));
842 break;
843
844 case _XbaeDebugSB_DISPLAY_POLICY:
845 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
846 (Get) ? _XbaeDebugSBDisplayPolicy2String(*(unsigned char *) al[i].value)
847 : _XbaeDebugSBDisplayPolicy2String((unsigned char) al[i].value));
848 break;
849
850 case _XbaeDebugDRAG_TYPE:
851 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
852 (Get) ? _XbaeDebugDragType2String(*(unsigned char *) al[i].value)
853 : _XbaeDebugDragType2String((unsigned char) al[i].value));
854 break;
855
856 case _XbaeDebugSCROLLING_POLICY:
857 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
858 (Get) ? _XbaeDebugScrollingPolicy2String(*(unsigned char *) al[i].value)
859 : _XbaeDebugScrollingPolicy2String((unsigned char) al[i].value));
860 break;
861
862 case _XbaeDebugSB_PLACEMENT:
863 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
864 (Get) ? _XbaeDebugSBPlacement2String(*(unsigned char *) al[i].value)
865 : _XbaeDebugSBPlacement2String((unsigned char) al[i].value));
866 break;
867
868 case _XbaeDebugLIST_SIZE_POLICY:
869 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
870 (Get) ? _XbaeDebugListSizePolicy2String(*(unsigned char *) al[i].value)
871 : _XbaeDebugListSizePolicy2String((unsigned char) al[i].value));
872 break;
873
874 case _XbaeDebugATTACHMENT:
875 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
876 (Get) ? _XbaeDebugAttachment2String(*(unsigned char *) al[i].value)
877 : _XbaeDebugAttachment2String((unsigned char) al[i].value));
878 break;
879
880 case _XbaeDebugDIALOG_STYLE:
881 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
882 (Get) ? _XbaeDebugDialogStyle2String(*(unsigned char *) al[i].value)
883 : _XbaeDebugDialogStyle2String((unsigned char) al[i].value));
884 break;
885
886 case _XbaeDebugWIDGET:
887 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name, (Get)
888 ? ((al[i].value && *(Widget *) al[i].value)
889 ? XtName(*(Widget *) al[i].value)
890 : "(null)")
891 : (al[i].value ? XtName((Widget) al[i].value)
892 : "(null)"));
893 break;
894
895 case _XbaeDebugEDIT_MODE:
896 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
897 (Get) ? _XbaeDebugEditMode2String(*(Boolean *) al[i].value)
898 : _XbaeDebugEditMode2String((Boolean) al[i].value));
899 break;
900
901 case _XbaeDebugBOOLEAN:
902 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
903 (Get) ? _XbaeDebugBoolean2String(*(Boolean *) al[i].value)
904 : _XbaeDebugBoolean2String((Boolean) al[i].value));
905 break;
906
907 case _XbaeDebugSELECTION_POLICY:
908 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
909 _XbaeDebugSelectionPolicy2String(al[i].value));
910 break;
911
912 case _XbaeDebugXMSTRING_LIST: /* Need related info !! */
913 num = 0xdeadbeef;
914
915 XtVaGetValues(w, _XbaeDebugTypes[at].related, &num, NULL);
916
917 if (num != 0xdeadbeef) {
918 int j;
919
920 fprintf(_XbaeDebugFile, "Arg[%d] : %s(%d):\n", i, al[i].name, num);
921 for (j = 0; j < (int) num; j++) {
922 fprintf(_XbaeDebugFile, "\tItem %d '%s'\n", j,
923 _XbaeDebugXmString2String(((XmString *) (al[i].value))[j]));
924 }
925 }
926
927 break;
928
929 case _XbaeDebugMWM_INPUT_MODE:
930 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
931 (Get) ? _XbaeDebugMwmInput2String(*(int *) al[i].value)
932 : _XbaeDebugMwmInput2String((int) al[i].value));
933 break;
934
935 case _XbaeDebugDELETE_RESPONSE:
936 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
937 (Get) ? _XbaeDebugDeleteResponse2String(*(int *) al[i].value) :
938 _XbaeDebugDeleteResponse2String((int) al[i].value));
939 break;
940
941 #if XmVERSION > 1
942 case _XbaeDebugCOMBOBOX_TYPE:
943 fprintf(_XbaeDebugFile, "Arg[%d] : %s %s\n", i, al[i].name,
944 _XbaeDebugComboBoxType2String(al[i].value));
945 break;
946 #endif
947
948 }
949 }
950 }
951 #endif /* !XBAE_PRODUCTION */
952 }
953
954
955 extern void
_XbaeDebugAction(const char * fn,Widget w,const String action,const String * params,const Cardinal * num_params)956 _XbaeDebugAction(const char *fn, Widget w, const String action,
957 const String * params, const Cardinal * num_params)
958 {
959 #ifndef XBAE_PRODUCTION
960
961 if (_XbaeDebugInit() && ValidateSource(fn)) {
962 int i;
963
964 if (w) {
965 if (_XbaeDebugPrintWidgetID) {
966 fprintf(_XbaeDebugFile, "%s %s [%p]: ",
967 w->core.widget_class->core_class.class_name, XtName(w), w);
968 } else {
969 fprintf(_XbaeDebugFile, "%s %s: ",
970 w->core.widget_class->core_class.class_name, XtName(w));
971 }
972 } else {
973 fprintf(_XbaeDebugFile, "(null widget): ");
974 }
975
976 fprintf(_XbaeDebugFile, "Action %s(", action);
977 if (*num_params) {
978 fprintf(_XbaeDebugFile, "%s", params[0]);
979 }
980 for (i = 1; i < (int) *num_params; i++) {
981 fprintf(_XbaeDebugFile, ", %s", params[i]);
982 }
983 fprintf(_XbaeDebugFile, ")\n");
984
985 fflush(_XbaeDebugFile);
986 }
987 #endif /* !XBAE_PRODUCTION */
988 }
989
990 /**************************************************************************************************/
991
992 #ifndef XBAE_PRODUCTION
__XbaeDebugPrintTree(Widget w,int level)993 static void __XbaeDebugPrintTree(Widget w, int level)
994 {
995 int i;
996 Cardinal c;
997 CompositeWidget cw = (CompositeWidget) w;
998
999 if (w == NULL) {
1000 return;
1001 }
1002
1003 for (i = 0; i < level; i++) {
1004 fprintf(_XbaeDebugFile, "\t");
1005 }
1006
1007 fprintf(_XbaeDebugFile, "%s : %p/%ld", XtName(w), w, XtWindow(w));
1008 fprintf(_XbaeDebugFile, "(%s) geo %d %d %d %d",
1009 w->core.widget_class->core_class.class_name, XtX(w), XtY(w), XtWidth(w), XtHeight(w));
1010 #ifdef PRINT_STATE
1011 fprintf(_XbaeDebugFile, " state: %s %s",
1012 _XbaeDebugState(w), w->core.mapped_when_managed ? "mwm" : "");
1013 #endif
1014 fprintf(_XbaeDebugFile, "\n");
1015 if (XtIsSubclass(w, compositeWidgetClass)) {
1016 for (c = 0; c < cw->composite.num_children; c++) {
1017 __XbaeDebugPrintTree(cw->composite.children[c], level + 1);
1018 }
1019 }
1020
1021 for (c = 0; c < cw->core.num_popups; c++) {
1022 __XbaeDebugPrintTree(cw->core.popup_list[c], level + 1);
1023 }
1024 }
1025 #endif
1026
1027
_XbaeDebugPrintTree(Widget w)1028 extern void _XbaeDebugPrintTree(Widget w)
1029 {
1030 #ifndef XBAE_PRODUCTION
1031 if (_XbaeDebugInit()) {
1032 __XbaeDebugPrintTree(w, 0);
1033 }
1034 #endif
1035 }
1036
1037
_XbaeDebugPrintCompleteTree(Widget w)1038 extern void _XbaeDebugPrintCompleteTree(Widget w)
1039 {
1040 #ifndef XBAE_PRODUCTION
1041 if (_XbaeDebugInit()) {
1042 Widget p;
1043 for (p = XtParent(w); p != NULL; w = p, p = XtParent(w))
1044 ;
1045
1046 __XbaeDebugPrintTree(w, 0);
1047 }
1048 #endif
1049 }
1050
1051 /**************************************************************************************************/
1052
1053 /*
1054 * Allow unconditional printing to the _XbaeDebugFile
1055 */
_XbaeDebugPrintString(const char * s)1056 extern void _XbaeDebugPrintString(const char *s)
1057 {
1058 #ifndef XBAE_PRODUCTION
1059 _XbaeDebugInit();
1060 fprintf(_XbaeDebugFile, "%s", s);
1061 #endif
1062 }
1063
1064 /**************************************************************************************************/
1065
1066 /* The following calls shouldn't depend on the complete debugging
1067 subsystem, i.e. things like _XbaeDebugFile, etc. */
1068
_XbaeDebugState(Widget w)1069 extern const char *_XbaeDebugState(Widget w)
1070 {
1071 if (XtIsRealized(w)) {
1072 if (XtIsManaged(w)) {
1073 return "realized, managed";
1074 } else {
1075 return "realized, not managed";
1076 }
1077 } else {
1078 if (XtIsManaged(w)) {
1079 return "not realized, managed";
1080 } else {
1081 return "not realized, not managed";
1082 }
1083 }
1084 }
1085
_XbaeDebugDeleteResponse2String(int d)1086 extern const char *_XbaeDebugDeleteResponse2String(int d)
1087 {
1088 switch (d) {
1089 case XmDESTROY:
1090 return "XmDESTROY";
1091 case XmUNMAP:
1092 return "XmUNMAP";
1093 case XmDO_NOTHING:
1094 return "XmDO_NOTHING";
1095 default:
1096 return "??";
1097 }
1098 }
1099
1100 #if XmVERSION > 1
_XbaeDebugComboBoxType2String(unsigned char type)1101 extern const char *_XbaeDebugComboBoxType2String(unsigned char type)
1102 {
1103 switch (type) {
1104 case XmDROP_DOWN_LIST:
1105 return ("XmDROP_DOWN_LIST");
1106 case XmDROP_DOWN_COMBO_BOX:
1107 return ("XmDROP_DOWN_COMBO_BOX");
1108 case XmCOMBO_BOX:
1109 return ("XmCOMBO_BOX");
1110 default:
1111 return ("UNKNOWN");
1112 }
1113 }
1114 #endif
1115
_XbaeDebugGeoAction2String(int action)1116 extern const char *_XbaeDebugGeoAction2String(int action)
1117 {
1118 switch (action) {
1119 case XmGET_ACTUAL_SIZE:
1120 return ("XmGET_ACTUAL_SIZE");
1121 case XmGET_PREFERRED_SIZE:
1122 return ("XmGET_PREFERRED_SIZE");
1123 case XmGEO_PRE_SET:
1124 return ("XmGEO_PRE_SET");
1125 case XmGEO_POST_SET:
1126 return ("XmGEO_POST_SET");
1127 default:
1128 return ("Unknown geo action");
1129 }
1130 }
1131
_XbaeDebugGeometryResult2String(XtGeometryResult r)1132 extern const char *_XbaeDebugGeometryResult2String(XtGeometryResult r)
1133 {
1134 switch (r) {
1135 case XtGeometryYes:
1136 return "Yes";
1137
1138 case XtGeometryNo:
1139 return "No";
1140
1141 case XtGeometryAlmost:
1142 return "Almost";
1143
1144 case XtGeometryDone:
1145 return "Done";
1146
1147 default:
1148 return "(invalid geometry result)";
1149 }
1150 }
1151
_XbaeDebugDragAndDropMessageType2String(unsigned char r)1152 extern const char *_XbaeDebugDragAndDropMessageType2String(unsigned char r)
1153 {
1154 switch (r) {
1155 case XmTOP_LEVEL_ENTER:
1156 return "TOP_LEVEL_ENTER";
1157
1158 case XmTOP_LEVEL_LEAVE:
1159 return "TOP_LEVEL_LEAVE";
1160
1161 case XmDRAG_MOTION:
1162 return "DRAG_MOTION";
1163
1164 case XmDROP_SITE_ENTER:
1165 return "DROP_SITE_ENTER";
1166
1167 case XmDROP_SITE_LEAVE:
1168 return "DROP_SITE_LEAVE";
1169
1170 case XmDROP_START:
1171 return "DROP_START";
1172
1173 case XmDROP_FINISH:
1174 return "DROP_FINISH";
1175
1176 case XmDRAG_DROP_FINISH:
1177 return "DRAG_DROP_FINISH";
1178
1179 case XmOPERATION_CHANGED:
1180 return "OPERATION_CHANGED";
1181
1182 default:
1183 return "UNKNOWN";
1184 }
1185 }
1186
_XbaeDebugDragType2String(unsigned char r)1187 extern const char *_XbaeDebugDragType2String(unsigned char r)
1188 {
1189 switch (r) {
1190 case XmDRAG_NONE:
1191 return "XmDRAG_NONE";
1192
1193 case XmDRAG_DROP_ONLY:
1194 return "XmDRAG_DROP_ONLY";
1195
1196 case XmDRAG_PREFER_PREREGISTER:
1197 return "XmDRAG_PREFER_PREREGISTER";
1198
1199 case XmDRAG_PREREGISTER:
1200 return "XmDRAG_PREREGISTER";
1201
1202 case XmDRAG_PREFER_DYNAMIC:
1203 return "XmDRAG_PREFER_DYNAMIC";
1204
1205 case XmDRAG_PREFER_RECEIVER:
1206 return "XmDRAG_PREFER_RECEIVER";
1207
1208 case XmDRAG_DYNAMIC:
1209 return "XmDRAG_DYNAMIC";
1210
1211 default:
1212 return "UNKNOWN";
1213 }
1214 }
1215
_XbaeDebugScrollingPolicy2String(unsigned char r)1216 extern const char *_XbaeDebugScrollingPolicy2String(unsigned char r)
1217 {
1218 switch (r) {
1219 case XmAUTOMATIC:
1220 return "XmAUTOMATIC";
1221
1222 case XmCONSTANT:
1223 return "XmCONSTANT";
1224
1225 default:
1226 return "UNKNOWN";
1227 }
1228 }
1229
_XbaeDebugMwmInput2String(int a)1230 extern const char *_XbaeDebugMwmInput2String(int a)
1231 {
1232 switch (a) {
1233 case MWM_INPUT_MODELESS:
1234 return "MWM_INPUT_MODELESS";
1235
1236 case MWM_INPUT_PRIMARY_APPLICATION_MODAL:
1237 return "MWM_INPUT_PRIMARY_APPLICATION_MODAL or MWM_INPUT_APPLICATION_MODAL";
1238
1239 case MWM_INPUT_FULL_APPLICATION_MODAL:
1240 return "MWM_INPUT_FULL_APPLICATION_MODAL";
1241
1242 case MWM_INPUT_SYSTEM_MODAL:
1243 return "MWM_INPUT_SYSTEM_MODAL";
1244 #if 0
1245 case MWM_INPUT_APPLICATION_MODAL:
1246 return "MWM_INPUT_APPLICATION_MODAL";
1247 #endif
1248 default:
1249 return "(invalid input style)";
1250 }
1251 }
1252
_XbaeDebugDialogStyle2String(int a)1253 extern const char *_XbaeDebugDialogStyle2String(int a)
1254 {
1255 switch (a) {
1256 case XmDIALOG_WORK_AREA:
1257 return "XmDIALOG_WORK_AREA or XmDIALOG_MODELESS";
1258
1259 /*
1260 case XmDIALOG_MODELESS:
1261 return "XmDIALOG_MODELESS";
1262 */
1263
1264 case XmDIALOG_PRIMARY_APPLICATION_MODAL:
1265 return "XmDIALOG_PRIMARY_APPLICATION_MODAL or XmDIALOG_APPLICATION_MODAL";
1266
1267 case XmDIALOG_FULL_APPLICATION_MODAL:
1268 return "XmDIALOG_FULL_APPLICATION_MODAL";
1269
1270 case XmDIALOG_SYSTEM_MODAL:
1271 return "XmDIALOG_SYSTEM_MODAL";
1272
1273 /*
1274 case XmDIALOG_APPLICATION_MODAL:
1275 return "XmDIALOG_APPLICATION_MODAL";
1276 */
1277
1278 default:
1279 return "(invalid dialog style)";
1280 }
1281 }
1282
_XbaeDebugAttachment2String(int a)1283 extern const char *_XbaeDebugAttachment2String(int a)
1284 {
1285 switch (a) {
1286 case XmATTACH_FORM:
1287 return "XmATTACH_FORM";
1288
1289 case XmATTACH_OPPOSITE_FORM:
1290 return "XmATTACH_OPPOSITE_FORM";
1291
1292 case XmATTACH_WIDGET:
1293 return "XmATTACH_WIDGET";
1294
1295 case XmATTACH_OPPOSITE_WIDGET:
1296 return "XmATTACH_OPPOSITE_WIDGET";
1297
1298 case XmATTACH_NONE:
1299 return "XmATTACH_NONE";
1300
1301 case XmATTACH_POSITION:
1302 return "XmATTACH_POSITION";
1303
1304 case XmATTACH_SELF:
1305 return "XmATTACH_SELF";
1306
1307 default:
1308 return "(invalid attachment)";
1309 }
1310 }
1311
_XbaeDebugMenuEnum2String(int f)1312 extern const char *_XbaeDebugMenuEnum2String(int f)
1313 {
1314 switch (f) {
1315 case XmMENU_POPDOWN:
1316 return "XmMENU_POPDOWN";
1317
1318 case XmMENU_PROCESS_TREE:
1319 return "XmMENU_PROCESS_TREE";
1320
1321 case XmMENU_TRAVERSAL:
1322 return "XmMENU_TRAVERSAL";
1323
1324 case XmMENU_SHELL_POPDOWN:
1325 return "XmMENU_SHELL_POPDOWN";
1326
1327 case XmMENU_CALLBACK:
1328 return "XmMENU_CALLBACK";
1329
1330 case XmMENU_BUTTON:
1331 return "XmMENU_BUTTON";
1332
1333 case XmMENU_CASCADING:
1334 return "XmMENU_CASCADING";
1335
1336 case XmMENU_SUBMENU:
1337 return "XmMENU_SUBMENU";
1338
1339 case XmMENU_ARM:
1340 return "XmMENU_ARM";
1341
1342 case XmMENU_DISARM:
1343 return "XmMENU_DISARM";
1344
1345 case XmMENU_BAR_CLEANUP:
1346 return "XmMENU_BAR_CLEANUP";
1347
1348 case XmMENU_STATUS:
1349 return "XmMENU_STATUS";
1350
1351 case XmMENU_MEMWIDGET_UPDATE:
1352 return "XmMENU_MEMWIDGET_UPDATE";
1353
1354 case XmMENU_BUTTON_POPDOWN:
1355 return "XmMENU_BUTTON_POPDOWN";
1356
1357 case XmMENU_RESTORE_EXCLUDED_TEAROFF_TO_TOPLEVEL_SHELL:
1358 return "XmMENU_RESTORE_EXCLUDED_TEAROFF_TO_TOPLEVEL_SHELL";
1359
1360 case XmMENU_RESTORE_TEAROFF_TO_TOPLEVEL_SHELL:
1361 return "XmMENU_RESTORE_TEAROFF_TO_TOPLEVEL_SHELL";
1362
1363 case XmMENU_RESTORE_TEAROFF_TO_MENUSHELL:
1364 return "XmMENU_RESTORE_TEAROFF_TO_MENUSHELL";
1365
1366 case XmMENU_GET_LAST_SELECT_TOPLEVEL:
1367 return "XmMENU_GET_LAST_SELECT_TOPLEVEL";
1368
1369 case XmMENU_TEAR_OFF_ARM:
1370 return "XmMENU_TEAR_OFF_ARM";
1371
1372 default:
1373 return "??";
1374 }
1375 }
1376
_XbaeDebugBoolean2String(Boolean b)1377 extern const char *_XbaeDebugBoolean2String(Boolean b)
1378 {
1379 if (b)
1380 return "True";
1381 else
1382 return "False";
1383 }
1384
_XbaeDebugXmString2String(XmString xms)1385 extern const char *_XbaeDebugXmString2String(XmString xms)
1386 {
1387 static char *s = NULL;
1388
1389 if (s) {
1390 XtFree(s);
1391 s = NULL;
1392 }
1393 if (xms == (XmString) XmUNSPECIFIED) {
1394 return "XmUNSPECIFIED";
1395 }
1396 if (!XmStringGetLtoR(xms, XmFONTLIST_DEFAULT_TAG, &s) || s == NULL) {
1397 return "(null)";
1398 }
1399
1400 return s;
1401 }
1402
_XbaeDebugPacking2String(unsigned char p)1403 extern const char *_XbaeDebugPacking2String(unsigned char p)
1404 {
1405 static char res[40];
1406
1407 switch (p) {
1408 case XmPACK_COLUMN:
1409 return "XmPACK_COLUMN";
1410
1411 case XmPACK_TIGHT:
1412 return "XmPACK_TIGHT";
1413
1414 case XmPACK_NONE:
1415 return "XmPACK_NONE";
1416
1417 default:
1418 sprintf(res, "Invalid packing %d", p);
1419 return res;
1420 }
1421 }
1422
_XbaeDebugRcType2String(unsigned char t)1423 extern const char *_XbaeDebugRcType2String(unsigned char t)
1424 {
1425 static char res[40];
1426
1427 switch (t) {
1428 case XmWORK_AREA:
1429 return "XmWORK_AREA";
1430
1431 case XmMENU_BAR:
1432 return "XmMENU_BAR";
1433
1434 case XmMENU_PULLDOWN:
1435 return "XmMENU_PULLDOWN";
1436
1437 case XmMENU_POPUP:
1438 return "XmMENU_POPUP";
1439
1440 case XmMENU_OPTION:
1441 return "XmMENU_OPTION";
1442
1443 default:
1444 sprintf(res, "Invalid RC Type %d", t);
1445 return res;
1446 }
1447 }
1448
_XbaeDebugWidgetGeometry2String(XtWidgetGeometry * g)1449 extern const char *_XbaeDebugWidgetGeometry2String(XtWidgetGeometry * g)
1450 {
1451 static char o1[128], o2[128], b[20];
1452 static char *out = NULL;
1453 int i;
1454
1455 if (g == NULL) {
1456 return "NULL_GEOMETRY";
1457 }
1458
1459 if (g->request_mode == 0) {
1460 return "GEOMETRY_NO_FIELDS";
1461 }
1462
1463 /* Some magic to ensure you can call this sucker twice in one C function call */
1464 if (out == o1) {
1465 out = o2;
1466 } else {
1467 out = o1;
1468 }
1469
1470 out[0] = '\0';
1471
1472 if (g->request_mode & CWX) {
1473 sprintf(b, "x %d ", g->x);
1474 strcat(out, b);
1475 }
1476 if (g->request_mode & CWY) {
1477 sprintf(b, "y %d ", g->y);
1478 strcat(out, b);
1479 }
1480 if (g->request_mode & CWWidth) {
1481 sprintf(b, "w %d ", g->width);
1482 strcat(out, b);
1483 }
1484 if (g->request_mode & CWHeight) {
1485 sprintf(b, "h %d ", g->height);
1486 strcat(out, b);
1487 }
1488 if (g->request_mode & CWBorderWidth) {
1489 sprintf(b, "bw %d ", g->border_width);
1490 strcat(out, b);
1491 }
1492
1493 for (i = 0; out[i]; i++) {
1494 }
1495
1496 if (i > 0 && out[i - 1] == ' ') {
1497 out[i - 1] = '\0';
1498 }
1499
1500 return out;
1501 }
1502
_XbaeDebugEditMode2String(int n)1503 extern const char *_XbaeDebugEditMode2String(int n)
1504 {
1505 switch (n) {
1506 case XmMULTI_LINE_EDIT:
1507 return "XmMULTI_LINE_EDIT";
1508
1509 case XmSINGLE_LINE_EDIT:
1510 return "XmSINGLE_LINE_EDIT";
1511
1512 default:
1513 return "???";
1514 }
1515 }
1516
_XbaeDebugSelectionPolicy2String(int n)1517 extern const char *_XbaeDebugSelectionPolicy2String(int n)
1518 {
1519 switch (n) {
1520 case XmSINGLE_SELECT:
1521 return "XmSINGLE_SELECT";
1522
1523 case XmBROWSE_SELECT:
1524 return "XmBROWSE_SELECT";
1525
1526 case XmMULTIPLE_SELECT:
1527 return "XmMULTIPLE_SELECT";
1528
1529 case XmEXTENDED_SELECT:
1530 return "XmEXTENDED_SELECT";
1531
1532 default:
1533 return "???";
1534 }
1535 }
1536
_XbaeDebugResizePolicy2String(int n)1537 extern const char *_XbaeDebugResizePolicy2String(int n)
1538 {
1539 switch (n) {
1540 case XmRESIZE_NONE:
1541 return "XmRESIZE_NONE";
1542
1543 case XmRESIZE_GROW:
1544 return "XmRESIZE_GROW";
1545
1546 case XmRESIZE_ANY:
1547 return "XmRESIZE_ANY";
1548
1549 case XmRESIZE_SWINDOW:
1550 return "XmRESIZE_SWINDOW";
1551
1552 default:
1553 return "XmNscrollBarDisplayPolicy - illegal";
1554 }
1555 }
1556
_XbaeDebugSBDisplayPolicy2String(int n)1557 extern const char *_XbaeDebugSBDisplayPolicy2String(int n)
1558 {
1559 switch (n) {
1560 case XmSTATIC:
1561 return "XmSTATIC";
1562
1563 case XmAS_NEEDED:
1564 return "XmAS_NEEDED";
1565
1566 default:
1567 return "XmNscrollBarDisplayPolicy - illegal";
1568 }
1569 }
1570
_XbaeDebugSBPlacement2String(int n)1571 extern const char *_XbaeDebugSBPlacement2String(int n)
1572 {
1573 switch (n) {
1574 case XmTOP_LEFT:
1575 return "XmTOP_LEFT";
1576
1577 case XmBOTTOM_LEFT:
1578 return "XmBOTTOM_LEFT";
1579
1580 case XmTOP_RIGHT:
1581 return "XmTOP_RIGHT";
1582
1583 case XmBOTTOM_RIGHT:
1584 return "XmBOTTOM_RIGHT";
1585
1586 default:
1587 return "XmNscrollBarPlacement - illegal";
1588 }
1589 }
1590
_XbaeDebugListSizePolicy2String(int n)1591 extern const char *_XbaeDebugListSizePolicy2String(int n)
1592 {
1593 switch (n) {
1594 case XmVARIABLE:
1595 return "XmVARIABLE";
1596
1597 case XmCONSTANT:
1598 return "XmCONSTANT";
1599
1600 case XmRESIZE_IF_POSSIBLE:
1601 return "XmRESIZE_IF_POSSIBLE";
1602
1603 default:
1604 return "XmNlistSizePolicy - illegal";
1605 }
1606 }
1607
_XbaeDebugAlignment2String(int n)1608 extern const char *_XbaeDebugAlignment2String(int n)
1609 {
1610 switch (n) {
1611 case XmALIGNMENT_BEGINNING:
1612 return "XmALIGNMENT_BEGINNING";
1613
1614 case XmALIGNMENT_CENTER:
1615 return "XmALIGNMENT_CENTER";
1616
1617 case XmALIGNMENT_END:
1618 return "XmALIGNMENT_END";
1619
1620 default:
1621 return "XmALIGNMENT - illegal";
1622 }
1623 }
1624
_XbaeDebugMenuType2String(int n)1625 extern const char *_XbaeDebugMenuType2String(int n)
1626 {
1627 switch (n) {
1628 case XmMENU_OPTION:
1629 return "XmMENU_OPTION";
1630
1631 case XmMENU_POPUP:
1632 return "XmMENU_POPUP";
1633
1634 case XmMENU_PULLDOWN:
1635 return "XmMENU_PULLDOWN";
1636
1637 default:
1638 return "???";
1639 }
1640 }
1641
_XbaeDebugNavigability2String(unsigned char n)1642 extern const char *_XbaeDebugNavigability2String(unsigned char n)
1643 {
1644 switch (n) {
1645 case XmDESCENDANTS_NAVIGABLE:
1646 return "XmDESCENDANTS_NAVIGABLE";
1647
1648 case XmDESCENDANTS_TAB_NAVIGABLE:
1649 return "XmDESCENDANTS_TAB_NAVIGABLE";
1650
1651 case XmCONTROL_NAVIGABLE:
1652 return "XmCONTROL_NAVIGABLE";
1653
1654 case XmNOT_NAVIGABLE:
1655 return "XmNOT_NAVIGABLE";
1656
1657 case XmTAB_NAVIGABLE:
1658 return "XmTAB_NAVIGABLE";
1659
1660 default:
1661 return "???";
1662 }
1663 }
1664
_XbaeDebugHighlightMode2String(int mode)1665 extern const char *_XbaeDebugHighlightMode2String(int mode)
1666 {
1667 switch (mode) {
1668 case XmHIGHLIGHT_NORMAL:
1669 return "NORMAL";
1670
1671 case XmHIGHLIGHT_SELECTED:
1672 return "SELECTED";
1673
1674 case XmHIGHLIGHT_SECONDARY_SELECTED:
1675 return "SECONDARY_SELECTED";
1676
1677 default:
1678 return "???";
1679 }
1680 }
1681
_XbaeDebugReason2String(int reason)1682 extern const char *_XbaeDebugReason2String(int reason)
1683 {
1684 switch (reason) {
1685 case XmCR_NONE:
1686 return "XmCR_NONE";
1687 case XmCR_HELP:
1688 return "XmCR_HELP";
1689 case XmCR_VALUE_CHANGED:
1690 return "XmCR_VALUE_CHANGED";
1691 case XmCR_INCREMENT:
1692 return "XmCR_INCREMENT";
1693 case XmCR_DECREMENT:
1694 return "XmCR_DECREMENT";
1695 case XmCR_PAGE_INCREMENT:
1696 return "XmCR_PAGE_INCREMENT";
1697 case XmCR_PAGE_DECREMENT:
1698 return "XmCR_PAGE_DECREMENT";
1699 case XmCR_TO_TOP:
1700 return "XmCR_TO_TOP";
1701 case XmCR_TO_BOTTOM:
1702 return "XmCR_TO_BOTTOM";
1703 case XmCR_DRAG:
1704 return "XmCR_DRAG";
1705 case XmCR_ACTIVATE:
1706 return "XmCR_ACTIVATE";
1707 case XmCR_ARM:
1708 return "XmCR_ARM";
1709 case XmCR_DISARM:
1710 return "XmCR_DISARM";
1711
1712 /* case XmCR_DUMMY13: return "XmCR_DUMMY13"; */
1713
1714 /* case XmCR_DUMMY14: return "XmCR_DUMMY14"; */
1715
1716 /* case XmCR_DUMMY15: return "XmCR_DUMMY15"; */
1717 case XmCR_MAP:
1718 return "XmCR_MAP";
1719 case XmCR_UNMAP:
1720 return "XmCR_UNMAP";
1721 case XmCR_FOCUS:
1722 return "XmCR_FOCUS";
1723 case XmCR_LOSING_FOCUS:
1724 return "XmCR_LOSING_FOCUS";
1725 case XmCR_MODIFYING_TEXT_VALUE:
1726 return "XmCR_MODIFYING_TEXT_VALUE";
1727 case XmCR_MOVING_INSERT_CURSOR:
1728 return "XmCR_MOVING_INSERT_CURSOR";
1729 case XmCR_EXECUTE:
1730 return "XmCR_EXECUTE";
1731 case XmCR_SINGLE_SELECT:
1732 return "XmCR_SINGLE_SELECT";
1733 case XmCR_MULTIPLE_SELECT:
1734 return "XmCR_MULTIPLE_SELECT";
1735 case XmCR_EXTENDED_SELECT:
1736 return "XmCR_EXTENDED_SELECT";
1737 case XmCR_BROWSE_SELECT:
1738 return "XmCR_BROWSE_SELECT";
1739 case XmCR_DEFAULT_ACTION:
1740 return "XmCR_DEFAULT_ACTION";
1741 case XmCR_CLIPBOARD_DATA_REQUEST:
1742 return "XmCR_CLIPBOARD_DATA_REQUEST";
1743 case XmCR_CLIPBOARD_DATA_DELETE:
1744 return "XmCR_CLIPBOARD_DATA_DELETE";
1745 case XmCR_CASCADING:
1746 return "XmCR_CASCADING";
1747 case XmCR_OK:
1748 return "XmCR_OK";
1749 case XmCR_CANCEL:
1750 return "XmCR_CANCEL";
1751
1752 /* case XmCR_DUMMY33: return "XmCR_DUMMY33"; */
1753 case XmCR_APPLY:
1754 return "XmCR_APPLY";
1755 case XmCR_NO_MATCH:
1756 return "XmCR_NO_MATCH";
1757 case XmCR_COMMAND_ENTERED:
1758 return "XmCR_COMMAND_ENTERED";
1759 case XmCR_COMMAND_CHANGED:
1760 return "XmCR_COMMAND_CHANGED";
1761 case XmCR_EXPOSE:
1762 return "XmCR_EXPOSE";
1763 case XmCR_RESIZE:
1764 return "XmCR_RESIZE";
1765 case XmCR_INPUT:
1766 return "XmCR_INPUT";
1767 case XmCR_GAIN_PRIMARY:
1768 return "XmCR_GAIN_PRIMARY";
1769 case XmCR_LOSE_PRIMARY:
1770 return "XmCR_LOSE_PRIMARY";
1771 case XmCR_CREATE:
1772 return "XmCR_CREATE";
1773 case XmCR_TEAR_OFF_ACTIVATE:
1774 return "XmCR_TEAR_OFF_ACTIVATE";
1775 case XmCR_TEAR_OFF_DEACTIVATE:
1776 return "XmCR_TEAR_OFF_DEACTIVATE";
1777 case XmCR_OBSCURED_TRAVERSAL:
1778 return "XmCR_OBSCURED_TRAVERSAL";
1779 #if XmVERSION >= 2
1780 case XmCR_FOCUS_MOVED:
1781 return "XmCR_FOCUS_MOVED";
1782
1783 /* case XmCR_DUMMY48: return "XmCR_DUMMY48"; */
1784
1785 /* case XmCR_DUMMY49: return "XmCR_DUMMY49"; */
1786
1787 /* case XmCR_DUMMY50: return "XmCR_DUMMY50"; */
1788
1789 /* case XmCR_DUMMY51: return "XmCR_DUMMY51"; */
1790
1791 /* case XmCR_DUMMY52: return "XmCR_DUMMY52"; */
1792
1793 /* case XmCR_DUMMY53: return "XmCR_DUMMY53"; */
1794 case XmCR_REPOST:
1795 return "XmCR_REPOST";
1796 case XmCR_COLLAPSED:
1797 return "XmCR_COLLAPSED";
1798 case XmCR_EXPANDED:
1799 return "XmCR_EXPANDED";
1800 case XmCR_SELECT:
1801 return "XmCR_SELECT";
1802 case XmCR_DRAG_START:
1803 return "XmCR_DRAG_START";
1804 case XmCR_NO_FONT:
1805 return "XmCR_NO_FONT";
1806 case XmCR_NO_RENDITION:
1807 return "XmCR_NO_RENDITION";
1808 case XmCR_POST:
1809 return "XmCR_POST";
1810 case XmCR_SPIN_NEXT:
1811 return "XmCR_SPIN_NEXT";
1812 case XmCR_SPIN_PRIOR:
1813 return "XmCR_SPIN_PRIOR";
1814 case XmCR_SPIN_FIRST:
1815 return "XmCR_SPIN_FIRST";
1816 case XmCR_SPIN_LAST:
1817 return "XmCR_SPIN_LAST";
1818 case XmCR_PAGE_SCROLLER_INCREMENT:
1819 return "XmCR_PAGE_SCROLLER_INCREMENT";
1820 case XmCR_PAGE_SCROLLER_DECREMENT:
1821 return "XmCR_PAGE_SCROLLER_DECREMENT";
1822 case XmCR_MAJOR_TAB:
1823 return "XmCR_MAJOR_TAB";
1824 case XmCR_MINOR_TAB:
1825 return "XmCR_MINOR_TAB";
1826 #endif /* XmVERSION >= 2 */
1827 #if XmVersion >=2001
1828 case XmCR_PDM_NONE:
1829 return "XmCR_PDM_NONE";
1830 case XmCR_PDM_START_VXAUTH:
1831 return "XmCR_PDM_START_VXAUTH";
1832 case XmCR_PDM_START_PXAUTH:
1833 return "XmCR_PDM_START_PXAUTH";
1834 case XmCR_PDM_UP:
1835 return "XmCR_PDM_UP";
1836 case XmCR_PDM_OK:
1837 return "XmCR_PDM_OK";
1838 case XmCR_PDM_CANCEL:
1839 return "XmCR_PDM_CANCEL";
1840 case XmCR_PDM_START_ERROR:
1841 return "XmCR_PDM_START_ERROR";
1842 case XmCR_PDM_EXIT_ERROR:
1843 return "XmCR_PDM_EXIT_ERROR";
1844 #endif /* XmVersion >=2001 */
1845 case XmCR_PROTOCOLS:
1846 return "XmCR_PROTOCOLS";
1847 default:
1848 return "???";
1849 }
1850 }
1851
_XbaeDebugFocusChange2String(XmFocusChange c)1852 extern const char *_XbaeDebugFocusChange2String(XmFocusChange c)
1853 {
1854 switch (c) {
1855 case XmFOCUS_IN:
1856 return "XmFOCUS_IN";
1857 case XmFOCUS_OUT:
1858 return "XmFOCUS_OUT";
1859 case XmENTER:
1860 return "XmENTER";
1861 case XmLEAVE:
1862 return "XmLEAVE";
1863 default:
1864 return "???";
1865 }
1866 }
1867
_XbaeDebugNavigationType2String(XmNavigationType nt)1868 extern const char *_XbaeDebugNavigationType2String(XmNavigationType nt)
1869 {
1870 switch (nt) {
1871 case XmNONE:
1872 return "XmNONE";
1873 case XmTAB_GROUP:
1874 return "XmTAB_GROUP";
1875 case XmSTICKY_TAB_GROUP:
1876 return "XmSTICKY_TAB_GROUP";
1877 case XmEXCLUSIVE_TAB_GROUP:
1878 return "XmEXCLUSIVE_TAB_GROUP";
1879 default:
1880 return "???";
1881 }
1882 }
1883
_XbaeDebugEventType2String(int type)1884 extern const char *_XbaeDebugEventType2String(int type)
1885 {
1886 switch (type) {
1887 case KeyPress:
1888 return ("KeyPress");
1889 case KeyRelease:
1890 return ("KeyRelease");
1891 case ButtonPress:
1892 return ("ButtonPress");
1893 case ButtonRelease:
1894 return ("ButtonRelease");
1895 case KeymapNotify:
1896 return ("KeymapNotify");
1897 case MotionNotify:
1898 return ("MotionNotify");
1899 case EnterNotify:
1900 return ("EnterNotify");
1901 case LeaveNotify:
1902 return ("LeaveNotify");
1903 case FocusIn:
1904 return ("FocusIn");
1905 case FocusOut:
1906 return ("FocusOut");
1907 case Expose:
1908 return ("Expose");
1909 case GraphicsExpose:
1910 return ("GraphicsExpose");
1911 case NoExpose:
1912 return ("NoExpose");
1913 case ColormapNotify:
1914 return ("ColormapNotify");
1915 case PropertyNotify:
1916 return ("PropertyNotify");
1917 case VisibilityNotify:
1918 return ("VisibilityNotify");
1919 case ResizeRequest:
1920 return ("ResizeRequest");
1921 case CirculateNotify:
1922 return ("CirculateNotify");
1923 case ConfigureNotify:
1924 return ("ConfigureNotify");
1925 case DestroyNotify:
1926 return ("DestroyNotify");
1927 case GravityNotify:
1928 return ("GravityNotify");
1929 case MapNotify:
1930 return ("MapNotify");
1931 case ReparentNotify:
1932 return ("ReparentNotify");
1933 case UnmapNotify:
1934 return ("UnmapNotify");
1935 case CreateNotify:
1936 return ("CreateNotify");
1937 case CirculateRequest:
1938 return ("CirculateRequest");
1939 case ConfigureRequest:
1940 return ("ConfigureRequest");
1941 case MapRequest:
1942 return ("MapRequest");
1943 case MappingNotify:
1944 return ("MappingNotify");
1945 case ClientMessage:
1946 return ("ClientMessage");
1947 case SelectionClear:
1948 return ("SelectionClear");
1949 case SelectionNotify:
1950 return ("SelectionNotify");
1951 case SelectionRequest:
1952 return ("SelectionRequest");
1953 default:
1954 return ("UNKNOWN");
1955 }
1956 }
1957
_XbaeDebugFocusMode2String(int type)1958 extern const char *_XbaeDebugFocusMode2String(int type)
1959 {
1960 switch (type) {
1961 case NotifyNormal:
1962 return ("NotifyNormal");
1963 case NotifyGrab:
1964 return ("NotifyGrab");
1965 case NotifyUngrab:
1966 return ("NotifyUngrab");
1967 case NotifyWhileGrabbed:
1968 return ("NotifyWhileGrabbed");
1969 default:
1970 return ("UNKNOWN");
1971 }
1972 }
1973
_XbaeDebugFocusDetail2String(int type)1974 extern const char *_XbaeDebugFocusDetail2String(int type)
1975 {
1976 switch (type) {
1977 case NotifyAncestor:
1978 return ("NotifyAncestor");
1979 case NotifyDetailNone:
1980 return ("NotifyDetailNone");
1981 case NotifyInferior:
1982 return ("NotifyInferior");
1983 case NotifyNonlinear:
1984 return ("NotifyNonlinear");
1985 case NotifyNonlinearVirtual:
1986 return ("NotifyNonlinearVirtual");
1987 case NotifyPointer:
1988 return ("NotifyPointer");
1989 case NotifyPointerRoot:
1990 return ("NotifyPointerRoot");
1991 case NotifyVirtual:
1992 return ("NotifyVirtual");
1993 default:
1994 return ("UNKNOWN");
1995 }
1996 }
1997
_LtDebugFrameChildType2String(int action)1998 extern const char * _LtDebugFrameChildType2String(int action)
1999 {
2000 switch (action) {
2001 case XmFRAME_GENERIC_CHILD:
2002 return ("XmFRAME_GENERIC_CHILD");
2003 case XmFRAME_WORKAREA_CHILD:
2004 return ("XmFRAME_WORKAREA_CHILD");
2005 case XmFRAME_TITLE_CHILD:
2006 return ("XmFRAME_TITLE_CHILD");
2007 default:
2008 return ("Unknown frame childtype");
2009 }
2010 }
2011
_XbaeDebugShadowTypeToString(unsigned char s)2012 extern const char *_XbaeDebugShadowTypeToString(unsigned char s)
2013 {
2014 switch (s) {
2015 case XmSHADOW_IN:
2016 return "XmSHADOW_IN";
2017 case XmSHADOW_OUT:
2018 return "XmSHADOW_OUT";
2019 case BAD_SHADOW:
2020 return "BAD_SHADOW";
2021 case XmSINGLE_LINE:
2022 return "XmSINGLE_LINE";
2023 case XmDOUBLE_LINE:
2024 return "XmDOUBLE_LINE";
2025 case XmSINGLE_DASHED_LINE:
2026 return "XmSINGLE_DASHED_LINE";
2027 case XmDOUBLE_DASHED_LINE:
2028 return "XmDOUBLE_DASHED_LINE";
2029 case XmSHADOW_ETCHED_IN:
2030 return "XmSHADOW_ETCHED_IN";
2031 case XmSHADOW_ETCHED_OUT:
2032 return "XmSHADOW_ETCHED_OUT";
2033 /* Same as XmSHADOW_IN case XmSHADOW_ETCHED_IN_DASH: return "XmSHADOW_ETCHED_IN_DASH"; */
2034 /* Same as XmSHADOW_OUT case XmSHADOW_ETCHED_OUT_DASH: return "XmSHADOW_ETCHED_OUT_DASH"; */
2035 case XmINVALID_SEPARATOR_TYPE:
2036 return "XmINVALID_SEPARATOR_TYPE";
2037 default:
2038 return "??";
2039 }
2040 }
2041
2042 /**************************************************************************************************/
2043
2044 #ifdef WITH_DMALLOC
2045
XbaeAllocError(const char * name)2046 static void XbaeAllocError(const char *name)
2047 {
2048 (void) write(2, "Xt Error: ", 10);
2049 (void) write(2, name, strlen(name));
2050 (void) write(2, "\n", 1);
2051 exit(1);
2052 }
2053
2054 #define DMALLOC_DISABLE
2055 #define DMALLOC_DEFAULT_LINE 0
2056
2057 #define DMALLOC_FUNC_MALLOC 10 /* malloc function called */
2058 #define DMALLOC_FUNC_CALLOC 11 /* calloc function called */
2059 #define DMALLOC_FUNC_REALLOC 12 /* realloc function called */
2060 #define DMALLOC_FUNC_RECALLOC 13 /* recalloc called */
2061 #define DMALLOC_FUNC_MEMALIGN 14 /* memalign function called */
2062 #define DMALLOC_FUNC_VALLOC 15 /* valloc function called */
2063 #define DMALLOC_FUNC_STRDUP 16 /* strdup function called */
2064 #define DMALLOC_FUNC_FREE 17 /* free function called */
2065 #define DMALLOC_FUNC_CFREE 18 /* cfree function called */
2066
2067 /*
2068 * For use with dmalloc, a malloc debugging package.
2069 * Mimick Xt behaviour ...
2070 * NEVER call them directly!
2071 */
2072
_XbaeDebugMalloc(const char * f,int l,Cardinal size)2073 extern XtPointer _XbaeDebugMalloc(const char *f, int l, Cardinal size)
2074 {
2075 XtPointer r = NULL;
2076
2077 if (size == 0) {
2078 size = 1;
2079 }
2080
2081 #if DMALLOC_VERSION_MAJOR < 5
2082 r = _malloc_leap(f, l, size);
2083 #else
2084 r = dmalloc_malloc(f, l, size, DMALLOC_FUNC_MALLOC, 0, 0);
2085 #endif
2086
2087 if (r == NULL) {
2088 XbaeAllocError("malloc");
2089 }
2090
2091 return r;
2092 }
2093
_XbaeDebugCalloc(const char * f,int l,Cardinal count,Cardinal size)2094 extern XtPointer _XbaeDebugCalloc(const char *f, int l, Cardinal count, Cardinal size)
2095 {
2096 XtPointer r = NULL;
2097
2098 if (size == 0 || count == 0) {
2099 count = size = 1;
2100 }
2101
2102 #if DMALLOC_VERSION_MAJOR < 5
2103 r = _calloc_leap(f, l, count, size);
2104 #else
2105 r = dmalloc_malloc(f, l, count * size, DMALLOC_FUNC_CALLOC, 0, 0);
2106 #endif
2107
2108 if (r == NULL) {
2109 XbaeAllocError("calloc");
2110 }
2111
2112 return r;
2113 }
2114
_XbaeDebugRealloc(const char * f,int l,XtPointer p,Cardinal size)2115 extern XtPointer _XbaeDebugRealloc(const char *f, int l, XtPointer p, Cardinal size)
2116 {
2117 XtPointer r = NULL;
2118
2119 if (p == NULL) {
2120 if (size == 0) {
2121 size = 1;
2122 }
2123 #if DMALLOC_VERSION_MAJOR < 5
2124 r = _malloc_leap(f, l, size);
2125 #else
2126 r = dmalloc_malloc(f, l, size, DMALLOC_FUNC_REALLOC, 0, 0);
2127 #endif
2128 } else if (size == 0) {
2129 #if DMALLOC_VERSION_MAJOR < 5
2130 _free_leap(f, l, p);
2131 #else
2132 dmalloc_free(f, l, p, DMALLOC_FUNC_FREE);
2133 #endif
2134 return NULL;
2135 } else {
2136 #if DMALLOC_VERSION_MAJOR < 5
2137 r = _realloc_leap(f, l, p, size);
2138 #else
2139 r = dmalloc_realloc(f, l, p, size, DMALLOC_FUNC_REALLOC, 0);
2140 #endif
2141 }
2142
2143 if (r == NULL) {
2144 XbaeAllocError("realloc");
2145 }
2146
2147 return r;
2148 }
2149
_XbaeDebugFree(const char * f,int l,XtPointer p)2150 extern void _XbaeDebugFree(const char *f, int l, XtPointer p)
2151 {
2152 if (p) {
2153 #if DMALLOC_VERSION_MAJOR < 5
2154 _free_leap(f, l, p);
2155 #else
2156 dmalloc_free(f, l, p, DMALLOC_FUNC_FREE);
2157 #endif
2158 }
2159 }
2160
2161 #define DO_XT_ENTRY_POINTS 1
2162 #if DO_XT_ENTRY_POINTS
2163 /*
2164 * Provide malloc library replacements for X Window System heap routines
2165 * XtCalloc
2166 * XtFree
2167 * XtMalloc
2168 * XtRealloc
2169 * so that we can get accurate caller data.
2170 *
2171 * David Hill
2172 */
2173
2174 #if 0
2175 #include "/home/danny/src/dmalloc/dmalloc-5.0.2/return.h"
2176 #endif
2177
2178 #ifndef GET_RET_ADDR
2179 #define GET_RET_ADDR(file) do { file = "unknown";} while (0)
2180 #endif
2181
2182 #ifdef XtMalloc
2183 #undef XtMalloc
2184 #endif
XtMalloc(unsigned size)2185 char *XtMalloc(unsigned size)
2186 {
2187 char *file;
2188
2189 GET_RET_ADDR(file);
2190
2191 return _XbaeDebugMalloc(file, DMALLOC_DEFAULT_LINE, size);
2192 }
2193
2194 #ifdef XtCalloc
2195 #undef XtCalloc
2196 #endif
XtCalloc(unsigned num_elements,unsigned size)2197 char *XtCalloc(unsigned num_elements, unsigned size)
2198 {
2199 char *file;
2200
2201 GET_RET_ADDR(file);
2202
2203 return _XbaeDebugCalloc(file, DMALLOC_DEFAULT_LINE, num_elements, size);
2204 }
2205
2206 #ifdef XtRealloc
2207 #undef XtRealloc
2208 #endif
XtRealloc(char * ptr,unsigned size)2209 char *XtRealloc(char *ptr, unsigned size)
2210 {
2211 char *file;
2212
2213 GET_RET_ADDR(file);
2214
2215 return _XbaeDebugRealloc(file, DMALLOC_DEFAULT_LINE, ptr, size);
2216 }
2217
2218 #ifdef XtFree
2219 #undef XtFree
2220 #endif
XtFree(char * ptr)2221 void XtFree(char *ptr)
2222 {
2223 char *file;
2224
2225 GET_RET_ADDR(file);
2226
2227 _XbaeDebugFree(file, DMALLOC_DEFAULT_LINE, ptr);
2228 }
2229
2230 #endif /* DO_XT_ENTRY_POINTS */
2231
2232 #else
2233
XbaeAllocError(const char * name)2234 static void XbaeAllocError(const char *name)
2235 {
2236 fprintf(stderr,"Xbae Error: Xbae was not compiled with memory allocation"
2237 "debugging but %s was called. Your linking is broken\n", name);
2238 exit(1);
2239 }
2240
_XbaeDebugMalloc(const char * f,int l,Cardinal size)2241 extern XtPointer _XbaeDebugMalloc(const char *f, int l, Cardinal size)
2242 {
2243 XbaeAllocError("_XbaeDebugMalloc");
2244 return NULL;
2245 }
_XbaeDebugCalloc(const char * f,int l,Cardinal count,Cardinal size)2246 extern XtPointer _XbaeDebugCalloc(const char *f, int l, Cardinal count, Cardinal size)
2247 {
2248 XbaeAllocError("_XbaeDebugCalloc");
2249 return NULL;
2250 }
_XbaeDebugRealloc(const char * f,int l,XtPointer p,Cardinal size)2251 extern XtPointer _XbaeDebugRealloc(const char *f, int l, XtPointer p, Cardinal size)
2252 {
2253 XbaeAllocError("_XbaeDebugRealloc");
2254 return NULL;
2255 }
_XbaeDebugFree(const char * f,int l,XtPointer p)2256 extern void _XbaeDebugFree(const char *f, int l, XtPointer p)
2257 {
2258 XbaeAllocError("_XbaeDebugFree");
2259 }
2260
2261 #endif /* WITH_DMALLOC */
2262