external/openurl/prefs/debug.c

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