workbench/classes/zune/betterstring/mcp/Debug.c

   1 /***************************************************************************
   2
   3  BetterString.mcc - A better String gadget MUI Custom Class
   4  Copyright (C) 1997-2000 Allan Odgaard
   5  Copyright (C) 2005-2013 by BetterString.mcc 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  BetterString class Support Site:  http://www.sf.net/projects/bstring-mcc/
  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("** BetterString.mcp v" LIB_REV_STRING " startup ********************\n");
  60   kprintf("Initializing runtime debugging:\n");
  61
  62   if(GetVar("betterstring.mcp.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; const 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; const unsigned long flag; } dbflags[] =
  83     {
  84       { "always",   DBF_ALWAYS  },
  85       { "startup",  DBF_STARTUP },
  86       { "input",    DBF_INPUT   },
  87       { "all",      DBF_ALL     },
  88       { NULL,       0           }
  89     };
  90
  91     // we parse the env variable token-wise
  92     while((tok = strtok(debug, ", ;")))
  93     {
  94       ULONG i;
  95
  96       // check if the token is class definition or
  97       // just a flag definition
  98       if(tok[0] == '@')
  99       {
 100         // check if this call is a negation or not
 101         if(tok[1] == '!')
 102         {
 103           // search for the token and clear the flag
 104           for(i=0; dbclasses[i].token; i++)
 105           {
 106             if(stricmp(tok+2, dbclasses[i].token) == 0)
 107             {
 108               kprintf("clear '%s' debug class flag.\n", dbclasses[i].token);
 109               CLEAR_FLAG(debug_classes, dbclasses[i].flag);
 110             }
 111           }
 112         }
 113         else
 114         {
 115           // search for the token and set the flag
 116           for(i=0; dbclasses[i].token; i++)
 117           {
 118             if(stricmp(tok+1, dbclasses[i].token) == 0)
 119             {
 120               kprintf("set '%s' debug class flag\n", dbclasses[i].token);
 121               SET_FLAG(debug_classes, dbclasses[i].flag);
 122             }
 123           }
 124         }
 125       }
 126       else
 127       {
 128         // check if this call is a negation or not
 129         if(tok[0] == '!')
 130         {
 131           for(i=0; dbflags[i].token; i++)
 132           {
 133             if(stricmp(tok+1, dbflags[i].token) == 0)
 134             {
 135               kprintf("clear '%s' debug flag\n", dbflags[i].token);
 136               CLEAR_FLAG(debug_flags, dbflags[i].flag);
 137             }
 138           }
 139         }
 140         else
 141         {
 142           // check if the token was "ansi" and if so enable the ANSI color
 143           // output
 144           if(stricmp(tok, "ansi") == 0)
 145           {
 146             kprintf("ansi output enabled\n");
 147             ansi_output = TRUE;
 148           }
 149           else
 150           {
 151             for(i=0; dbflags[i].token; i++)
 152             {
 153               if(stricmp(tok, dbflags[i].token) == 0)
 154               {
 155                 kprintf("set '%s' debug flag\n", dbflags[i].token);
 156                 SET_FLAG(debug_flags, dbflags[i].flag);
 157               }
 158             }
 159           }
 160         }
 161       }
 162
 163       debug = NULL;
 164     }
 165   }
 166
 167   kprintf("set debug classes/flags (env:betterstring.mcp.debug): %08lx/%08lx\n", debug_classes, debug_flags);
 168   kprintf("** Normal processing follows ***************************************\n");
 169 }
 170
 171 /****************************************************************************/
 172
 173 void CleanupDebug(void)
 174 {
 175   kprintf("** Cleaned up debugging ********************************************\n");
 176 }
 177
 178 /****************************************************************************/
 179
 180 // define variables for using ANSI colors in our debugging scheme
 181 #define ANSI_ESC_CLR        "\033[0m"
 182 #define ANSI_ESC_BOLD        "\033[1m"
 183 #define ANSI_ESC_UNDERLINE  "\033[4m"
 184 #define ANSI_ESC_BLINK      "\033[5m"
 185 #define ANSI_ESC_REVERSE    "\033[7m"
 186 #define ANSI_ESC_INVISIBLE  "\033[8m"
 187 #define ANSI_ESC_FG_BLACK    "\033[0;30m"
 188 #define ANSI_ESC_FG_RED      "\033[0;31m"
 189 #define ANSI_ESC_FG_GREEN    "\033[0;32m"
 190 #define ANSI_ESC_FG_BROWN    "\033[0;33m"
 191 #define ANSI_ESC_FG_BLUE    "\033[0;34m"
 192 #define ANSI_ESC_FG_PURPLE  "\033[0;35m"
 193 #define ANSI_ESC_FG_CYAN    "\033[0;36m"
 194 #define ANSI_ESC_FG_LGRAY    "\033[0;37m"
 195 #define ANSI_ESC_FG_DGRAY    "\033[1;30m"
 196 #define ANSI_ESC_FG_LRED    "\033[1;31m"
 197 #define ANSI_ESC_FG_LGREEN  "\033[1;32m"
 198 #define ANSI_ESC_FG_YELLOW  "\033[1;33m"
 199 #define ANSI_ESC_FG_LBLUE    "\033[1;34m"
 200 #define ANSI_ESC_FG_LPURPLE  "\033[1;35m"
 201 #define ANSI_ESC_FG_LCYAN    "\033[1;36m"
 202 #define ANSI_ESC_FG_WHITE    "\033[1;37m"
 203 #define ANSI_ESC_BG          "\033[0;4"    // background esc-squ start with 4x
 204 #define ANSI_ESC_BG_BLACK    "\033[0;40m"
 205 #define ANSI_ESC_BG_RED      "\033[0;41m"
 206 #define ANSI_ESC_BG_GREEN    "\033[0;42m"
 207 #define ANSI_ESC_BG_BROWN    "\033[0;43m"
 208 #define ANSI_ESC_BG_BLUE    "\033[0;44m"
 209 #define ANSI_ESC_BG_PURPLE  "\033[0;45m"
 210 #define ANSI_ESC_BG_CYAN    "\033[0;46m"
 211 #define ANSI_ESC_BG_LGRAY    "\033[0;47m"
 212
 213 /****************************************************************************/
 214
 215 INLINE void _INDENT(void)
 216 {
 217   int i;
 218   for(i=0; i < indent_level; i++)
 219     kprintf(" ");
 220 }
 221
 222 /****************************************************************************/
 223
 224 void _ENTER(unsigned long dclass, const char *file, int line, const char *function)
 225 {
 226   if(isFlagSet(debug_classes, dclass))
 227   {
 228     _INDENT();
 229     if(ansi_output)
 230       kprintf("%s%s:%ld:Entering %s%s\n", ANSI_ESC_FG_BROWN, file, line, function, ANSI_ESC_CLR);
 231     else
 232       kprintf("%s:%ld:Entering %s\n", file, line, function);
 233   }
 234
 235   indent_level++;
 236 }
 237
 238 void _LEAVE(unsigned long dclass, const char *file, int line, const char *function)
 239 {
 240   indent_level--;
 241
 242   if(isFlagSet(debug_classes, dclass))
 243   {
 244     _INDENT();
 245     if(ansi_output)
 246       kprintf("%s%s:%ld:Leaving %s%s\n", ANSI_ESC_FG_BROWN, file, line, function, ANSI_ESC_CLR);
 247     else
 248       kprintf("%s:%ld:Leaving %s\n", file, line, function);
 249   }
 250 }
 251
 252 void _RETURN(unsigned long dclass, const char *file, int line, const char *function, unsigned long result)
 253 {
 254   indent_level--;
 255
 256   if(isFlagSet(debug_classes, dclass))
 257   {
 258     _INDENT();
 259     if(ansi_output)
 260       kprintf("%s%s:%ld:Leaving %s (result 0x%08lx, %ld)%s\n", ANSI_ESC_FG_BROWN, file, line, function, result, result, ANSI_ESC_CLR);
 261     else
 262       kprintf("%s:%ld:Leaving %s (result 0x%08lx, %ld)\n", file, line, function, result, result);
 263   }
 264 }
 265
 266 /****************************************************************************/
 267
 268 void _SHOWVALUE(unsigned long dclass, unsigned long dflags, unsigned long value, int size, const char *name, const char *file, int line)
 269 {
 270   if(isFlagSet(debug_classes, dclass) &&
 271      isFlagSet(debug_flags, dflags))
 272   {
 273     const char *fmt;
 274
 275     switch(size)
 276     {
 277       case 1:
 278         fmt = "%s:%ld:%s = %ld, 0x%02lx";
 279       break;
 280
 281       case 2:
 282         fmt = "%s:%ld:%s = %ld, 0x%04lx";
 283       break;
 284
 285       default:
 286         fmt = "%s:%ld:%s = %ld, 0x%08lx";
 287       break;
 288     }
 289
 290     _INDENT();
 291
 292     if(ansi_output)
 293       kprintf(ANSI_ESC_FG_GREEN);
 294
 295     kprintf(fmt, file, line, name, value, value);
 296
 297     if(size == 1 && value < 256)
 298     {
 299       if(value < ' ' || (value >= 127 && value < 160))
 300         kprintf(", '\\x%02lx'", value);
 301       else
 302         kprintf(", '%lc'", value);
 303     }
 304
 305     if(ansi_output)
 306       kprintf("%s\n", ANSI_ESC_CLR);
 307     else
 308       kprintf("\n");
 309   }
 310 }
 311
 312 /****************************************************************************/
 313
 314 void _SHOWPOINTER(unsigned long dclass, unsigned long dflags, const void *p, const char *name, const char *file, int line)
 315 {
 316   if(isFlagSet(debug_classes, dclass) &&
 317      isFlagSet(debug_flags, dflags))
 318   {
 319     const char *fmt;
 320
 321     _INDENT();
 322
 323     if(p != NULL)
 324       fmt = "%s:%ld:%s = 0x%08lx\n";
 325     else
 326       fmt = "%s:%ld:%s = NULL\n";
 327
 328     if(ansi_output)
 329     {
 330       kprintf(ANSI_ESC_FG_GREEN);
 331       kprintf(fmt, file, line, name, p);
 332       kprintf(ANSI_ESC_CLR);
 333     }
 334     else
 335       kprintf(fmt, file, line, name, p);
 336   }
 337 }
 338
 339 /****************************************************************************/
 340
 341 void _SHOWSTRING(unsigned long dclass, unsigned long dflags, const char *string, const char *name, const char *file, int line)
 342 {
 343   if(isFlagSet(debug_classes, dclass) &&
 344      isFlagSet(debug_flags, dflags))
 345   {
 346     _INDENT();
 347
 348     if(ansi_output)
 349       kprintf("%s%s:%ld:%s = 0x%08lx \"%s\"%s\n", ANSI_ESC_FG_GREEN, file, line, name, string, string, ANSI_ESC_CLR);
 350     else
 351       kprintf("%s:%ld:%s = 0x%08lx \"%s\"\n", file, line, name, string, string);
 352   }
 353 }
 354
 355 /****************************************************************************/
 356
 357 void _SHOWMSG(unsigned long dclass, unsigned long dflags, const char *msg, const char *file, int line)
 358 {
 359   if(isFlagSet(debug_classes, dclass) &&
 360      isFlagSet(debug_flags, dflags))
 361   {
 362     _INDENT();
 363
 364     if(ansi_output)
 365       kprintf("%s%s:%ld:%s%s\n", ANSI_ESC_FG_GREEN, file, line, msg, ANSI_ESC_CLR);
 366     else
 367       kprintf("%s:%ld:%s\n", file, line, msg);
 368   }
 369 }
 370
 371 /****************************************************************************/
 372
 373 void _DPRINTF(unsigned long dclass, unsigned long dflags, const char *file, int line, const char *format, ...)
 374 {
 375   if((isFlagSet(debug_classes, dclass) && isFlagSet(debug_flags, dflags)) ||
 376      (isFlagSet(dclass, DBC_ERROR) || isFlagSet(dclass, DBC_WARNING)))
 377   {
 378     va_list args;
 379     static char buf[1024];
 380
 381     _INDENT();
 382
 383     va_start(args, format);
 384     vsnprintf(buf, 1024, format, args);
 385     va_end(args);
 386
 387     if(ansi_output)
 388     {
 389       const char *highlight = ANSI_ESC_FG_GREEN;
 390
 391       switch(dclass)
 392       {
 393         case DBC_CTRACE:  highlight = ANSI_ESC_FG_BROWN; break;
 394         case DBC_REPORT:  highlight = ANSI_ESC_FG_GREEN; break;
 395         case DBC_ASSERT:  highlight = ANSI_ESC_FG_RED;   break;
 396         case DBC_TIMEVAL: highlight = ANSI_ESC_FG_GREEN; break;
 397         case DBC_DEBUG:   highlight = ANSI_ESC_FG_GREEN; break;
 398         case DBC_ERROR:   highlight = ANSI_ESC_FG_RED;   break;
 399         case DBC_WARNING: highlight = ANSI_ESC_FG_PURPLE;break;
 400       }
 401
 402       kprintf("%s%s:%ld:%s%s\n", highlight, file, line, buf, ANSI_ESC_CLR);
 403     }
 404     else
 405       kprintf("%s:%ld:%s\n", file, line, buf);
 406   }
 407 }
 408
 409 /****************************************************************************/
 410
 411 #endif