workbench/classes/zune/nlist/nlisttree_mcc/Debug.c

   1 /***************************************************************************
   2
   3  NListtree.mcc - New Listtree MUI Custom Class
   4  Copyright (C) 1999-2001 by Carsten Scholling
   5  Copyright (C) 2001-2014 NList Open Source Team
   6
   7  This library is free software; you can redistribute it and/or
   8  modify it under the terms of the GNU Lesser General Public
   9  License as published by the Free Software Foundation; either
  10  version 2.1 of the License, or (at your option) any later version.
  11
  12  This library is distributed in the hope that it will be useful,
  13  but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  Lesser General Public License for more details.
  16
  17  NList classes Support Site:  http://www.sf.net/projects/nlist-classes
  18
  19  $Id$
  20
  21 ***************************************************************************/
  22
  23 #ifdef DEBUG
  24
  25 #include <stdlib.h>
  26 #include <string.h>
  27 #include <stdarg.h>
  28 #include <stdio.h>
  29
  30 #include <proto/intuition.h>
  31 #include <proto/utility.h>
  32 #include <proto/dos.h>
  33 #include <proto/exec.h>
  34
  35 #include "SDI_compiler.h"
  36 #include "Debug.h"
  37 #include "version.h"
  38
  39 // special flagging macros
  40 #define isFlagSet(v,f)      (((v) & (f)) == (f))  // return TRUE if the flag is set
  41 #define hasFlag(v,f)        (((v) & (f)) != 0)    // return TRUE if one of the flags in f is set in v
  42 #define isFlagClear(v,f)    (((v) & (f)) == 0)    // return TRUE if flag f is not set in v
  43 #define SET_FLAG(v,f)       ((v) |= (f))          // set the flag f in v
  44 #define CLEAR_FLAG(v,f)     ((v) &= ~(f))         // clear the flag f in v
  45 #define MASK_FLAG(v,f)      ((v) &= (f))          // mask the variable v with flag f bitwise
  46
  47 // our static variables with default values
  48 static int indent_level = 0;
  49 static BOOL ansi_output = FALSE;
  50 static ULONG debug_flags = DBF_ALWAYS | DBF_STARTUP; // default debug flags
  51 static ULONG debug_classes = DBC_ERROR | DBC_DEBUG | DBC_WARNING | DBC_ASSERT | DBC_REPORT; // default debug classes
  52
  53 /****************************************************************************/
  54
  55 void SetupDebug(void)
  56 {
  57   char var[256];
  58
  59   kprintf("** NListtree.mcc v" LIB_REV_STRING " startup ***********************\n");
  60   kprintf("Initializing runtime debugging:\n");
  61
  62   if(GetVar("nlisttree.mcc.debug", var, sizeof(var), 0) > 0)
  63   {
  64     char *tok;
  65     char *debug = var;
  66
  67     // static list of our debugging classes tokens.
  68     // in the yamdebug variable these classes always start with a @
  69     static struct { const char *token; unsigned long flag; } dbclasses[] =
  70     {
  71       { "ctrace",  DBC_CTRACE   },
  72       { "report",  DBC_REPORT   },
  73       { "assert",  DBC_ASSERT   },
  74       { "timeval", DBC_TIMEVAL  },
  75       { "debug",   DBC_DEBUG    },
  76       { "error",   DBC_ERROR    },
  77       { "warning", DBC_WARNING  },
  78       { "all",     DBC_ALL      },
  79       { NULL,      0            }
  80     };
  81
  82     static struct { const char *token; unsigned long flag; } dbflags[] =
  83     {
  84       { "always",    DBF_ALWAYS    },
  85       { "startup",   DBF_STARTUP   },
  86       { "draw",      DBF_DRAW      },
  87       { "getset",    DBF_GETSET    },
  88       { "memory",    DBF_MEMORY    },
  89       { "listtree",  DBF_LISTTREE  },
  90       { "setup",     DBF_SETUP     },
  91       { "input",     DBF_INPUT     },
  92       { "dragdrop",  DBF_DRAGDROP  },
  93       { "images",    DBF_IMAGES    },
  94       { "notify",    DBF_NOTIFY    },
  95       { "clipboard", DBF_CLIPBOARD },
  96       { "all",       DBF_ALL       },
  97       { NULL,        0             }
  98     };
  99
 100     // we parse the env variable token-wise
 101     while((tok = strtok(debug, ", ;")))
 102     {
 103       ULONG i;
 104
 105       // check if the token is class definition or
 106       // just a flag definition
 107       if(tok[0] == '@')
 108       {
 109         // check if this call is a negation or not
 110         if(tok[1] == '!')
 111         {
 112           // search for the token and clear the flag
 113           for(i=0; dbclasses[i].token; i++)
 114           {
 115             if(stricmp(tok+2, dbclasses[i].token) == 0)
 116             {
 117               kprintf("clear '%s' debug class flag.\n", dbclasses[i].token);
 118               CLEAR_FLAG(debug_classes, dbclasses[i].flag);
 119             }
 120           }
 121         }
 122         else
 123         {
 124           // search for the token and set the flag
 125           for(i=0; dbclasses[i].token; i++)
 126           {
 127             if(stricmp(tok+1, dbclasses[i].token) == 0)
 128             {
 129               kprintf("set '%s' debug class flag\n", dbclasses[i].token);
 130               SET_FLAG(debug_classes, dbclasses[i].flag);
 131             }
 132           }
 133         }
 134       }
 135       else
 136       {
 137         // check if this call is a negation or not
 138         if(tok[0] == '!')
 139         {
 140           for(i=0; dbflags[i].token; i++)
 141           {
 142             if(stricmp(tok+1, dbflags[i].token) == 0)
 143             {
 144               kprintf("clear '%s' debug flag\n", dbflags[i].token);
 145               CLEAR_FLAG(debug_flags, dbflags[i].flag);
 146             }
 147           }
 148         }
 149         else
 150         {
 151           // check if the token was "ansi" and if so enable the ANSI color
 152           // output
 153           if(stricmp(tok, "ansi") == 0)
 154           {
 155             kprintf("ansi output enabled\n");
 156             ansi_output = TRUE;
 157           }
 158           else
 159           {
 160             for(i=0; dbflags[i].token; i++)
 161             {
 162               if(stricmp(tok, dbflags[i].token) == 0)
 163               {
 164                 kprintf("set '%s' debug flag\n", dbflags[i].token);
 165                 SET_FLAG(debug_flags, dbflags[i].flag);
 166               }
 167             }
 168           }
 169         }
 170       }
 171
 172       debug = NULL;
 173     }
 174   }
 175
 176   kprintf("set debug classes/flags (env:nlisttree.mcc.debug): %08lx/%08lx\n", debug_classes, debug_flags);
 177   kprintf("** Normal processing follows ***************************************\n");
 178 }
 179
 180 /****************************************************************************/
 181
 182 void CleanupDebug(void)
 183 {
 184   kprintf("** Cleaned up debugging ********************************************\n");
 185 }
 186
 187 /****************************************************************************/
 188
 189 // define variables for using ANSI colors in our debugging scheme
 190 #define ANSI_ESC_CLR        "\033[0m"
 191 #define ANSI_ESC_BOLD       "\033[1m"
 192 #define ANSI_ESC_UNDERLINE  "\033[4m"
 193 #define ANSI_ESC_BLINK      "\033[5m"
 194 #define ANSI_ESC_REVERSE    "\033[7m"
 195 #define ANSI_ESC_INVISIBLE  "\033[8m"
 196 #define ANSI_ESC_FG_BLACK   "\033[0;30m"
 197 #define ANSI_ESC_FG_RED     "\033[0;31m"
 198 #define ANSI_ESC_FG_GREEN   "\033[0;32m"
 199 #define ANSI_ESC_FG_BROWN   "\033[0;33m"
 200 #define ANSI_ESC_FG_BLUE    "\033[0;34m"
 201 #define ANSI_ESC_FG_PURPLE  "\033[0;35m"
 202 #define ANSI_ESC_FG_CYAN    "\033[0;36m"
 203 #define ANSI_ESC_FG_LGRAY   "\033[0;37m"
 204 #define ANSI_ESC_FG_DGRAY   "\033[1;30m"
 205 #define ANSI_ESC_FG_LRED    "\033[1;31m"
 206 #define ANSI_ESC_FG_LGREEN  "\033[1;32m"
 207 #define ANSI_ESC_FG_YELLOW  "\033[1;33m"
 208 #define ANSI_ESC_FG_LBLUE   "\033[1;34m"
 209 #define ANSI_ESC_FG_LPURPLE "\033[1;35m"
 210 #define ANSI_ESC_FG_LCYAN   "\033[1;36m"
 211 #define ANSI_ESC_FG_WHITE   "\033[1;37m"
 212 #define ANSI_ESC_BG         "\033[0;4"    // background esc-squ start with 4x
 213 #define ANSI_ESC_BG_BLACK   "\033[0;40m"
 214 #define ANSI_ESC_BG_RED     "\033[0;41m"
 215 #define ANSI_ESC_BG_GREEN   "\033[0;42m"
 216 #define ANSI_ESC_BG_BROWN   "\033[0;43m"
 217 #define ANSI_ESC_BG_BLUE    "\033[0;44m"
 218 #define ANSI_ESC_BG_PURPLE  "\033[0;45m"
 219 #define ANSI_ESC_BG_CYAN    "\033[0;46m"
 220 #define ANSI_ESC_BG_LGRAY   "\033[0;47m"
 221
 222 /****************************************************************************/
 223
 224 INLINE void _INDENT(void)
 225 {
 226   int i;
 227   for(i=0; i < indent_level; i++)
 228     kprintf(" ");
 229 }
 230
 231 /****************************************************************************/
 232
 233 void _ENTER(unsigned long dclass, const char *file, int line, const char *function)
 234 {
 235   if(isFlagSet(debug_classes, dclass))
 236   {
 237     _INDENT();
 238     if(ansi_output)
 239       kprintf("%s%s:%ld:Entering %s%s\n", ANSI_ESC_FG_BROWN, file, line, function, ANSI_ESC_CLR);
 240     else
 241       kprintf("%s:%ld:Entering %s\n", file, line, function);
 242   }
 243
 244   indent_level++;
 245 }
 246
 247 void _LEAVE(unsigned long dclass, const char *file, int line, const char *function)
 248 {
 249   indent_level--;
 250
 251   if(isFlagSet(debug_classes, dclass))
 252   {
 253     _INDENT();
 254     if(ansi_output)
 255       kprintf("%s%s:%ld:Leaving %s%s\n", ANSI_ESC_FG_BROWN, file, line, function, ANSI_ESC_CLR);
 256     else
 257       kprintf("%s:%ld:Leaving %s\n", file, line, function);
 258   }
 259 }
 260
 261 void _RETURN(unsigned long dclass, const char *file, int line, const char *function, unsigned long result)
 262 {
 263   indent_level--;
 264
 265   if(isFlagSet(debug_classes, dclass))
 266   {
 267     _INDENT();
 268     if(ansi_output)
 269       kprintf("%s%s:%ld:Leaving %s (result 0x%08lx, %ld)%s\n", ANSI_ESC_FG_BROWN, file, line, function, result, result, ANSI_ESC_CLR);
 270     else
 271       kprintf("%s:%ld:Leaving %s (result 0x%08lx, %ld)\n", file, line, function, result, result);
 272   }
 273 }
 274
 275 /****************************************************************************/
 276
 277 void _SHOWVALUE(unsigned long dclass, unsigned long dflags, unsigned long value, int size, const char *name, const char *file, int line)
 278 {
 279   if(isFlagSet(debug_classes, dclass) &&
 280      isFlagSet(debug_flags, dflags))
 281   {
 282     const char *fmt;
 283
 284     switch(size)
 285     {
 286       case 1:
 287         fmt = "%s:%ld:%s = %ld, 0x%02lx";
 288       break;
 289
 290       case 2:
 291         fmt = "%s:%ld:%s = %ld, 0x%04lx";
 292       break;
 293
 294       default:
 295         fmt = "%s:%ld:%s = %ld, 0x%08lx";
 296       break;
 297     }
 298
 299     _INDENT();
 300
 301     if(ansi_output)
 302       kprintf(ANSI_ESC_FG_GREEN);
 303
 304     kprintf(fmt, file, line, name, value, value);
 305
 306     if(size == 1 && value < 256)
 307     {
 308       if(value < ' ' || (value >= 127 && value < 160))
 309         kprintf(", '\\x%02lx'", value);
 310       else
 311         kprintf(", '%lc'", value);
 312     }
 313
 314     if(ansi_output)
 315       kprintf("%s\n", ANSI_ESC_CLR);
 316     else
 317       kprintf("\n");
 318   }
 319 }
 320
 321 /****************************************************************************/
 322
 323 void _SHOWPOINTER(unsigned long dclass, unsigned long dflags, const void *p, const char *name, const char *file, int line)
 324 {
 325   if(isFlagSet(debug_classes, dclass) &&
 326      isFlagSet(debug_flags, dflags))
 327   {
 328     const char *fmt;
 329
 330     _INDENT();
 331
 332     if(p != NULL)
 333       fmt = "%s:%ld:%s = 0x%08lx\n";
 334     else
 335       fmt = "%s:%ld:%s = NULL\n";
 336
 337     if(ansi_output)
 338     {
 339       kprintf(ANSI_ESC_FG_GREEN);
 340       kprintf(fmt, file, line, name, p);
 341       kprintf(ANSI_ESC_CLR);
 342     }
 343     else
 344       kprintf(fmt, file, line, name, p);
 345   }
 346 }
 347
 348 /****************************************************************************/
 349
 350 void _SHOWSTRING(unsigned long dclass, unsigned long dflags, const char *string, const char *name, const char *file, int line)
 351 {
 352   if(isFlagSet(debug_classes, dclass) &&
 353      isFlagSet(debug_flags, dflags))
 354   {
 355     _INDENT();
 356
 357     if(ansi_output)
 358       kprintf("%s%s:%ld:%s = 0x%08lx \"%s\"%s\n", ANSI_ESC_FG_GREEN, file, line, name, string, string, ANSI_ESC_CLR);
 359     else
 360       kprintf("%s:%ld:%s = 0x%08lx \"%s\"\n", file, line, name, string, string);
 361   }
 362 }
 363
 364 /****************************************************************************/
 365
 366 void _SHOWMSG(unsigned long dclass, unsigned long dflags, const char *msg, const char *file, int line)
 367 {
 368   if(isFlagSet(debug_classes, dclass) &&
 369      isFlagSet(debug_flags, dflags))
 370   {
 371     _INDENT();
 372
 373     if(ansi_output)
 374       kprintf("%s%s:%ld:%s%s\n", ANSI_ESC_FG_GREEN, file, line, msg, ANSI_ESC_CLR);
 375     else
 376       kprintf("%s:%ld:%s\n", file, line, msg);
 377   }
 378 }
 379
 380 /****************************************************************************/
 381
 382 void _DPRINTF(unsigned long dclass, unsigned long dflags, const char *file, int line, const char *format, ...)
 383 {
 384   if((isFlagSet(debug_classes, dclass) && isFlagSet(debug_flags, dflags)) ||
 385      (isFlagSet(dclass, DBC_ERROR) || isFlagSet(dclass, DBC_WARNING)))
 386   {
 387     va_list args;
 388     static char buf[1024];
 389
 390     _INDENT();
 391
 392     va_start(args, format);
 393     vsnprintf(buf, 1024, format, args);
 394     va_end(args);
 395
 396     if(ansi_output)
 397     {
 398       const char *highlight = ANSI_ESC_FG_GREEN;
 399
 400       switch(dclass)
 401       {
 402         case DBC_CTRACE:  highlight = ANSI_ESC_FG_BROWN; break;
 403         case DBC_REPORT:  highlight = ANSI_ESC_FG_GREEN; break;
 404         case DBC_ASSERT:  highlight = ANSI_ESC_FG_RED;   break;
 405         case DBC_TIMEVAL: highlight = ANSI_ESC_FG_GREEN; break;
 406         case DBC_DEBUG:   highlight = ANSI_ESC_FG_GREEN; break;
 407         case DBC_ERROR:   highlight = ANSI_ESC_FG_RED;   break;
 408         case DBC_WARNING: highlight = ANSI_ESC_FG_PURPLE;break;
 409       }
 410
 411       kprintf("%s%s:%ld:%s%s\n", highlight, file, line, buf, ANSI_ESC_CLR);
 412     }
 413     else
 414       kprintf("%s:%ld:%s\n", file, line, buf);
 415   }
 416 }
 417
 418 /****************************************************************************/
 419
 420 #endif