home *** CD-ROM | disk | FTP | other *** search
/ Magazyn Exec 5 / CD_Magazyn_EXEC_nr_5.iso / Programy / Internet / Samba / smbfs.lha / source / assert.c next >
C/C++ Source or Header  |  2001-01-07  |  7KB  |  385 lines
  1. /*
  2.  * $Id: assert.c 1.7 2001/01/07 09:04:10 olsen Exp olsen $
  3.  *
  4.  * :ts=8
  5.  *
  6.  * SMB file system wrapper for AmigaOS, using the AmiTCP V3 API
  7.  *
  8.  * Copyright (C) 2000-2001 by Olaf `Olsen' Barthel <olsen@sourcery.han.de>
  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. #include <pragmas/exec_pragmas.h>
  33. #include <pragmas/dos_pragmas.h>
  34.  
  35. #include <string.h>
  36.  
  37. extern struct Library * SysBase;
  38.  
  39. extern void kprintf(const char *,...);
  40. extern void __stdargs kputc(char c);
  41.  
  42. /****************************************************************************/
  43.  
  44. #include <stdarg.h>
  45.  
  46. /****************************************************************************/
  47.  
  48. #define DEBUGLEVEL_OnlyAsserts    0
  49. #define DEBUGLEVEL_Reports    1
  50. #define DEBUGLEVEL_CallTracing    2
  51.  
  52. /****************************************************************************/
  53.  
  54. static int indent_level = 0;
  55. static int debug_level = DEBUGLEVEL_CallTracing;
  56.  
  57. static char program_name[40];
  58. static int program_name_len = 0;
  59.  
  60. /****************************************************************************/
  61.  
  62. void
  63. _SETPROGRAMNAME(char *name)
  64. {
  65.     if(name != NULL && name[0] != '\0')
  66.     {
  67.         program_name_len = strlen(name);
  68.         if(program_name_len >= sizeof(program_name))
  69.             program_name_len = sizeof(program_name)-1;
  70.  
  71.         strncpy(program_name,name,program_name_len);
  72.         program_name[program_name_len] = '\0';
  73.     }
  74.     else
  75.     {
  76.         program_name_len = 0;
  77.     }
  78. }
  79.  
  80. /****************************************************************************/
  81.  
  82. int
  83. _SETDEBUGLEVEL(int level)
  84. {
  85.     int old_level = debug_level;
  86.  
  87.     debug_level = level;
  88.  
  89.     return(old_level);
  90. }
  91.  
  92. /****************************************************************************/
  93.  
  94. int
  95. _GETDEBUGLEVEL(void)
  96. {
  97.     return(debug_level);
  98. }
  99.  
  100. /****************************************************************************/
  101.  
  102. static int previous_debug_level = -1;
  103.  
  104. void
  105. _PUSHDEBUGLEVEL(int level)
  106. {
  107.     previous_debug_level = _SETDEBUGLEVEL(level);
  108. }
  109.  
  110. void
  111. _POPDEBUGLEVEL(void)
  112. {
  113.     if(previous_debug_level != -1)
  114.     {
  115.         _SETDEBUGLEVEL(previous_debug_level);
  116.  
  117.         previous_debug_level = -1;
  118.     }
  119. }
  120.  
  121. /****************************************************************************/
  122.  
  123. void
  124. _INDENT(void)
  125. {
  126.     if(program_name_len > 0)
  127.         kprintf("(%s) ",program_name);
  128.  
  129.     if(debug_level >= DEBUGLEVEL_CallTracing)
  130.     {
  131.         int i;
  132.  
  133.         for(i = 0 ; i < indent_level ; i++)
  134.             kprintf("   ");
  135.     }
  136. }
  137.  
  138. /****************************************************************************/
  139.  
  140. void
  141. _SHOWVALUE(
  142.     unsigned long value,
  143.     int size,
  144.     const char *name,
  145.     const char *file,
  146.     int line)
  147. {
  148.     if(debug_level >= DEBUGLEVEL_Reports)
  149.     {
  150.         char *fmt;
  151.  
  152.         switch(size)
  153.         {
  154.             case 1:
  155.  
  156.                 fmt = "%s:%ld:%s = %ld, 0x%02lx";
  157.                 break;
  158.  
  159.             case 2:
  160.  
  161.                 fmt = "%s:%ld:%s = %ld, 0x%04lx";
  162.                 break;
  163.  
  164.             default:
  165.  
  166.                 fmt = "%s:%ld:%s = %ld, 0x%08lx";
  167.                 break;
  168.         }
  169.  
  170.         _INDENT();
  171.  
  172.         kprintf(fmt,file,line,name,value,value);
  173.  
  174.         if(size == 1 && value < 256)
  175.         {
  176.             if(value < ' ' || (value >= 127 && value < 160))
  177.                 kprintf(", '\\x%02lx'",value);
  178.             else
  179.                 kprintf(", '%lc'",value);
  180.         }
  181.  
  182.         kprintf("\n");
  183.     }
  184. }
  185.  
  186. /****************************************************************************/
  187.  
  188. void
  189. _SHOWSTRING(
  190.     const char *string,
  191.     const char *name,
  192.     const char *file,
  193.     int line)
  194. {
  195.     if(debug_level >= DEBUGLEVEL_Reports)
  196.     {
  197.         _INDENT();
  198.         kprintf("%s:%ld:%s = 0x%08lx \"%s\"\n",file,line,name,string,string);
  199.     }
  200. }
  201.  
  202. /****************************************************************************/
  203.  
  204. void
  205. _SHOWMSG(
  206.     const char *string,
  207.     const char *file,
  208.     int line)
  209. {
  210.     if(debug_level >= DEBUGLEVEL_Reports)
  211.     {
  212.         _INDENT();
  213.         kprintf("%s:%ld:%s\n",file,line,string);
  214.     }
  215. }
  216.  
  217. /****************************************************************************/
  218.  
  219. void
  220. _DPRINTF_HEADER(
  221.     const char *file,
  222.     int line)
  223. {
  224.     if(debug_level >= DEBUGLEVEL_Reports)
  225.     {
  226.         _INDENT();
  227.         kprintf("%s:%ld:",file,line);
  228.     }
  229. }
  230.  
  231. static void __asm
  232. putch(register __d0 c)
  233. {
  234.     if(c != '\0')
  235.         kputc(c);
  236. }
  237.  
  238. void
  239. _DPRINTF(const char *fmt,...)
  240. {
  241.     if(debug_level >= DEBUGLEVEL_Reports)
  242.     {
  243.         va_list args;
  244.  
  245.         va_start(args,fmt);
  246.         RawDoFmt((char *)fmt,args,(VOID (*)())putch,NULL);
  247.         va_end(args);
  248.  
  249.         kprintf("\n");
  250.     }
  251. }
  252.  
  253. void
  254. _DLOG(const char *fmt,...)
  255. {
  256.     if(debug_level >= DEBUGLEVEL_Reports)
  257.     {
  258.         va_list args;
  259.  
  260.         va_start(args,fmt);
  261.         RawDoFmt((char *)fmt,args,(VOID (*)())putch,NULL);
  262.         va_end(args);
  263.     }
  264. }
  265.  
  266. /****************************************************************************/
  267.  
  268. void
  269. _ENTER(
  270.     const char *file,
  271.     int line,
  272.     const char *function)
  273. {
  274.     if(debug_level >= DEBUGLEVEL_CallTracing)
  275.     {
  276.         _INDENT();
  277.         kprintf("%s:%ld:Entering %s\n",file,line,function);
  278.     }
  279.  
  280.     indent_level++;
  281. }
  282.  
  283. void
  284. _LEAVE(
  285.     const char *file,
  286.     int line,
  287.     const char *function)
  288. {
  289.     indent_level--;
  290.  
  291.     if(debug_level >= DEBUGLEVEL_CallTracing)
  292.     {
  293.         _INDENT();
  294.         kprintf("%s:%ld: Leaving %s\n",file,line,function);
  295.     }
  296. }
  297.  
  298. void
  299. _RETURN(
  300.     const char *file,
  301.     int line,
  302.     const char *function,
  303.     unsigned long result)
  304. {
  305.     indent_level--;
  306.  
  307.     if(debug_level >= DEBUGLEVEL_CallTracing)
  308.     {
  309.         _INDENT();
  310.         kprintf("%s:%ld: Leaving %s (result 0x%08lx, %ld)\n",file,line,function,result,result);
  311.     }
  312. }
  313.  
  314. /****************************************************************************/
  315.  
  316. void
  317. _ASSERT(
  318.     int x,
  319.     const char *xs,
  320.     const char *file,
  321.     int line,
  322.     const char *function)
  323. {
  324.     #ifdef CONFIRM
  325.     {
  326.         STATIC BOOL ScrollMode    = FALSE;
  327.         STATIC BOOL BatchMode    = FALSE;
  328.  
  329.         if(BatchMode == FALSE)
  330.         {
  331.             if(x == 0)
  332.             {
  333.                 kprintf("%s:%ld:Expression `%s' failed assertion in %s().\n",
  334.                         file,
  335.                         line,
  336.                         xs,
  337.                         function);
  338.  
  339.                 if(ScrollMode == FALSE)
  340.                 {
  341.                     ULONG Signals;
  342.  
  343.                     SetSignal(0,SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D | SIGBREAKF_CTRL_E);
  344.  
  345.                     kprintf(" ^C to continue, ^D to enter scroll mode, ^E to enter batch mode\r");
  346.  
  347.                     Signals = Wait(SIGBREAKF_CTRL_C | SIGBREAKF_CTRL_D | SIGBREAKF_CTRL_E);
  348.  
  349.                     if(Signals & SIGBREAKF_CTRL_D)
  350.                     {
  351.                         ScrollMode = TRUE;
  352.  
  353.                         kprintf("Ok, entering scroll mode\033[K\n");
  354.                     }
  355.                     else if (Signals & SIGBREAKF_CTRL_E)
  356.                     {
  357.                         BatchMode = TRUE;
  358.  
  359.                         kprintf("Ok, entering batch mode\033[K\n");
  360.                     }
  361.                     else
  362.                     {
  363.                         /* Continue */
  364.  
  365.                         kprintf("\033[K\r");
  366.                     }
  367.                 }
  368.             }
  369.         }
  370.     }
  371.     #else
  372.     {
  373.         if(x == 0)
  374.         {
  375.             _INDENT();
  376.             kprintf("%s:%ld:Expression `%s' failed assertion in %s().\n",
  377.                     file,
  378.                     line,
  379.                     xs,
  380.                     function);
  381.         }
  382.     }
  383.     #endif    /* CONFIRM */
  384. }
  385.