Path: utzoo!mnetor!uunet!husc6!cmcl2!rutgers!iuvax!pur-ee!j.cc.purdue.edu!ain
From: ain@j.cc.purdue.edu (Patrick White)
Newsgroups: comp.sources.amiga
Subject: debug routines  (part 1 of 1)
Message-ID: <6008@j.cc.purdue.edu>
Date: 18 Dec 87 21:00:12 GMT
Organization: PUCC Land, USA
Lines: 238
Keywords: debug, C source, part 1 of 1, tested
Approved: ain@j.cc.purdue.edu  (Pat White)

Program Name:	debug source
Submitted By:	John G. Hardie <rutgers!cisunx.psu.edu!psuvax1!pitt!
		jgh2@uunet.uu.net>
Summary:	a set of rotines that aid in debugging programs.
Poster Boy:  Pat White  (ain@j.cc.purdue.edu)
Compiled, but not used.

NOTES:
   I had to change the void for go_away() to an int to get it to compile,
but that was probably because I was too brain dead at the time to figure out
what he was doing.


-- Pat White   (co-moderator comp.sources/binaries.amiga)
UUCP: j.cc.purdue.edu!ain  BITNET: PATWHITE@PURCCVM   PHONE: (317) 743-8421
U.S.  Mail:  320 Brown St. apt. 406,    West Lafayette, IN 47906

----------------------------------------


#	This is a shell archive.
#	Remove everything above and including the cut line.
#	Then run the rest of the file through sh.
#----cut here-----cut here-----cut here-----cut here----#
#!/bin/sh
# shar:	Shell Archiver
#	Run the following text with /bin/sh to create:
#	README
#	debug.c
# This archive created: Fri Dec 18 15:59:15 1987
# By:	Patrick White (PUCC Land, USA)
cat << \SHAR_EOF > README
The following are two routines that I wrote to make tracing C programs
easier.  They aren't sophisticated, nor fancy but they are usually 
sufficient for the purpose, and they are easy to use.

USAGE:	1) compile debug.c -> debug.o
	2) call the debugging routines wherever desired in your
	   source code.
	3) compile and link with debug.o

	That's all folks.

I hope that you find these routines useful.  Let me know.

-- 
John G. Hardie			UUCP:	jgh2@cisunx.UUCP 
Dept. of Physics, 		-or-	jgh2@unix.cis.pittsburgh.edu@pitt
Univ. of Pittsburgh		BIX:	jhardie
Pittsburgh, PA 15260		BITNET:	JGH2@PITTVMS
SHAR_EOF
if test 600 -ne "`wc -c README`"
then
echo shar: error transmitting README '(should have been 600 characters)'
fi
cat << \SHAR_EOF > debug.c
/*************************************************************************
*	Debugging/Tracing routines.
*
*
*	DEBUGGING ROUTINE
*
*	void debug(level,str,int1,int2,doubl1,doubl2)
*	where:
*		level 		- integer  - level of debug call.
*		str   		- char *   - labelling string (may be NULL)
*		int1,2		- int *    - integer args (may be NULL)
*		doubl1,2 	- double * - double args (may be NULL)
*
*	if an argument is NULL, it will not be printed in the debug 
*	message.  The format of the debug message is:
*
*	'DEBUGGER called at level:<lev> with:'
*	'Str: <string>' 
*	'I1=<int1> I2=<int2>'
*	'F1=<doub1> F2=<doub2>'
*
*	The level of debugging can be controlled by setting the
*	appropriate bits in the debugging mask defined below.  The mask
*	globalmask controlls whether there is complete (at all levels)
*	debugging, selective debugging or no debugging.
*
*	The debugging mask works as follows,
*	The mask is a 32 bit unsigned integer, so there are 32 possible
*	debugging levels.  Each bit corresponds to a level.  If a 
*	bit is set, then that level is enabled and debugging info
*	is printed for that level.  If all the bits are set, then the
*	message is printed for all levels, if no bits are set, then
* 	no debugging info is printed.
*
*	In addition, if the flag 'trace' is set, the debug funcion will
*	stop the program after each message is printed and give the user
*	the option to a) continue the program - or -
*		      b) abort the program.
*	In the case of b, the debug funtion will call the function
*	*exitfunc().  The default exitfunc() is the ANSI function 
*	exit(), but it may be reassigned by the user in the debug_level()
*	call.  If any memory is allocated, files opened, libraries opened,
*	etc. it is recommended that you reassign the exit function so
*	that any allocated resources are closed before the program
*	exits.
*
*	Also, if the constant NODEBUGGER is defined, the debug function
*	will be #ifdef'ed out and simply become a Jump/Return pair.
*	(actually, the function will simply do a return, but the compiler
*	will still insert the parameter setup code, stack checking (if
*	enabled) and any other overhead...<sigh>
*
*	SET UP/ DEBUG LEVEL CHANGES
*
*	void debug_level(mask,trace,func)
*	where	mask	- int 	       - mask to be used in defining
*					 the debug level.
*		trace	- int	       - flag.  If set, then debug()
*					 will stop after each message
*					 and wait for the user to signal
*					 that it is OK to continue.
*		func    -(*function)() - pointer to the function that will
*					 be called on exit (if trace is set)
*					 if this field is NULL, the default
*					 function exit() will be called.
*
*	This function may be called to change the default debugging
*	level ( default - NO DEBUGGING ENABLED, TRACE OFF)
*	ie to turn debugging on/off.
*	The routine uses the first parameter to toggle the particular
*	debug level.  For example, if the first argument is 1, then 
*	debugging level 1 will be turned on if it is off, and off if it
*	is on.  If the value is negative, then one of three things can
*	happen.  If the param is -1, debugging will be turned off. If
*	it is -2, debugging will be turned on globally, and if it is
*	any other negative value, then the mask will be complemented,
*	ie, all levels that are on will be turned off, and all that are
*	off will be turned on.
*
*	Problems:  None that I know of.
*
*	Programmed by: John G. Hardie	
*		       UUCP: jgh2@unix.cis.pittsburgh.edu@pitt
*
**************************************************************************/

#include "stdio.h"
#include "string.h"
#include "math.h"
#include "ctype.h"

int (*exitfunc)();			/* pointer to exit function */

static int trace = 0;			/* trace flag */
static unsigned int globalmask = 0;	/* debug mask flags	*/
static reset_defaults = 0;		/* detects the first call and */
					/* allows exitfunc to be init'ld */


void debug(lev,str,int1,int2,dbl1,dbl2)
int lev;
char *str;
int *int1,*int2;
double *dbl1,*dbl2;
{
#ifndef NODEBUGGER

	void go_away();
	char resp;

	if (!reset_defaults)
	{
		exitfunc = go_away;
		reset_defaults++;
	}
	if (globalmask & (1<<lev))
	{
		printf("\n Debugger entered at level %d with:\n",lev);
		if (str)
			printf(" str: %s\n",str);
		if (int1)
			printf("  int 1= %d",*int1);
		if (int2)
			printf("  int 2= %d",*int2);
		putchar('\n');
		if (dbl1)
			printf("  dbl 1= %g",*dbl1);
		if (dbl2)
			printf("  dbl 2= %g",*dbl2);
		putchar('\n');
		if (trace)
		{
			printf("\nTrace: continue program execution? (y or n) ");
			while (!isalpha((resp = getchar())))
				;
			if (resp == 'n')
				(*exitfunc)();
		}
	}
#endif
}


void debug_level(mask,trflag,func)
int mask;
int trflag;
int (*func)();
{
#ifndef	NODEBUGGER
	void go_away();

	if (mask >= 0)
		globalmask |= (1<<mask);
	else if (mask == -1)
		globalmask = 0;
	else if (mask = -2 )
		globalmask = 0xffffffff;
	else 
		globalmask = ~globalmask;
	trace = trflag;
	if (func == NULL)
		exitfunc = go_away;
	else
		exitfunc = func;
#endif
}


void go_away()
{
#ifndef NODEBUGGER
	puts("DEBUGGER: KILLING PROGRAM - EXITING THROUGH DEFAULT HANDLER");
	exit(1999);
#endif
}
SHAR_EOF
if test 5114 -ne "`wc -c debug.c`"
then
echo shar: error transmitting debug.c '(should have been 5114 characters)'
fi
#	End of shell archive
exit 0