workbench/network/smbfs/source_code/assert.c

   1 /*
   2  * $Id$
   3  *
   4  * :ts=8
   5  *
   6  * SMB file system wrapper for AmigaOS, using the AmiTCP V3 API
   7  *
   8  * Copyright (C) 2000-2009 by Olaf `Olsen' Barthel <obarthel -at- gmx -dot- net>
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program 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
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program; if not, write to the Free Software
  22  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23  */
  24
  25 /****************************************************************************/
  26
  27 #include <dos/dos.h>
  28
  29 #include <clib/exec_protos.h>
  30 #include <clib/dos_protos.h>
  31
  32 #ifdef __SASC
  33 #include <pragmas/exec_pragmas.h>
  34 #include <pragmas/dos_pragmas.h>
  35 #else
  36 #include <inline/exec.h>
  37 #include <inline/dos.h>
  38 #endif /* __SASC */
  39
  40 #include <string.h>
  41
  42 #if !defined(__AROS__)
  43 extern struct Library * AbsExecBase;
  44
  45 #define SysBase AbsExecBase
  46 #endif
  47
  48 extern void kprintf(const char *,...);
  49 extern void __stdargs kputc(char c);
  50
  51 /****************************************************************************/
  52
  53 #include <stdarg.h>
  54
  55 /****************************************************************************/
  56
  57 #define DEBUGLEVEL_OnlyAsserts  0
  58 #define DEBUGLEVEL_Reports      1
  59 #define DEBUGLEVEL_CallTracing  2
  60
  61 /****************************************************************************/
  62
  63 static int indent_level = 0;
  64 int __debug_level = DEBUGLEVEL_CallTracing;
  65
  66 static char program_name[40];
  67 static int program_name_len = 0;
  68
  69 /****************************************************************************/
  70
  71 void
  72 _SETPROGRAMNAME(char *name)
  73 {
  74         if(name != NULL && name[0] != '\0')
  75         {
  76                 program_name_len = strlen(name);
  77                 if(program_name_len >= sizeof(program_name))
  78                         program_name_len = sizeof(program_name)-1;
  79
  80                 strncpy(program_name,name,program_name_len);
  81                 program_name[program_name_len] = '\0';
  82         }
  83         else
  84         {
  85                 program_name_len = 0;
  86         }
  87 }
  88
  89 /****************************************************************************/
  90
  91 int
  92 _SETDEBUGLEVEL(int level)
  93 {
  94         int old_level = __debug_level;
  95
  96         __debug_level = level;
  97
  98         return(old_level);
  99 }
 100
 101 /****************************************************************************/
 102
 103 int
 104 _GETDEBUGLEVEL(void)
 105 {
 106         return(__debug_level);
 107 }
 108
 109 /****************************************************************************/
 110
 111 static int previous_debug_level = -1;
 112
 113 void
 114 _PUSHDEBUGLEVEL(int level)
 115 {
 116         previous_debug_level = _SETDEBUGLEVEL(level);
 117 }
 118
 119 void
 120 _POPDEBUGLEVEL(void)
 121 {
 122         if(previous_debug_level != -1)
 123         {
 124                 _SETDEBUGLEVEL(previous_debug_level);
 125
 126                 previous_debug_level = -1;
 127         }
 128 }
 129
 130 /****************************************************************************/
 131
 132 void
 133 _INDENT(void)
 134 {
 135         if(program_name_len > 0)
 136                 kprintf("(%s) ",program_name);
 137
 138         if(__debug_level >= DEBUGLEVEL_CallTracing)
 139         {
 140                 int i;
 141
 142                 for(i = 0 ; i < indent_level ; i++)
 143                         kprintf("   ");
 144         }
 145 }
 146
 147 /****************************************************************************/
 148
 149 void
 150 _SHOWVALUE(
 151         unsigned long value,
 152         int size,
 153         const char *name,
 154         const char *file,
 155         int line)
 156 {
 157         if(__debug_level >= DEBUGLEVEL_Reports)
 158         {
 159                 char *fmt;
 160
 161                 switch(size)
 162                 {
 163                         case 1:
 164
 165                                 fmt = "%s:%ld:%s = %ld, 0x%02lx";
 166                                 break;
 167
 168                         case 2:
 169
 170                                 fmt = "%s:%ld:%s = %ld, 0x%04lx";
 171                                 break;
 172
 173                         default:
 174
 175                                 fmt = "%s:%ld:%s = %ld, 0x%08lx";
 176                                 break;
 177                 }
 178
 179                 _INDENT();
 180
 181                 kprintf(fmt,file,line,name,value,value);
 182
 183                 if(size == 1 && value < 256)
 184                 {
 185                         if(value < ' ' || (value >= 127 && value < 160))
 186                                 kprintf(", '\\x%02lx'",value);
 187                         else
 188                                 kprintf(", '%lc'",value);
 189                 }
 190
 191                 kprintf("\n");
 192         }
 193 }
 194
 195 /****************************************************************************/
 196
 197 void
 198 _SHOWPOINTER(
 199         void *pointer,
 200         const char *name,
 201         const char *file,
 202         int line)
 203 {
 204         if(__debug_level >= DEBUGLEVEL_Reports)
 205         {
 206                 char *fmt;
 207
 208                 _INDENT();
 209
 210                 if(pointer != NULL)
 211                         fmt = "%s:%ld:%s = 0x%08lx\n";
 212                 else
 213                         fmt = "%s:%ld:%s = NULL\n";
 214
 215                 kprintf(fmt,file,line,name,pointer);
 216         }
 217 }
 218
 219 /****************************************************************************/
 220
 221 void
 222 _SHOWSTRING(
 223         const char *string,
 224         const char *name,
 225         const char *file,
 226         int line)
 227 {
 228         if(__debug_level >= DEBUGLEVEL_Reports)
 229         {
 230                 _INDENT();
 231                 kprintf("%s:%ld:%s = 0x%08lx \"%s\"\n",file,line,name,string,string);
 232         }
 233 }
 234
 235 /****************************************************************************/
 236
 237 void
 238 _SHOWMSG(
 239         const char *string,
 240         const char *file,
 241         int line)
 242 {
 243         if(__debug_level >= DEBUGLEVEL_Reports)
 244         {
 245                 _INDENT();
 246                 kprintf("%s:%ld:%s\n",file,line,string);
 247         }
 248 }
 249
 250 /****************************************************************************/
 251
 252 void
 253 _DPRINTF_HEADER(
 254         const char *file,
 255         int line)
 256 {
 257         if(__debug_level >= DEBUGLEVEL_Reports)
 258         {
 259                 _INDENT();
 260                 kprintf("%s:%ld:",file,line);
 261         }
 262 }
 263
 264 #ifdef __SASC
 265
 266 static void __asm
 267 putch(register __d0 UBYTE c)
 268 {
 269         if(c != '\0')
 270                 kputc(c);
 271 }
 272
 273 #else
 274
 275 static void
 276 putch(UBYTE c __asm("d0"))
 277 {
 278         if(c != '\0')
 279                 kputc(c);
 280 }
 281
 282 #endif /* __SASC */
 283
 284 void
 285 _DPRINTF(const char *fmt,...)
 286 {
 287         if(__debug_level >= DEBUGLEVEL_Reports)
 288         {
 289                 va_list args;
 290
 291                 va_start(args,fmt);
 292                 RawDoFmt((char *)fmt,args,(VOID (*)())putch,NULL);
 293                 va_end(args);
 294
 295                 kprintf("\n");
 296         }
 297 }
 298
 299 void
 300 _DLOG(const char *fmt,...)
 301 {
 302         if(__debug_level >= DEBUGLEVEL_Reports)
 303         {
 304                 va_list args;
 305
 306                 va_start(args,fmt);
 307                 RawDoFmt((char *)fmt,args,(VOID (*)())putch,NULL);
 308                 va_end(args);
 309         }
 310 }
 311
 312 /****************************************************************************/
 313
 314 void
 315 _ENTER(
 316         const char *file,
 317         int line,
 318         const char *function)
 319 {
 320         if(__debug_level >= DEBUGLEVEL_CallTracing)
 321         {
 322                 _INDENT();
 323                 kprintf("%s:%ld:Entering %s\n",file,line,function);
 324         }
 325
 326         indent_level++;
 327 }
 328
 329 void
 330 _LEAVE(
 331         const char *file,
 332         int line,
 333         const char *function)
 334 {
 335         indent_level--;
 336
 337         if(__debug_level >= DEBUGLEVEL_CallTracing)
 338         {
 339                 _INDENT();
 340                 kprintf("%s:%ld: Leaving %s\n",file,line,function);
 341         }
 342 }
 343
 344 void
 345 _RETURN(
 346         const char *file,
 347         int line,
 348         const char *function,
 349         unsigned long result)
 350 {
 351         indent_level--;
 352
 353         if(__debug_level >= DEBUGLEVEL_CallTracing)
 354         {
 355                 _INDENT();
 356                 kprintf("%s:%ld: Leaving %s (result 0x%08lx, %ld)\n",file,line,function,result,result);
 357         }
 358 }
 359
 360 /****************************************************************************/
 361
 362 void
 363 _ASSERT(
 364         int x,
 365         const char *xs,
 366         const char *file,
 367         int line,
 368         const char *function)
 369 {
 370         #ifdef CONFIRM
 371         {
 372                 STATIC BOOL ScrollMode  = FALSE;
 373                 STATIC BOOL BatchMode   = FALSE;
 374
 375                 if(BatchMode == FALSE)
 376                 {
 377                         if(x == 0)
 378                         {
 379                                 kprintf("%s:%ld:Expression `%s' failed assertion in %s().\n",
 380                                         file,
 381                                         line,
 382                                         xs,
 383                                         function);
 384
 385                                 if(ScrollMode == FALSE)
 386                                 {
 387                                         ULONG Signals;
 388
 389                                         SetSignal(0,SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D | SIGBREAKF_CTRL_E);
 390
 391                                         kprintf(" ^C to continue, ^D to enter scroll mode, ^E to enter batch mode\r");
 392
 393                                         Signals = Wait(SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D | SIGBREAKF_CTRL_E);
 394
 395                                         if(Signals & SIGBREAKF_CTRL_D)
 396                                         {
 397                                                 ScrollMode = TRUE;
 398
 399                                                 kprintf("Ok, entering scroll mode\033[K\n");
 400                                         }
 401                                         else if (Signals & SIGBREAKF_CTRL_E)
 402                                         {
 403                                                 BatchMode = TRUE;
 404
 405                                                 kprintf("Ok, entering batch mode\033[K\n");
 406                                         }
 407                                         else
 408                                         {
 409                                                 /* Continue */
 410
 411                                                 kprintf("\033[K\r");
 412                                         }
 413                                 }
 414                         }
 415                 }
 416         }
 417         #else
 418         {
 419                 if(x == 0)
 420                 {
 421                         _INDENT();
 422                         kprintf("%s:%ld:Expression `%s' failed assertion in %s().\n",
 423                                 file,
 424                                 line,
 425                                 xs,
 426                                 function);
 427                 }
 428         }
 429         #endif  /* CONFIRM */
 430 }