[people/ms/u-boot.git] / common / cmd_bedbug.c

/*
 * BedBug Functions
 */

#include <common.h>
#include <command.h>
#include <linux/ctype.h>
#include <net.h>

#include <cmd_bedbug.h>
#include <bedbug/bedbug.h>
#include <bedbug/regs.h>
#include <bedbug/ppc.h>
#include <elf.h>

#if (CONFIG_COMMANDS & CFG_CMD_BEDBUG)

#ifndef MAX
#define MAX(a,b) ((a) > (b) ? (a) : (b))
#endif

extern void show_regs __P((struct pt_regs*));
extern int  run_command __P((const char*, int));
extern char console_buffer[];

ulong	      dis_last_addr = 0;        /* Last address disassembled   */
ulong	      dis_last_len = 20;        /* Default disassembler length */
CPU_DEBUG_CTX bug_ctx;                  /* Bedbug context structure    */

\f
/* ======================================================================
 * U-Boot's puts function does not append a newline, so the bedbug stuff
 * will use this for the output of the dis/assembler.
 * ====================================================================== */

int bedbug_puts(const char *str)
{
  /* -------------------------------------------------- */

  printf( "%s\r\n", str );
  return 0;
} /* bedbug_puts */


\f
/* ======================================================================
 * Initialize the bug_ctx structure used by the bedbug debugger.  This is
 * specific to the CPU since each has different debug registers and
 * settings.
 * ====================================================================== */

void bedbug_init( void )
{
  /* -------------------------------------------------- */

#if defined(CONFIG_4xx)
  void bedbug405_init( void );
  bedbug405_init();
#elif defined(CONFIG_8xx)
  void bedbug860_init( void );
  bedbug860_init();
#endif

#if defined(CONFIG_MPC824X) || defined(CONFIG_MPC8260)
  /* Processors that are 603e core based */
  void bedbug603e_init( void );

  bedbug603e_init();
#endif

  return;
} /* bedbug_init */


\f
/* ======================================================================
 * Entry point from the interpreter to the disassembler.  Repeated calls
 * will resume from the last disassembled address.
 * ====================================================================== */
int do_bedbug_dis (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
  ulong	addr;   /* Address to start disassembly from    */
  ulong	len;    /* # of instructions to disassemble     */
  /* -------------------------------------------------- */

  /* Setup to go from the last address if none is given */
  addr = dis_last_addr;
  len  = dis_last_len;

  if (argc < 2)
  {
    printf ("Usage:\n%s\n", cmdtp->usage);
    return 1;
  }

  if(( flag & CMD_FLAG_REPEAT ) == 0 )
  {
    /* New command */
    addr = simple_strtoul( argv[1], NULL, 16 );

    /* If an extra param is given then it is the length */
    if( argc > 2 )
      len = simple_strtoul( argv[2], NULL, 16 );
  }

  /* Run the disassembler */
  disppc( (unsigned char *)addr, 0, len, bedbug_puts, F_RADHEX );

  dis_last_addr = addr + (len * 4);
  dis_last_len = len;
  return 0;
} /* do_bedbug_dis */


\f
/* ======================================================================
 * Entry point from the interpreter to the assembler.  Assembles
 * instructions in consecutive memory locations until a '.' (period) is
 * entered on a line by itself.
 * ====================================================================== */
int do_bedbug_asm (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
  long		mem_addr;               /* Address to assemble into     */
  unsigned long instr;                  /* Machine code for text        */
  char		prompt[ 15 ];           /* Prompt string for user input */
  int		asm_err;                /* Error code from the assembler*/
  /* -------------------------------------------------- */
   int          rcode = 0;

  if (argc < 2)
  {
    printf ("Usage:\n%s\n", cmdtp->usage);
    return 1;
  }

  printf( "\nEnter '.' when done\n" );
  mem_addr = simple_strtoul( argv[ 1 ], NULL, 16 );

  while( 1 )
  {
    putc( '\n' );
    disppc( (unsigned char *)mem_addr, 0, 1, bedbug_puts, F_RADHEX );

    sprintf( prompt, "%08lx:    ", mem_addr );
    readline( prompt );

    if( console_buffer[ 0 ] && strcmp( console_buffer, "." ))
    {
      if(( instr = asmppc( mem_addr, console_buffer, &asm_err )) != 0 )
      {
	*(unsigned long *)mem_addr = instr;
	mem_addr += 4;
      }
      else
      {
	printf( "*** Error: %s ***\n", asm_error_str( asm_err ));
        rcode = 1;
      }
    }
    else
    {
      break;
    }
  }
  return rcode;
} /* do_bedbug_asm */


\f
/* ======================================================================
 * Used to set a break point from the interpreter.  Simply calls into the
 * CPU-specific break point set routine.
 * ====================================================================== */

int do_bedbug_break (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
  /* -------------------------------------------------- */
  if( bug_ctx.do_break )
    (*bug_ctx.do_break)( cmdtp, flag, argc, argv );
    return 0;

} /* do_bedbug_break */


\f
/* ======================================================================
 * Called from the debug interrupt routine.  Simply calls the CPU-specific
 * breakpoint handling routine.
 * ====================================================================== */

void do_bedbug_breakpoint (struct pt_regs *regs)
{
  /* -------------------------------------------------- */

  if( bug_ctx.break_isr )
    (*bug_ctx.break_isr)( regs );

  return;
} /* do_bedbug_breakpoint */


\f
/* ======================================================================
 * Called from the CPU-specific breakpoint handling routine.  Enter a
 * mini main loop until the stopped flag is cleared from the breakpoint
 * context.
 *
 * This handles the parts of the debugger that are common to all CPU's.
 * ====================================================================== */

void bedbug_main_loop( unsigned long addr, struct pt_regs *regs )
{
  int		len;                    /* Length of command line */
  int           flag;                   /* Command flags          */
  int           rc = 0;                 /* Result from run_command*/
  char          prompt_str[ 20 ];       /* Prompt string          */
  static char   lastcommand[ CFG_CBSIZE ] = {0}; /* previous command */
  /* -------------------------------------------------- */

  if( bug_ctx.clear )
    (*bug_ctx.clear)( bug_ctx.current_bp );

  printf( "Breakpoint %d: ", bug_ctx.current_bp );
  disppc( (unsigned char *)addr, 0, 1, bedbug_puts, F_RADHEX );

  bug_ctx.stopped = 1;
  bug_ctx.regs = regs;

  sprintf( prompt_str, "BEDBUG.%d =>", bug_ctx.current_bp );

  /* A miniature main loop */
  while( bug_ctx.stopped )
  {
    len = readline( prompt_str );

    flag = 0;	/* assume no special flags for now */

    if (len > 0)
      strcpy( lastcommand, console_buffer );
    else if( len == 0 )
      flag |= CMD_FLAG_REPEAT;

    if (len == -1)
      printf ("<INTERRUPT>\n");
    else
      rc = run_command( lastcommand, flag );

    if (rc <= 0) {
      /* invalid command or not repeatable, forget it */
      lastcommand[0] = 0;
    }
  }

  bug_ctx.regs = NULL;
  bug_ctx.current_bp = 0;

  return;
} /* bedbug_main_loop */


\f
/* ======================================================================
 * Interpreter command to continue from a breakpoint.  Just clears the
 * stopped flag in the context so that the breakpoint routine will
 * return.
 * ====================================================================== */
int do_bedbug_continue (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])

{
  /* -------------------------------------------------- */

  if( ! bug_ctx.stopped )
  {
    printf( "Not at a breakpoint\n" );
    return 1;
  }

  bug_ctx.stopped = 0;
  return 0;
} /* do_bedbug_continue */


\f
/* ======================================================================
 * Interpreter command to continue to the next instruction, stepping into
 * subroutines.  Works by calling the find_next_addr() routine to compute
 * the address passes control to the CPU-specific set breakpoint routine
 * for the current breakpoint number.
 * ====================================================================== */
int do_bedbug_step (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
  unsigned long addr;   /* Address to stop at */
  /* -------------------------------------------------- */

  if( ! bug_ctx.stopped )
  {
    printf( "Not at a breakpoint\n" );
    return 1;
  }

  if( !find_next_address( (unsigned char *)&addr, FALSE, bug_ctx.regs ))
    return 1;

  if( bug_ctx.set )
    (*bug_ctx.set)( bug_ctx.current_bp, addr );

  bug_ctx.stopped = 0;
  return 0;
} /* do_bedbug_step */


\f
/* ======================================================================
 * Interpreter command to continue to the next instruction, stepping over
 * subroutines.  Works by calling the find_next_addr() routine to compute
 * the address passes control to the CPU-specific set breakpoint routine
 * for the current breakpoint number.
 * ====================================================================== */
int do_bedbug_next (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
  unsigned long addr;   /* Address to stop at */
  /* -------------------------------------------------- */

  if( ! bug_ctx.stopped )
  {
    printf( "Not at a breakpoint\n" );
    return 1;
  }

  if( !find_next_address( (unsigned char *)&addr, TRUE, bug_ctx.regs ))
    return 1;

  if( bug_ctx.set )
    (*bug_ctx.set)( bug_ctx.current_bp, addr );

  bug_ctx.stopped = 0;
  return 0;
} /* do_bedbug_next */


\f
/* ======================================================================
 * Interpreter command to print the current stack.  This assumes an EABI
 * architecture, so it starts with GPR R1 and works back up the stack.
 * ====================================================================== */
int do_bedbug_stack (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
	DECLARE_GLOBAL_DATA_PTR;

  unsigned long sp;             /* Stack pointer                */
  unsigned long func;           /* LR from stack                */
  int           depth;          /* Stack iteration level        */
  int           skip = 1;       /* Flag to skip the first entry */
  unsigned long top;            /* Top of memory address        */
  /* -------------------------------------------------- */

  if( ! bug_ctx.stopped )
  {
    printf( "Not at a breakpoint\n" );
    return 1;
  }

  top = gd->bd->bi_memstart + gd->bd->bi_memsize;
  depth = 0;

  printf( "Depth     PC\n" );
  printf( "-----  --------\n" );
  printf( "%5d  %08lx\n", depth++, bug_ctx.regs->nip );

  sp = bug_ctx.regs->gpr[ 1 ];
  func = *(unsigned long *)(sp+4);

  while(( func < top ) && ( sp < top ))
  {
    if( !skip )
      printf( "%5d  %08lx\n", depth++, func );
    else
      --skip;

    sp = *(unsigned long *)sp;
    func = *(unsigned long *)(sp+4);
  }
  return 0;
} /* do_bedbug_stack */


\f
/* ======================================================================
 * Interpreter command to dump the registers.  Calls the CPU-specific
 * show registers routine.
 * ====================================================================== */
int do_bedbug_rdump (cmd_tbl_t *cmdtp, int flag, int argc, char *argv[])
{
  /* -------------------------------------------------- */

  if( ! bug_ctx.stopped )
  {
    printf( "Not at a breakpoint\n" );
    return 1;
  }

  show_regs( bug_ctx.regs );
  return 0;
} /* do_bedbug_rdump */


/* ====================================================================== */
#endif	/* CFG_CMD_BEDBUG */


/*
 * Copyright (c) 2001 William L. Pitts
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms are freely
 * permitted provided that the above copyright notice and this
 * paragraph and the following disclaimer are duplicated in all
 * such forms.
 *
 * This software is provided "AS IS" and without any express or
 * implied warranties, including, without limitation, the implied
 * warranties of merchantability and fitness for a particular
 * purpose.
 */
Commit	Line	Data
47d1a6e1 WD	1	/*
	2	* BedBug Functions
	3	*/
	4
	5	#include <common.h>
	6	#include <command.h>
	7	#include <linux/ctype.h>
	8	#include <net.h>
	9
	10	#include <cmd_bedbug.h>
	11	#include <bedbug/bedbug.h>
	12	#include <bedbug/regs.h>
	13	#include <bedbug/ppc.h>
	14	#include <elf.h>
	15
	16	#if (CONFIG_COMMANDS & CFG_CMD_BEDBUG)
	17
	18	#ifndef MAX
	19	#define MAX(a,b) ((a) > (b) ? (a) : (b))
	20	#endif
	21
	22	extern void show_regs __P((struct pt_regs*));
	23	extern int run_command __P((const char*, int));
	24	extern char console_buffer[];
	25
	26	ulong dis_last_addr = 0; /* Last address disassembled */
	27	ulong dis_last_len = 20; /* Default disassembler length */
	28	CPU_DEBUG_CTX bug_ctx; /* Bedbug context structure */
	29
	30	\f
	31	/* ======================================================================
	32	* U-Boot's puts function does not append a newline, so the bedbug stuff
	33	* will use this for the output of the dis/assembler.
	34	* ====================================================================== */
	35
	36	int bedbug_puts(const char *str)
	37	{
	38	/* -------------------------------------------------- */
	39
	40	printf( "%s\r\n", str );
	41	return 0;
	42	} /* bedbug_puts */
	43
	44
	45	\f
	46	/* ======================================================================
	47	* Initialize the bug_ctx structure used by the bedbug debugger. This is
	48	* specific to the CPU since each has different debug registers and
	49	* settings.
	50	* ====================================================================== */
	51
	52	void bedbug_init( void )
	53	{
	54	/* -------------------------------------------------- */
	55
	56	#if defined(CONFIG_4xx)
	57	void bedbug405_init( void );
	58	bedbug405_init();
d126bfbd	59	#elif defined(CONFIG_8xx)
47d1a6e1 WD	60	void bedbug860_init( void );
	61	bedbug860_init();
	62	#endif
	63
	64	#if defined(CONFIG_MPC824X) \|\| defined(CONFIG_MPC8260)
	65	/* Processors that are 603e core based */
	66	void bedbug603e_init( void );
	67
	68	bedbug603e_init();
	69	#endif
	70
	71	return;
	72	} /* bedbug_init */
	73
	74
	75	\f
	76	/* ======================================================================
	77	* Entry point from the interpreter to the disassembler. Repeated calls
	78	* will resume from the last disassembled address.
	79	* ====================================================================== */
	80	int do_bedbug_dis (cmd_tbl_t cmdtp, int flag, int argc, char argv[])
	81	{
	82	ulong addr; /* Address to start disassembly from */
	83	ulong len; /* # of instructions to disassemble */
	84	/* -------------------------------------------------- */
	85
	86	/* Setup to go from the last address if none is given */
	87	addr = dis_last_addr;
	88	len = dis_last_len;
	89
	90	if (argc < 2)
	91	{
	92	printf ("Usage:\n%s\n", cmdtp->usage);
	93	return 1;
	94	}
	95
	96	if(( flag & CMD_FLAG_REPEAT ) == 0 )
	97	{
	98	/* New command */
	99	addr = simple_strtoul( argv[1], NULL, 16 );
	100
	101	/* If an extra param is given then it is the length */
	102	if( argc > 2 )
	103	len = simple_strtoul( argv[2], NULL, 16 );
	104	}
	105
	106	/* Run the disassembler */
	107	disppc( (unsigned char *)addr, 0, len, bedbug_puts, F_RADHEX );
	108
	109	dis_last_addr = addr + (len * 4);
	110	dis_last_len = len;
	111	return 0;
	112	} /* do_bedbug_dis */
	113
	114
	115	\f
	116	/* ======================================================================
	117	* Entry point from the interpreter to the assembler. Assembles
	118	* instructions in consecutive memory locations until a '.' (period) is
	119	* entered on a line by itself.
	120	* ====================================================================== */
	121	int do_bedbug_asm (cmd_tbl_t cmdtp, int flag, int argc, char argv[])
	122	{
	123	long mem_addr; /* Address to assemble into */
124	unsigned long instr; /* Machine code for text */
125	char prompt[ 15 ]; /* Prompt string for user input */
126	int asm_err; /* Error code from the assembler*/
127	/* -------------------------------------------------- */
128	int rcode = 0;
129
130	if (argc < 2)
131	{
132	printf ("Usage:\n%s\n", cmdtp->usage);
133	return 1;
134	}
135
136	printf( "\nEnter '.' when done\n" );
137	mem_addr = simple_strtoul( argv[ 1 ], NULL, 16 );
138
139	while( 1 )
140	{
141	putc( '\n' );
142	disppc( (unsigned char *)mem_addr, 0, 1, bedbug_puts, F_RADHEX );
143
144	sprintf( prompt, "%08lx: ", mem_addr );
145	readline( prompt );
146
147	if( console_buffer[ 0 ] && strcmp( console_buffer, "." ))
148	{
149	if(( instr = asmppc( mem_addr, console_buffer, &asm_err )) != 0 )
150	{
151	(unsigned long )mem_addr = instr;
152	mem_addr += 4;
153	}
154	else
155	{
156	printf( "* Error: %s *\n", asm_error_str( asm_err ));
157	rcode = 1;
158	}
159	}
160	else
161	{
162	break;
163	}
164	}
165	return rcode;
166	} /* do_bedbug_asm */
167
168
169	\f
170	/* ======================================================================
171	* Used to set a break point from the interpreter. Simply calls into the
172	* CPU-specific break point set routine.
173	* ====================================================================== */
174
175	int do_bedbug_break (cmd_tbl_t cmdtp, int flag, int argc, char argv[])
176	{
177	/* -------------------------------------------------- */
178	if( bug_ctx.do_break )
179	(*bug_ctx.do_break)( cmdtp, flag, argc, argv );
180	return 0;
181
182	} /* do_bedbug_break */
183
184
185	\f
186	/* ======================================================================
187	* Called from the debug interrupt routine. Simply calls the CPU-specific
188	* breakpoint handling routine.
189	* ====================================================================== */
190
191	void do_bedbug_breakpoint (struct pt_regs *regs)
192	{
193	/* -------------------------------------------------- */
194
195	if( bug_ctx.break_isr )
196	(*bug_ctx.break_isr)( regs );
197
198	return;
199	} /* do_bedbug_breakpoint */
200
201
202	\f
203	/* ======================================================================
204	* Called from the CPU-specific breakpoint handling routine. Enter a
205	* mini main loop until the stopped flag is cleared from the breakpoint
206	* context.
207	*
208	* This handles the parts of the debugger that are common to all CPU's.
209	* ====================================================================== */
210
211	void bedbug_main_loop( unsigned long addr, struct pt_regs *regs )
212	{
213	int len; /* Length of command line */
214	int flag; /* Command flags */
215	int rc = 0; /* Result from run_command*/
216	char prompt_str[ 20 ]; /* Prompt string */
217	static char lastcommand[ CFG_CBSIZE ] = {0}; /* previous command */
218	/* -------------------------------------------------- */
219
220	if( bug_ctx.clear )
221	(*bug_ctx.clear)( bug_ctx.current_bp );
222
223	printf( "Breakpoint %d: ", bug_ctx.current_bp );
224	disppc( (unsigned char *)addr, 0, 1, bedbug_puts, F_RADHEX );
225
226	bug_ctx.stopped = 1;
227	bug_ctx.regs = regs;
228
229	sprintf( prompt_str, "BEDBUG.%d =>", bug_ctx.current_bp );
230
231	/* A miniature main loop */
232	while( bug_ctx.stopped )
233	{
234	len = readline( prompt_str );
235
236	flag = 0; /* assume no special flags for now */
237
238	if (len > 0)
239	strcpy( lastcommand, console_buffer );
240	else if( len == 0 )
241	flag \|= CMD_FLAG_REPEAT;
242
243	if (len == -1)
244	printf ("<INTERRUPT>\n");
245	else
246	rc = run_command( lastcommand, flag );
247
248	if (rc <= 0) {
249	/* invalid command or not repeatable, forget it */
250	lastcommand[0] = 0;
251	}
252	}
253
254	bug_ctx.regs = NULL;
255	bug_ctx.current_bp = 0;
256
257	return;
258	} /* bedbug_main_loop */
259
260
261	\f
262	/* ======================================================================
263	* Interpreter command to continue from a breakpoint. Just clears the
264	* stopped flag in the context so that the breakpoint routine will
265	* return.
266	* ====================================================================== */
267	int do_bedbug_continue (cmd_tbl_t cmdtp, int flag, int argc, char argv[])
268
269	{
270	/* -------------------------------------------------- */
271
272	if( ! bug_ctx.stopped )
273	{
274	printf( "Not at a breakpoint\n" );
275	return 1;
276	}
277
278	bug_ctx.stopped = 0;
279	return 0;
280	} /* do_bedbug_continue */
281
282
283	\f
284	/* ======================================================================
285	* Interpreter command to continue to the next instruction, stepping into
286	* subroutines. Works by calling the find_next_addr() routine to compute
287	* the address passes control to the CPU-specific set breakpoint routine
288	* for the current breakpoint number.
289	* ====================================================================== */
290	int do_bedbug_step (cmd_tbl_t cmdtp, int flag, int argc, char argv[])
291	{
292	unsigned long addr; /* Address to stop at */
293	/* -------------------------------------------------- */
294
295	if( ! bug_ctx.stopped )
296	{
297	printf( "Not at a breakpoint\n" );
298	return 1;
299	}
300
301	if( !find_next_address( (unsigned char *)&addr, FALSE, bug_ctx.regs ))
302	return 1;
303
304	if( bug_ctx.set )
305	(*bug_ctx.set)( bug_ctx.current_bp, addr );
306
307	bug_ctx.stopped = 0;
308	return 0;
309	} /* do_bedbug_step */
310
311
312	\f
313	/* ======================================================================
314	* Interpreter command to continue to the next instruction, stepping over
315	* subroutines. Works by calling the find_next_addr() routine to compute
316	* the address passes control to the CPU-specific set breakpoint routine
317	* for the current breakpoint number.
318	* ====================================================================== */
319	int do_bedbug_next (cmd_tbl_t cmdtp, int flag, int argc, char argv[])
320	{
321	unsigned long addr; /* Address to stop at */
322	/* -------------------------------------------------- */
323
324	if( ! bug_ctx.stopped )
325	{
326	printf( "Not at a breakpoint\n" );
327	return 1;
328	}
329
330	if( !find_next_address( (unsigned char *)&addr, TRUE, bug_ctx.regs ))
331	return 1;
332
333	if( bug_ctx.set )
334	(*bug_ctx.set)( bug_ctx.current_bp, addr );
335
336	bug_ctx.stopped = 0;
337	return 0;
338	} /* do_bedbug_next */
339
340
341	\f
342	/* ======================================================================
343	* Interpreter command to print the current stack. This assumes an EABI
344	* architecture, so it starts with GPR R1 and works back up the stack.
345	* ====================================================================== */
346	int do_bedbug_stack (cmd_tbl_t cmdtp, int flag, int argc, char argv[])
347	{
348	DECLARE_GLOBAL_DATA_PTR;
349
350	unsigned long sp; /* Stack pointer */
351	unsigned long func; /* LR from stack */
352	int depth; /* Stack iteration level */
353	int skip = 1; /* Flag to skip the first entry */
354	unsigned long top; /* Top of memory address */
355	/* -------------------------------------------------- */
356
357	if( ! bug_ctx.stopped )
358	{
359	printf( "Not at a breakpoint\n" );
360	return 1;
361	}
362
363	top = gd->bd->bi_memstart + gd->bd->bi_memsize;
364	depth = 0;
365
366	printf( "Depth PC\n" );
367	printf( "----- --------\n" );
368	printf( "%5d %08lx\n", depth++, bug_ctx.regs->nip );
369
370	sp = bug_ctx.regs->gpr[ 1 ];
371	func = (unsigned long )(sp+4);
372
373	while(( func < top ) && ( sp < top ))
374	{
375	if( !skip )
376	printf( "%5d %08lx\n", depth++, func );
377	else
378	--skip;
379
380	sp = (unsigned long )sp;
381	func = (unsigned long )(sp+4);
382	}
383	return 0;
384	} /* do_bedbug_stack */
385
386
387	\f
388	/* ======================================================================
389	* Interpreter command to dump the registers. Calls the CPU-specific
390	* show registers routine.
391	* ====================================================================== */
392	int do_bedbug_rdump (cmd_tbl_t cmdtp, int flag, int argc, char argv[])
393	{
394	/* -------------------------------------------------- */
395
396	if( ! bug_ctx.stopped )
397	{
398	printf( "Not at a breakpoint\n" );
399	return 1;
400	}
401
402	show_regs( bug_ctx.regs );
403	return 0;
404	} /* do_bedbug_rdump */
405
406
407	/* ====================================================================== */
408	#endif /* CFG_CMD_BEDBUG */
409
410
411	/*
412	* Copyright (c) 2001 William L. Pitts
413	* All rights reserved.
414	*
415	* Redistribution and use in source and binary forms are freely
416	* permitted provided that the above copyright notice and this
417	* paragraph and the following disclaimer are duplicated in all
418	* such forms.
419	*
420	* This software is provided "AS IS" and without any express or
421	* implied warranties, including, without limitation, the implied
422	* warranties of merchantability and fitness for a particular
423	* purpose.
424	*/