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