home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 January / usenetsourcesnewsgroupsinfomagicjanuary1994.iso / sources / misc / volume7 / dbug / part01 next >
Encoding:
Text File  |  1989-07-02  |  60.8 KB  |  2,346 lines
  1. Newsgroups: comp.sources.misc
  2. From: allbery@uunet.UU.NET (Brandon S. Allbery - comp.sources.misc)
  3. Subject: v07i057: DBUG Package (Part 1 of 3)
  4. Reply-To: fnf@estinc.UUCP
  5.  
  6. Posting-number: Volume 7, Issue 57
  7. Submitted-by: fnf@estinc.UUCP
  8. Archive-name: dbug/part01
  9.  
  10. This is the latest version of my dbug package, a relatively portable and
  11. machine independent macro based C debugging package.  The dbug package
  12. has proven to be a very flexible and useful tool for debugging, testing,
  13. and porting C programs.
  14.  
  15. All of the features of the dbug package can be enabled or disabled
  16. dynamically at execution time.  This means that production programs will
  17. run normally when debugging is not enabled, and eliminates the need to
  18. maintain two separate versions of a program during testing.
  19.  
  20. Many of the things easily accomplished with conventional debugging tools,
  21. such as symbolic debuggers, are difficult or impossible with this package,
  22. and vice versa.  Thus the dbug package should not be thought of as a
  23. replacement or substitute for other debugging tools, but simply as a useful
  24. addition to the program development and maintenance environment.
  25.  
  26. One of the new features with this version is stack usage accounting.  You
  27. can discover the total amount of stack used by your program, and the amount
  28. used by each individual function.  You will need to know in which direction
  29. you stack grows (up or down).
  30.  
  31. -Fred Fish   12-Jun-89
  32.  
  33. #--------CUT---------CUT---------CUT---------CUT--------#
  34. #########################################################
  35. #                                                       #
  36. # This is a shell archive file.  To extract files:      #
  37. #                                                       #
  38. #    1)    Make a directory for the files.                 #
  39. #    2) Write a file, such as "file.shar", containing   #
  40. #       this archive file into the directory.           #
  41. #    3) Type "sh file.shar".  Do not use csh.           #
  42. #                                                       #
  43. #########################################################
  44. #
  45. #
  46. echo Extracting dbug.h:
  47. sed 's/^Z//' >dbug.h <<\STUNKYFLUFF
  48. Z/******************************************************************************
  49. Z *                                          *
  50. Z *                               N O T I C E                      *
  51. Z *                                          *
  52. Z *                  Copyright Abandoned, 1987, Fred Fish              *
  53. Z *                                          *
  54. Z *                                          *
  55. Z *    This previously copyrighted work has been placed into the  public     *
  56. Z *    domain  by  the  author  and  may be freely used for any purpose,     *
  57. Z *    private or commercial.                              *
  58. Z *                                          *
  59. Z *    Because of the number of inquiries I was receiving about the  use     *
  60. Z *    of this product in commercially developed works I have decided to     *
  61. Z *    simply make it public domain to further its unrestricted use.   I     *
  62. Z *    specifically  would  be  most happy to see this material become a     *
  63. Z *    part of the standard Unix distributions by AT&T and the  Berkeley     *
  64. Z *    Computer  Science  Research Group, and a standard part of the GNU     *
  65. Z *    system from the Free Software Foundation.                  *
  66. Z *                                          *
  67. Z *    I would appreciate it, as a courtesy, if this notice is  left  in     *
  68. Z *    all copies and derivative works.  Thank you.                  *
  69. Z *                                          *
  70. Z *    The author makes no warranty of any kind  with  respect  to  this     *
  71. Z *    product  and  explicitly disclaims any implied warranties of mer-     *
  72. Z *    chantability or fitness for any particular purpose.              *
  73. Z *                                          *
  74. Z ******************************************************************************
  75. Z */
  76. Z
  77. Z
  78. Z/*
  79. Z *  FILE
  80. Z *
  81. Z *    dbug.h    user include file for programs using the dbug package
  82. Z *
  83. Z *  SYNOPSIS
  84. Z *
  85. Z *    #include <local/dbug.h>
  86. Z *
  87. Z *  SCCS ID
  88. Z *
  89. Z *    @(#)dbug.h    1.12 4/2/89
  90. Z *
  91. Z *  DESCRIPTION
  92. Z *
  93. Z *    Programs which use the dbug package must include this file.
  94. Z *    It contains the appropriate macros to call support routines
  95. Z *    in the dbug runtime library.
  96. Z *
  97. Z *    To disable compilation of the macro expansions define the
  98. Z *    preprocessor symbol "DBUG_OFF".  This will result in null
  99. Z *    macros expansions so that the resulting code will be smaller
  100. Z *    and faster.  (The difference may be smaller than you think
  101. Z *    so this step is recommended only when absolutely necessary).
  102. Z *    In general, tradeoffs between space and efficiency are
  103. Z *    decided in favor of efficiency since space is seldom a
  104. Z *    problem on the new machines).
  105. Z *
  106. Z *    All externally visible symbol names follow the pattern
  107. Z *    "_db_xxx..xx_" to minimize the possibility of a dbug package
  108. Z *    symbol colliding with a user defined symbol.
  109. Z *    
  110. Z *    The DBUG_<N> style macros are obsolete and should not be used
  111. Z *    in new code.  Macros to map them to instances of DBUG_PRINT
  112. Z *    are provided for compatibility with older code.  They may go
  113. Z *    away completely in subsequent releases.
  114. Z *
  115. Z *  AUTHOR
  116. Z *
  117. Z *    Fred Fish
  118. Z *    (Currently employed by Motorola Computer Division, Tempe, Az.)
  119. Z *    hao!noao!mcdsun!fnf
  120. Z *    (602) 438-3614
  121. Z *
  122. Z */
  123. Z
  124. Z
  125. Z/*
  126. Z *    Internally used dbug variables which must be global.
  127. Z */
  128. Z
  129. Z#ifndef DBUG_OFF
  130. Z    extern int _db_on_;            /* TRUE if debug currently enabled */
  131. Z    extern FILE *_db_fp_;        /* Current debug output stream */
  132. Z    extern char *_db_process_;        /* Name of current process */
  133. Z    extern int _db_keyword_ ();        /* Accept/reject keyword */
  134. Z    extern void _db_push_ ();        /* Push state, set up new state */
  135. Z    extern void _db_pop_ ();        /* Pop previous debug state */
  136. Z    extern void _db_enter_ ();        /* New user function entered */
  137. Z    extern void _db_return_ ();        /* User function return */
  138. Z    extern void _db_pargs_ ();        /* Remember args for line */
  139. Z    extern void _db_doprnt_ ();        /* Print debug output */
  140. Z    extern void _db_setjmp_ ();        /* Save debugger environment */
  141. Z    extern void _db_longjmp_ ();    /* Restore debugger environment */
  142. Z# endif
  143. Z
  144. Z
  145. Z/*
  146. Z *    These macros provide a user interface into functions in the
  147. Z *    dbug runtime support library.  They isolate users from changes
  148. Z *    in the MACROS and/or runtime support.
  149. Z *
  150. Z *    The symbols "__LINE__" and "__FILE__" are expanded by the
  151. Z *    preprocessor to the current source file line number and file
  152. Z *    name respectively.
  153. Z *
  154. Z *    WARNING ---  Because the DBUG_ENTER macro allocates space on
  155. Z *    the user function's stack, it must precede any executable
  156. Z *    statements in the user function.
  157. Z *
  158. Z */
  159. Z
  160. Z# ifdef DBUG_OFF
  161. Z#    define DBUG_ENTER(a1)
  162. Z#    define DBUG_RETURN(a1) return(a1)
  163. Z#    define DBUG_VOID_RETURN return
  164. Z#    define DBUG_EXECUTE(keyword,a1)
  165. Z#    define DBUG_PRINT(keyword,arglist)
  166. Z#    define DBUG_2(keyword,format)        /* Obsolete */
  167. Z#    define DBUG_3(keyword,format,a1)        /* Obsolete */
  168. Z#    define DBUG_4(keyword,format,a1,a2)    /* Obsolete */
  169. Z#    define DBUG_5(keyword,format,a1,a2,a3)    /* Obsolete */
  170. Z#    define DBUG_PUSH(a1)
  171. Z#    define DBUG_POP()
  172. Z#    define DBUG_PROCESS(a1)
  173. Z#    define DBUG_FILE (stderr)
  174. Z#    define DBUG_SETJMP setjmp
  175. Z#    define DBUG_LONGJMP longjmp
  176. Z# else
  177. Z#    define DBUG_ENTER(a) \
  178. Z    auto char *_db_func_; auto char *_db_file_; auto int _db_level_; \
  179. Z    auto char *_db_framep_; \
  180. Z    _db_enter_ (a,__FILE__,__LINE__,&_db_func_,&_db_file_,&_db_level_, \
  181. Z            &_db_framep_)
  182. Z#    define DBUG_LEAVE \
  183. Z    (_db_return_ (__LINE__, &_db_func_, &_db_file_, &_db_level_))
  184. Z#    define DBUG_RETURN(a1) return (DBUG_LEAVE, (a1))
  185. Z/*   define DBUG_RETURN(a1) {DBUG_LEAVE; return(a1);}  Alternate form */
  186. Z#    define DBUG_VOID_RETURN {DBUG_LEAVE; return;}
  187. Z#    define DBUG_EXECUTE(keyword,a1) \
  188. Z    {if (_db_on_) {if (_db_keyword_ (keyword)) { a1 }}}
  189. Z#    define DBUG_PRINT(keyword,arglist) \
  190. Z    {if (_db_on_) {_db_pargs_(__LINE__,keyword); _db_doprnt_ arglist;}}
  191. Z#    define DBUG_2(keyword,format) \
  192. Z    DBUG_PRINT(keyword,(format))        /* Obsolete */
  193. Z#    define DBUG_3(keyword,format,a1) \
  194. Z    DBUG_PRINT(keyword,(format,a1))        /* Obsolete */
  195. Z#    define DBUG_4(keyword,format,a1,a2) \
  196. Z    DBUG_PRINT(keyword,(format,a1,a2))    /* Obsolete */
  197. Z#    define DBUG_5(keyword,format,a1,a2,a3) \
  198. Z    DBUG_PRINT(keyword,(format,a1,a2,a3))    /* Obsolete */
  199. Z#    define DBUG_PUSH(a1) _db_push_ (a1)
  200. Z#    define DBUG_POP() _db_pop_ ()
  201. Z#    define DBUG_PROCESS(a1) (_db_process_ = a1)
  202. Z#    define DBUG_FILE (_db_fp_)
  203. Z#    define DBUG_SETJMP(a1) (_db_setjmp_ (), setjmp (a1))
  204. Z#    define DBUG_LONGJMP(a1,a2) (_db_longjmp_ (), longjmp (a1, a2))
  205. Z# endif
  206. STUNKYFLUFF
  207. set `sum dbug.h`
  208. if test 16096 != $1
  209. then
  210. echo dbug.h: Checksum error. Is: $1, should be: 16096.
  211. fi
  212. #
  213. #
  214. echo Extracting dbug.c:
  215. sed 's/^Z//' >dbug.c <<\STUNKYFLUFF
  216. Z/******************************************************************************
  217. Z *                                          *
  218. Z *                               N O T I C E                      *
  219. Z *                                          *
  220. Z *                  Copyright Abandoned, 1987, Fred Fish              *
  221. Z *                                          *
  222. Z *                                          *
  223. Z *    This previously copyrighted work has been placed into the  public     *
  224. Z *    domain  by  the  author  and  may be freely used for any purpose,     *
  225. Z *    private or commercial.                              *
  226. Z *                                          *
  227. Z *    Because of the number of inquiries I was receiving about the  use     *
  228. Z *    of this product in commercially developed works I have decided to     *
  229. Z *    simply make it public domain to further its unrestricted use.   I     *
  230. Z *    specifically  would  be  most happy to see this material become a     *
  231. Z *    part of the standard Unix distributions by AT&T and the  Berkeley     *
  232. Z *    Computer  Science  Research Group, and a standard part of the GNU     *
  233. Z *    system from the Free Software Foundation.                  *
  234. Z *                                          *
  235. Z *    I would appreciate it, as a courtesy, if this notice is  left  in     *
  236. Z *    all copies and derivative works.  Thank you.                  *
  237. Z *                                          *
  238. Z *    The author makes no warranty of any kind  with  respect  to  this     *
  239. Z *    product  and  explicitly disclaims any implied warranties of mer-     *
  240. Z *    chantability or fitness for any particular purpose.              *
  241. Z *                                          *
  242. Z ******************************************************************************
  243. Z */
  244. Z
  245. Z
  246. Z/*
  247. Z *  FILE
  248. Z *
  249. Z *    dbug.c   runtime support routines for dbug package
  250. Z *
  251. Z *  SCCS
  252. Z *
  253. Z *    @(#)dbug.c    1.19 9/5/87
  254. Z *
  255. Z *  DESCRIPTION
  256. Z *
  257. Z *    These are the runtime support routines for the dbug package.
  258. Z *    The dbug package has two main components; the user include
  259. Z *    file containing various macro definitions, and the runtime
  260. Z *    support routines which are called from the macro expansions.
  261. Z *
  262. Z *    Externally visible functions in the runtime support module
  263. Z *    use the naming convention pattern "_db_xx...xx_", thus
  264. Z *    they are unlikely to collide with user defined function names.
  265. Z *
  266. Z *  AUTHOR(S)
  267. Z *
  268. Z *    Fred Fish        (base code)
  269. Z *    Enhanced Software Technologies, Tempe, AZ
  270. Z *    asuvax!mcdphx!estinc!fnf
  271. Z *
  272. Z *    Binayak Banerjee    (profiling enhancements)
  273. Z *    seismo!bpa!sjuvax!bbanerje
  274. Z */
  275. Z
  276. Z
  277. Z#include <stdio.h>
  278. Z
  279. Z#if NO_VARARGS
  280. Z#include "vargs.h"        /* Use our "fake" varargs */
  281. Z#else
  282. Z#include <varargs.h>        /* Use system supplied varargs package */
  283. Z#endif
  284. Z
  285. Z#if amiga
  286. Z#define HZ (50)            /* Probably in some header somewhere */
  287. Z#endif
  288. Z
  289. Z#ifdef M_XENIX            /* Some xenix compilers predefine this */
  290. Z#ifndef xenix
  291. Z#define xenix 1
  292. Z#endif
  293. Z#endif
  294. Z
  295. Z/*
  296. Z *    Manifest constants that should not require any changes.
  297. Z */
  298. Z
  299. Z#define FALSE        0    /* Boolean FALSE */
  300. Z#define TRUE        1    /* Boolean TRUE */
  301. Z#define EOS        '\000'    /* End Of String marker */
  302. Z
  303. Z/*
  304. Z *    Manifest constants which may be "tuned" if desired.
  305. Z */
  306. Z
  307. Z#define PRINTBUF    1024    /* Print buffer size */
  308. Z#define INDENT        4    /* Indentation per trace level */
  309. Z#define MAXDEPTH    200    /* Maximum trace depth default */
  310. Z
  311. Z/*
  312. Z *    The following flags are used to determine which
  313. Z *    capabilities the user has enabled with the state
  314. Z *    push macro.
  315. Z */
  316. Z
  317. Z#define TRACE_ON    000001    /* Trace enabled */
  318. Z#define DEBUG_ON    000002    /* Debug enabled */
  319. Z#define FILE_ON     000004    /* File name print enabled */
  320. Z#define LINE_ON        000010    /* Line number print enabled */
  321. Z#define DEPTH_ON    000020    /* Function nest level print enabled */
  322. Z#define PROCESS_ON    000040    /* Process name print enabled */
  323. Z#define NUMBER_ON    000100    /* Number each line of output */
  324. Z#define PROFILE_ON    000200    /* Print out profiling code */
  325. Z#define PID_ON        000400    /* Identify each line with process id */
  326. Z
  327. Z#define TRACING (stack -> flags & TRACE_ON)
  328. Z#define DEBUGGING (stack -> flags & DEBUG_ON)
  329. Z#define PROFILING (stack -> flags & PROFILE_ON)
  330. Z#define STREQ(a,b) (strcmp(a,b) == 0)
  331. Z
  332. Z/*
  333. Z *    Typedefs to make things more obvious.
  334. Z */
  335. Z
  336. Z#define VOID void        /* Can't use typedef for most compilers */
  337. Ztypedef int BOOLEAN;
  338. Z
  339. Z/*
  340. Z *    Make it easy to change storage classes if necessary.
  341. Z */
  342. Z
  343. Z#define LOCAL static        /* Names not needed by outside world */
  344. Z#define IMPORT extern        /* Names defined externally */
  345. Z#define EXPORT            /* Allocated here, available globally */
  346. Z#define AUTO auto        /* Names to be allocated on stack */
  347. Z#define REGISTER register    /* Names to be placed in registers */
  348. Z
  349. Z/*
  350. Z * The default file for profiling.  Could also add another flag
  351. Z * (G?) which allowed the user to specify this.
  352. Z *
  353. Z * If the automatic variables get allocated on the stack in
  354. Z * reverse order from their declarations, then define AUTOS_REVERSE.
  355. Z * This is used by the code that keeps track of stack usage.  For
  356. Z * forward allocation, the difference in the dbug frame pointers 
  357. Z * represents stack used by the callee function.  For reverse allocation,
  358. Z * the difference represents stack used by the caller function.
  359. Z *
  360. Z */
  361. Z
  362. Z#define PROF_FILE    "dbugmon.out"
  363. Z#define PROF_EFMT    "E\t%ld\t%s\n"
  364. Z#define PROF_SFMT    "S\t%lx\t%lx\t%s\n"
  365. Z#define PROF_XFMT    "X\t%ld\t%s\n"
  366. Z
  367. Z#if M_I386        /* predefined by xenix 386 compiler */
  368. Z#define AUTOS_REVERSE 1
  369. Z#endif
  370. Z
  371. Z/*
  372. Z *    Variables which are available externally but should only
  373. Z *    be accessed via the macro package facilities.
  374. Z */
  375. Z
  376. ZEXPORT FILE *_db_fp_ = stderr;        /* Output stream, default stderr */
  377. ZEXPORT FILE *_db_pfp_ = (FILE *)0;    /* Profile stream, 'dbugmon.out' */
  378. ZEXPORT char *_db_process_ = "dbug";    /* Pointer to process name; argv[0] */
  379. ZEXPORT BOOLEAN _db_on_ = FALSE;        /* TRUE if debugging currently on */
  380. ZEXPORT BOOLEAN _db_pon_ = FALSE;    /* TRUE if debugging currently on */
  381. Z
  382. Z/*
  383. Z *    Externally supplied functions.
  384. Z */
  385. Z
  386. Z#if (unix || xenix)        /* Only needed for unix */
  387. ZIMPORT VOID perror ();        /* Print system/library error */
  388. ZIMPORT int chown ();        /* Change owner of a file */
  389. ZIMPORT int getgid ();        /* Get real group id */
  390. ZIMPORT int getuid ();        /* Get real user id */
  391. ZIMPORT int access ();        /* Test file for access */
  392. Z#else
  393. Z#if !(amiga && LATTICE)
  394. ZLOCAL VOID perror ();        /* Fake system/library error print routine */
  395. Z#endif
  396. Z#endif
  397. Z
  398. Z# if BSD4_3 || sun
  399. ZIMPORT int getrusage ();
  400. Z#endif
  401. Z
  402. ZIMPORT int atoi ();        /* Convert ascii to integer */
  403. ZIMPORT VOID exit ();        /* Terminate execution */
  404. ZIMPORT int fclose ();        /* Close a stream */
  405. ZIMPORT FILE *fopen ();        /* Open a stream */
  406. ZIMPORT int fprintf ();        /* Formatted print on file */
  407. ZIMPORT int vfprintf ();        /* Varargs form of fprintf */
  408. ZIMPORT VOID free ();
  409. ZIMPORT char *malloc ();        /* Allocate memory */
  410. ZIMPORT int strcmp ();        /* Compare strings */
  411. ZIMPORT char *strcpy ();        /* Copy strings around */
  412. ZIMPORT int strlen ();        /* Find length of string */
  413. Z
  414. Z#ifndef fflush            /* This is sometimes a macro */
  415. ZIMPORT int fflush ();        /* Flush output for stream */
  416. Z#endif
  417. Z
  418. Z
  419. Z/*
  420. Z *    The user may specify a list of functions to trace or 
  421. Z *    debug.  These lists are kept in a linear linked list,
  422. Z *    a very simple implementation.
  423. Z */
  424. Z
  425. Zstruct link {
  426. Z    char *string;        /* Pointer to link's contents */
  427. Z    struct link *next_link;    /* Pointer to the next link */
  428. Z};
  429. Z
  430. Z
  431. Z/*
  432. Z *    Debugging states can be pushed or popped off of a
  433. Z *    stack which is implemented as a linked list.  Note
  434. Z *    that the head of the list is the current state and the
  435. Z *    stack is pushed by adding a new state to the head of the
  436. Z *    list or popped by removing the first link.
  437. Z */
  438. Z
  439. Zstruct state {
  440. Z    int flags;                /* Current state flags */
  441. Z    int maxdepth;            /* Current maximum trace depth */
  442. Z    unsigned int delay;            /* Delay after each output line */
  443. Z    int level;                /* Current function nesting level */
  444. Z    FILE *out_file;            /* Current output stream */
  445. Z    FILE *prof_file;            /* Current profiling stream */
  446. Z    struct link *functions;        /* List of functions */
  447. Z    struct link *p_functions;        /* List of profiled functions */
  448. Z    struct link *keywords;        /* List of debug keywords */
  449. Z    struct link *processes;        /* List of process names */
  450. Z    struct state *next_state;        /* Next state in the list */
  451. Z};
  452. Z
  453. ZLOCAL struct state *stack = NULL;    /* Linked list of stacked states */
  454. Z
  455. Z/*
  456. Z *    Local variables not seen by user.
  457. Z */
  458. Z
  459. ZLOCAL int lineno = 0;        /* Current debugger output line number */
  460. ZLOCAL char *func = "?func";    /* Name of current user function */
  461. ZLOCAL char *file = "?file";    /* Name of current user file */
  462. ZLOCAL BOOLEAN init_done = FALSE;/* Set to TRUE when initialization done */
  463. ZLOCAL char **framep = NULL;    /* Pointer to current frame */
  464. Z
  465. Z#if (unix || xenix || amiga)
  466. ZLOCAL int jmplevel;        /* Remember nesting level at setjmp () */
  467. ZLOCAL char *jmpfunc;        /* Remember current function for setjmp */
  468. ZLOCAL char *jmpfile;        /* Remember current file for setjmp */
  469. Z#endif
  470. Z
  471. ZLOCAL struct link *ListParse ();/* Parse a debug command string */
  472. ZLOCAL char *StrDup ();        /* Make a fresh copy of a string */
  473. ZLOCAL VOID OpenFile ();        /* Open debug output stream */
  474. ZLOCAL VOID OpenProfile ();    /* Open profile output stream */
  475. ZLOCAL VOID CloseFile ();    /* Close debug output stream */
  476. ZLOCAL VOID PushState ();    /* Push current debug state */
  477. ZLOCAL VOID ChangeOwner ();    /* Change file owner and group */
  478. ZLOCAL BOOLEAN DoTrace ();    /* Test for tracing enabled */
  479. ZLOCAL BOOLEAN Writable ();    /* Test to see if file is writable */
  480. ZLOCAL unsigned long Clock ();    /* Return current user time (ms) */
  481. ZLOCAL long *DbugMalloc ();    /* Allocate memory for runtime support */
  482. ZLOCAL char *BaseName ();    /* Remove leading pathname components */
  483. ZLOCAL VOID DoPrefix ();        /* Print debugger line prefix */
  484. ZLOCAL VOID FreeList ();        /* Free memory from linked list */
  485. ZLOCAL VOID Indent ();        /* Indent line to specified indent */
  486. Z
  487. Z                /* Supplied in Sys V runtime environ */
  488. ZLOCAL char *strtok ();        /* Break string into tokens */
  489. ZLOCAL char *strrchr ();        /* Find last occurance of char */
  490. Z
  491. Z/*
  492. Z *    The following local variables are used to hold the state information
  493. Z *    between the call to _db_pargs_() and _db_doprnt_(), during
  494. Z *    expansion of the DBUG_PRINT macro.  This is the only macro
  495. Z *    that currently uses these variables.
  496. Z *
  497. Z *    These variables are currently used only by _db_pargs_() and
  498. Z *    _db_doprnt_().
  499. Z */
  500. Z
  501. ZLOCAL int u_line = 0;        /* User source code line number */
  502. ZLOCAL char *u_keyword = "?";    /* Keyword for current macro */
  503. Z
  504. Z/*
  505. Z *    Miscellaneous printf format strings.
  506. Z */
  507. Z 
  508. Z#define ERR_MISSING_RETURN "%s: missing DBUG_RETURN or DBUG_VOID_RETURN macro in function \"%s\"\n"
  509. Z#define ERR_OPEN "%s: can't open debug output stream \"%s\": "
  510. Z#define ERR_CLOSE "%s: can't close debug file: "
  511. Z#define ERR_ABORT "%s: debugger aborting because %s\n"
  512. Z#define ERR_CHOWN "%s: can't change owner/group of \"%s\": "
  513. Z
  514. Z/*
  515. Z *    Macros and defines for testing file accessibility under UNIX.
  516. Z */
  517. Z
  518. Z#if (unix || xenix)
  519. Z#  define A_EXISTS    00        /* Test for file existance */
  520. Z#  define A_EXECUTE    01        /* Test for execute permission */
  521. Z#  define A_WRITE    02        /* Test for write access */
  522. Z#  define A_READ    03        /* Test for read access */
  523. Z#  define EXISTS(pathname) (access (pathname, A_EXISTS) == 0)
  524. Z#  define WRITABLE(pathname) (access (pathname, A_WRITE) == 0)
  525. Z#else
  526. Z#  define EXISTS(pathname) (FALSE)    /* Assume no existance */
  527. Z#endif
  528. Z
  529. Z/*
  530. Z *    Translate some calls among different systems.
  531. Z */
  532. Z
  533. Z#if (unix || xenix)
  534. Z# define Delay sleep
  535. ZIMPORT unsigned int sleep ();    /* Pause for given number of seconds */
  536. Z#endif
  537. Z
  538. Z#if amiga
  539. ZIMPORT int Delay ();        /* Pause for given number of ticks */
  540. Z#endif
  541. Z
  542. Z
  543. Z/*
  544. Z *  FUNCTION
  545. Z *
  546. Z *    _db_push_    push current debugger state and set up new one
  547. Z *
  548. Z *  SYNOPSIS
  549. Z *
  550. Z *    VOID _db_push_ (control)
  551. Z *    char *control;
  552. Z *
  553. Z *  DESCRIPTION
  554. Z *
  555. Z *    Given pointer to a debug control string in "control", pushes
  556. Z *    the current debug state, parses the control string, and sets
  557. Z *    up a new debug state.
  558. Z *
  559. Z *    The only attribute of the new state inherited from the previous
  560. Z *    state is the current function nesting level.  This can be
  561. Z *    overridden by using the "r" flag in the control string.
  562. Z *
  563. Z *    The debug control string is a sequence of colon separated fields
  564. Z *    as follows:
  565. Z *
  566. Z *        <field_1>:<field_2>:...:<field_N>
  567. Z *
  568. Z *    Each field consists of a mandatory flag character followed by
  569. Z *    an optional "," and comma separated list of modifiers:
  570. Z *
  571. Z *        flag[,modifier,modifier,...,modifier]
  572. Z *
  573. Z *    The currently recognized flag characters are:
  574. Z *
  575. Z *        d    Enable output from DBUG_<N> macros for
  576. Z *            for the current state.  May be followed
  577. Z *            by a list of keywords which selects output
  578. Z *            only for the DBUG macros with that keyword.
  579. Z *            A null list of keywords implies output for
  580. Z *            all macros.
  581. Z *
  582. Z *        D    Delay after each debugger output line.
  583. Z *            The argument is the number of tenths of seconds
  584. Z *            to delay, subject to machine capabilities.
  585. Z *            I.E.  -#D,20 is delay two seconds.
  586. Z *
  587. Z *        f    Limit debugging and/or tracing, and profiling to the
  588. Z *            list of named functions.  Note that a null list will
  589. Z *            disable all functions.  The appropriate "d" or "t"
  590. Z *            flags must still be given, this flag only limits their
  591. Z *            actions if they are enabled.
  592. Z *
  593. Z *        F    Identify the source file name for each
  594. Z *            line of debug or trace output.
  595. Z *
  596. Z *        i    Identify the process with the pid for each line of
  597. Z *            debug or trace output.
  598. Z *
  599. Z *        g    Enable profiling.  Create a file called 'dbugmon.out'
  600. Z *            containing information that can be used to profile
  601. Z *            the program.  May be followed by a list of keywords
  602. Z *            that select profiling only for the functions in that
  603. Z *            list.  A null list implies that all functions are
  604. Z *            considered.
  605. Z *
  606. Z *        L    Identify the source file line number for
  607. Z *            each line of debug or trace output.
  608. Z *
  609. Z *        n    Print the current function nesting depth for
  610. Z *            each line of debug or trace output.
  611. Z *    
  612. Z *        N    Number each line of dbug output.
  613. Z *
  614. Z *        o    Redirect the debugger output stream to the
  615. Z *            specified file.  The default output is stderr.
  616. Z *
  617. Z *        p    Limit debugger actions to specified processes.
  618. Z *            A process must be identified with the
  619. Z *            DBUG_PROCESS macro and match one in the list
  620. Z *            for debugger actions to occur.
  621. Z *
  622. Z *        P    Print the current process name for each
  623. Z *            line of debug or trace output.
  624. Z *
  625. Z *        r    When pushing a new state, do not inherit
  626. Z *            the previous state's function nesting level.
  627. Z *            Useful when the output is to start at the
  628. Z *            left margin.
  629. Z *
  630. Z *        t    Enable function call/exit trace lines.
  631. Z *            May be followed by a list (containing only
  632. Z *            one modifier) giving a numeric maximum
  633. Z *            trace level, beyond which no output will
  634. Z *            occur for either debugging or tracing
  635. Z *            macros.  The default is a compile time
  636. Z *            option.
  637. Z *
  638. Z *    Some examples of debug control strings which might appear
  639. Z *    on a shell command line (the "-#" is typically used to
  640. Z *    introduce a control string to an application program) are:
  641. Z *
  642. Z *        -#d:t
  643. Z *        -#d:f,main,subr1:F:L:t,20
  644. Z *        -#d,input,output,files:n
  645. Z *
  646. Z *    For convenience, any leading "-#" is stripped off.
  647. Z *
  648. Z */
  649. Z
  650. Z
  651. ZVOID _db_push_ (control)
  652. Zchar *control;
  653. Z{
  654. Z    REGISTER char *scan;
  655. Z    REGISTER struct link *temp;
  656. Z
  657. Z    if (control && *control == '-') {
  658. Z    if (*++control == '#') {
  659. Z        control++;
  660. Z    }    
  661. Z    }
  662. Z    control = StrDup (control);
  663. Z    PushState ();
  664. Z    scan = strtok (control, ":");
  665. Z    for (; scan != NULL; scan = strtok ((char *)NULL, ":")) {
  666. Z    switch (*scan++) {
  667. Z        case 'd': 
  668. Z        _db_on_ = TRUE;
  669. Z        stack -> flags |= DEBUG_ON;
  670. Z        if (*scan++ == ',') {
  671. Z            stack -> keywords = ListParse (scan);
  672. Z        }
  673. Z            break;
  674. Z        case 'D': 
  675. Z        stack -> delay = 0;
  676. Z        if (*scan++ == ',') {
  677. Z            temp = ListParse (scan);
  678. Z            stack -> delay = DelayArg (atoi (temp -> string));
  679. Z            FreeList (temp);
  680. Z        }
  681. Z        break;
  682. Z        case 'f': 
  683. Z        if (*scan++ == ',') {
  684. Z            stack -> functions = ListParse (scan);
  685. Z        }
  686. Z        break;
  687. Z        case 'F': 
  688. Z        stack -> flags |= FILE_ON;
  689. Z        break;
  690. Z        case 'i':
  691. Z        stack -> flags |= PID_ON;
  692. Z        break;
  693. Z        case 'g': 
  694. Z        _db_pon_ = TRUE;
  695. Z        OpenProfile(PROF_FILE);
  696. Z        stack -> flags |= PROFILE_ON;
  697. Z        if (*scan++ == ',') {
  698. Z            stack -> p_functions = ListParse (scan);
  699. Z        }
  700. Z        break;
  701. Z        case 'L': 
  702. Z        stack -> flags |= LINE_ON;
  703. Z        break;
  704. Z        case 'n': 
  705. Z        stack -> flags |= DEPTH_ON;
  706. Z        break;
  707. Z        case 'N':
  708. Z        stack -> flags |= NUMBER_ON;
  709. Z        break;
  710. Z        case 'o': 
  711. Z        if (*scan++ == ',') {
  712. Z            temp = ListParse (scan);
  713. Z            OpenFile (temp -> string);
  714. Z            FreeList (temp);
  715. Z        } else {
  716. Z            OpenFile ("-");
  717. Z        }
  718. Z        break;
  719. Z        case 'p':
  720. Z        if (*scan++ == ',') {
  721. Z            stack -> processes = ListParse (scan);
  722. Z        }
  723. Z        break;
  724. Z        case 'P': 
  725. Z        stack -> flags |= PROCESS_ON;
  726. Z        break;
  727. Z        case 'r': 
  728. Z        stack -> level = 0;
  729. Z        break;
  730. Z        case 't': 
  731. Z        stack -> flags |= TRACE_ON;
  732. Z        if (*scan++ == ',') {
  733. Z            temp = ListParse (scan);
  734. Z            stack -> maxdepth = atoi (temp -> string);
  735. Z            FreeList (temp);
  736. Z        }
  737. Z        break;
  738. Z    }
  739. Z    }
  740. Z    free (control);
  741. Z}
  742. Z
  743. Z
  744. Z
  745. Z/*
  746. Z *  FUNCTION
  747. Z *
  748. Z *    _db_pop_    pop the debug stack
  749. Z *
  750. Z *  DESCRIPTION
  751. Z *
  752. Z *    Pops the debug stack, returning the debug state to its
  753. Z *    condition prior to the most recent _db_push_ invocation.
  754. Z *    Note that the pop will fail if it would remove the last
  755. Z *    valid state from the stack.  This prevents user errors
  756. Z *    in the push/pop sequence from screwing up the debugger.
  757. Z *    Maybe there should be some kind of warning printed if the
  758. Z *    user tries to pop too many states.
  759. Z *
  760. Z */
  761. Z
  762. ZVOID _db_pop_ ()
  763. Z{
  764. Z    REGISTER struct state *discard;
  765. Z
  766. Z    discard = stack;
  767. Z    if (discard != NULL && discard -> next_state != NULL) {
  768. Z    stack = discard -> next_state;
  769. Z    _db_fp_ = stack -> out_file;
  770. Z    _db_pfp_ = stack -> prof_file;
  771. Z    if (discard -> keywords != NULL) {
  772. Z        FreeList (discard -> keywords);
  773. Z    }
  774. Z    if (discard -> functions != NULL) {
  775. Z        FreeList (discard -> functions);
  776. Z    }
  777. Z    if (discard -> processes != NULL) {
  778. Z        FreeList (discard -> processes);
  779. Z    }
  780. Z    if (discard -> p_functions != NULL) {
  781. Z        FreeList (discard -> p_functions);
  782. Z    }
  783. Z    CloseFile (discard -> out_file);
  784. Z    CloseFile (discard -> prof_file);
  785. Z    free ((char *) discard);
  786. Z    }
  787. Z}
  788. Z
  789. Z
  790. Z/*
  791. Z *  FUNCTION
  792. Z *
  793. Z *    _db_enter_    process entry point to user function
  794. Z *
  795. Z *  SYNOPSIS
  796. Z *
  797. Z *    VOID _db_enter_ (_func_, _file_, _line_,
  798. Z *             _sfunc_, _sfile_, _slevel_, _sframep_)
  799. Z *    char *_func_;        points to current function name
  800. Z *    char *_file_;        points to current file name
  801. Z *    int _line_;        called from source line number
  802. Z *    char **_sfunc_;        save previous _func_
  803. Z *    char **_sfile_;        save previous _file_
  804. Z *    int *_slevel_;        save previous nesting level
  805. Z *    char ***_sframep_;    save previous frame pointer
  806. Z *
  807. Z *  DESCRIPTION
  808. Z *
  809. Z *    Called at the beginning of each user function to tell
  810. Z *    the debugger that a new function has been entered.
  811. Z *    Note that the pointers to the previous user function
  812. Z *    name and previous user file name are stored on the
  813. Z *    caller's stack (this is why the ENTER macro must be
  814. Z *    the first "executable" code in a function, since it
  815. Z *    allocates these storage locations).  The previous nesting
  816. Z *    level is also stored on the callers stack for internal
  817. Z *    self consistency checks.
  818. Z *
  819. Z *    Also prints a trace line if tracing is enabled and
  820. Z *    increments the current function nesting depth.
  821. Z *
  822. Z *    Note that this mechanism allows the debugger to know
  823. Z *    what the current user function is at all times, without
  824. Z *    maintaining an internal stack for the function names.
  825. Z *
  826. Z */
  827. Z
  828. ZVOID _db_enter_ (_func_, _file_, _line_, _sfunc_, _sfile_, _slevel_,
  829. Z         _sframep_)
  830. Zchar *_func_;
  831. Zchar *_file_;
  832. Zint _line_;
  833. Zchar **_sfunc_;
  834. Zchar **_sfile_;
  835. Zint *_slevel_;
  836. Zchar ***_sframep_;
  837. Z{
  838. Z    long stackused;
  839. Z
  840. Z    if (!init_done) {
  841. Z    _db_push_ ("");
  842. Z    }
  843. Z    *_sfunc_ = func;
  844. Z    func = _func_;
  845. Z    *_sfile_ = file;
  846. Z    file = BaseName (_file_);
  847. Z    stack -> level++;
  848. Z    *_slevel_ = stack -> level;
  849. Z    *_sframep_ = framep;
  850. Z    framep = (char **) _sframep_;
  851. Z    if (DoProfile ()) {
  852. Z    if (*framep == NULL) {
  853. Z        stackused = 0;
  854. Z    } else {
  855. Z        stackused = ((long)(*framep)) - ((long)(framep));
  856. Z        stackused = stackused > 0 ? stackused : -stackused;
  857. Z    }
  858. Z    (VOID) fprintf (_db_pfp_, PROF_EFMT , Clock (), func);
  859. Z#if AUTOS_REVERSE
  860. Z    (VOID) fprintf (_db_pfp_, PROF_SFMT, framep, stackused, *_sfunc_);
  861. Z#else
  862. Z    (VOID) fprintf (_db_pfp_, PROF_SFMT, framep, stackused, func);
  863. Z#endif
  864. Z    (VOID) fflush (_db_pfp_);
  865. Z    }
  866. Z    if (DoTrace ()) {
  867. Z    DoPrefix (_line_);
  868. Z    Indent (stack -> level);
  869. Z    (VOID) fprintf (_db_fp_, ">%s\n", func);
  870. Z    (VOID) fflush (_db_fp_);
  871. Z    (VOID) Delay (stack -> delay);
  872. Z    }
  873. Z}
  874. Z
  875. Z
  876. Z/*
  877. Z *  FUNCTION
  878. Z *
  879. Z *    _db_return_    process exit from user function
  880. Z *
  881. Z *  SYNOPSIS
  882. Z *
  883. Z *    VOID _db_return_ (_line_, _sfunc_, _sfile_, _slevel_)
  884. Z *    int _line_;        current source line number
  885. Z *    char **_sfunc_;        where previous _func_ is to be retrieved
  886. Z *    char **_sfile_;        where previous _file_ is to be retrieved
  887. Z *    int *_slevel_;        where previous level was stashed
  888. Z *
  889. Z *  DESCRIPTION
  890. Z *
  891. Z *    Called just before user function executes an explicit or implicit
  892. Z *    return.  Prints a trace line if trace is enabled, decrements
  893. Z *    the current nesting level, and restores the current function and
  894. Z *    file names from the defunct function's stack.
  895. Z *
  896. Z */
  897. Z
  898. ZVOID _db_return_ (_line_, _sfunc_, _sfile_, _slevel_)
  899. Zint _line_;
  900. Zchar **_sfunc_;
  901. Zchar **_sfile_;
  902. Zint *_slevel_;
  903. Z{
  904. Z    if (!init_done) {
  905. Z    _db_push_ ("");
  906. Z    }
  907. Z    if (stack -> level != *_slevel_ && (TRACING || DEBUGGING || PROFILING)) {
  908. Z    (VOID) fprintf (_db_fp_, ERR_MISSING_RETURN, _db_process_, func);
  909. Z    } else if (DoProfile ()) {
  910. Z    (VOID) fprintf (_db_pfp_, PROF_XFMT, Clock(), func);
  911. Z    } else if (DoTrace ()) {
  912. Z    DoPrefix (_line_);
  913. Z    Indent (stack -> level);
  914. Z    (VOID) fprintf (_db_fp_, "<%s\n", func);
  915. Z    }
  916. Z    (VOID) fflush (_db_fp_);
  917. Z    (VOID) Delay (stack -> delay);
  918. Z    stack -> level = *_slevel_ - 1;
  919. Z    func = *_sfunc_;
  920. Z    file = *_sfile_;
  921. Z    if (framep != NULL) {
  922. Z    framep = (char **) *framep;
  923. Z    }
  924. Z}
  925. Z
  926. Z
  927. Z/*
  928. Z *  FUNCTION
  929. Z *
  930. Z *    _db_pargs_    log arguments for subsequent use by _db_doprnt_()
  931. Z *
  932. Z *  SYNOPSIS
  933. Z *
  934. Z *    VOID _db_pargs_ (_line_, keyword)
  935. Z *    int _line_;
  936. Z *    char *keyword;
  937. Z *
  938. Z *  DESCRIPTION
  939. Z *
  940. Z *    The new universal printing macro DBUG_PRINT, which replaces
  941. Z *    all forms of the DBUG_N macros, needs two calls to runtime
  942. Z *    support routines.  The first, this function, remembers arguments
  943. Z *    that are used by the subsequent call to _db_doprnt_().
  944. Z*
  945. Z */
  946. Z
  947. ZVOID _db_pargs_ (_line_, keyword)
  948. Zint _line_;
  949. Zchar *keyword;
  950. Z{
  951. Z    u_line = _line_;
  952. Z    u_keyword = keyword;
  953. Z}
  954. Z
  955. Z
  956. Z/*
  957. Z *  FUNCTION
  958. Z *
  959. Z *    _db_doprnt_    handle print of debug lines
  960. Z *
  961. Z *  SYNOPSIS
  962. Z *
  963. Z *    VOID _db_doprnt_ (format, va_alist)
  964. Z *    char *format;
  965. Z *    va_dcl;
  966. Z *
  967. Z *  DESCRIPTION
  968. Z *
  969. Z *    When invoked via one of the DBUG macros, tests the current keyword
  970. Z *    set by calling _db_pargs_() to see if that macro has been selected
  971. Z *    for processing via the debugger control string, and if so, handles
  972. Z *    printing of the arguments via the format string.  The line number
  973. Z *    of the DBUG macro in the source is found in u_line.
  974. Z *
  975. Z *    Note that the format string SHOULD NOT include a terminating
  976. Z *    newline, this is supplied automatically.
  977. Z *
  978. Z */
  979. Z
  980. Z/*VARARGS1*/
  981. ZVOID _db_doprnt_ (format, va_alist)
  982. Zchar *format;
  983. Zva_dcl
  984. Z{
  985. Z    va_list args;
  986. Z
  987. Z    va_start (args);
  988. Z    if (_db_keyword_ (u_keyword)) {
  989. Z    DoPrefix (u_line);
  990. Z    if (TRACING) {
  991. Z        Indent (stack -> level + 1);
  992. Z    } else {
  993. Z        (VOID) fprintf (_db_fp_, "%s: ", func);
  994. Z    }
  995. Z    (VOID) fprintf (_db_fp_, "%s: ", u_keyword);
  996. Z    (VOID) vfprintf (_db_fp_, format, args);
  997. Z    (VOID) fprintf (_db_fp_, "\n");
  998. Z    (VOID) fflush (_db_fp_);
  999. Z    (VOID) Delay (stack -> delay);
  1000. Z    }
  1001. Z    va_end (args);
  1002. Z}
  1003. Z
  1004. Z
  1005. Z/*
  1006. Z *  FUNCTION
  1007. Z *
  1008. Z *    ListParse    parse list of modifiers in debug control string
  1009. Z *
  1010. Z *  SYNOPSIS
  1011. Z *
  1012. Z *    LOCAL struct link *ListParse (ctlp)
  1013. Z *    char *ctlp;
  1014. Z *
  1015. Z *  DESCRIPTION
  1016. Z *
  1017. Z *    Given pointer to a comma separated list of strings in "cltp",
  1018. Z *    parses the list, building a list and returning a pointer to it.
  1019. Z *    The original comma separated list is destroyed in the process of
  1020. Z *    building the linked list, thus it had better be a duplicate
  1021. Z *    if it is important.
  1022. Z *
  1023. Z *    Note that since each link is added at the head of the list,
  1024. Z *    the final list will be in "reverse order", which is not
  1025. Z *    significant for our usage here.
  1026. Z *
  1027. Z */
  1028. Z
  1029. ZLOCAL struct link *ListParse (ctlp)
  1030. Zchar *ctlp;
  1031. Z{
  1032. Z    REGISTER char *start;
  1033. Z    REGISTER struct link *new;
  1034. Z    REGISTER struct link *head;
  1035. Z
  1036. Z    head = NULL;
  1037. Z    while (*ctlp != EOS) {
  1038. Z    start = ctlp;
  1039. Z    while (*ctlp != EOS && *ctlp != ',') {
  1040. Z        ctlp++;
  1041. Z    }
  1042. Z    if (*ctlp == ',') {
  1043. Z        *ctlp++ = EOS;
  1044. Z    }
  1045. Z    new = (struct link *) DbugMalloc (sizeof (struct link));
  1046. Z    new -> string = StrDup (start);
  1047. Z    new -> next_link = head;
  1048. Z    head = new;
  1049. Z    }
  1050. Z    return (head);
  1051. Z}
  1052. Z
  1053. Z
  1054. Z/*
  1055. Z *  FUNCTION
  1056. Z *
  1057. Z *    InList    test a given string for member of a given list
  1058. Z *
  1059. Z *  SYNOPSIS
  1060. Z *
  1061. Z *    LOCAL BOOLEAN InList (linkp, cp)
  1062. Z *    struct link *linkp;
  1063. Z *    char *cp;
  1064. Z *
  1065. Z *  DESCRIPTION
  1066. Z *
  1067. Z *    Tests the string pointed to by "cp" to determine if it is in
  1068. Z *    the list pointed to by "linkp".  Linkp points to the first
  1069. Z *    link in the list.  If linkp is NULL then the string is treated
  1070. Z *    as if it is in the list (I.E all strings are in the null list).
  1071. Z *    This may seem rather strange at first but leads to the desired
  1072. Z *    operation if no list is given.  The net effect is that all
  1073. Z *    strings will be accepted when there is no list, and when there
  1074. Z *    is a list, only those strings in the list will be accepted.
  1075. Z *
  1076. Z */
  1077. Z
  1078. ZLOCAL BOOLEAN InList (linkp, cp)
  1079. Zstruct link *linkp;
  1080. Zchar *cp;
  1081. Z{
  1082. Z    REGISTER struct link *scan;
  1083. Z    REGISTER BOOLEAN accept;
  1084. Z
  1085. Z    if (linkp == NULL) {
  1086. Z    accept = TRUE;
  1087. Z    } else {
  1088. Z    accept = FALSE;
  1089. Z    for (scan = linkp; scan != NULL; scan = scan -> next_link) {
  1090. Z        if (STREQ (scan -> string, cp)) {
  1091. Z        accept = TRUE;
  1092. Z        break;
  1093. Z        }
  1094. Z    }
  1095. Z    }
  1096. Z    return (accept);
  1097. Z}
  1098. Z
  1099. Z
  1100. Z/*
  1101. Z *  FUNCTION
  1102. Z *
  1103. Z *    PushState    push current state onto stack and set up new one
  1104. Z *
  1105. Z *  SYNOPSIS
  1106. Z *
  1107. Z *    LOCAL VOID PushState ()
  1108. Z *
  1109. Z *  DESCRIPTION
  1110. Z *
  1111. Z *    Pushes the current state on the state stack, and initializes
  1112. Z *    a new state.  The only parameter inherited from the previous
  1113. Z *    state is the function nesting level.  This action can be
  1114. Z *    inhibited if desired, via the "r" flag.
  1115. Z *
  1116. Z *    The state stack is a linked list of states, with the new
  1117. Z *    state added at the head.  This allows the stack to grow
  1118. Z *    to the limits of memory if necessary.
  1119. Z *
  1120. Z */
  1121. Z
  1122. ZLOCAL VOID PushState ()
  1123. Z{
  1124. Z    REGISTER struct state *new;
  1125. Z
  1126. Z    new = (struct state *) DbugMalloc (sizeof (struct state));
  1127. Z    new -> flags = 0;
  1128. Z    new -> delay = 0;
  1129. Z    new -> maxdepth = MAXDEPTH;
  1130. Z    if (stack != NULL) {
  1131. Z    new -> level = stack -> level;
  1132. Z    } else {
  1133. Z    new -> level = 0;
  1134. Z    }
  1135. Z    new -> out_file = stderr;
  1136. Z    new -> functions = NULL;
  1137. Z    new -> p_functions = NULL;
  1138. Z    new -> keywords = NULL;
  1139. Z    new -> processes = NULL;
  1140. Z    new -> next_state = stack;
  1141. Z    stack = new;
  1142. Z    init_done = TRUE;
  1143. Z}
  1144. Z
  1145. Z
  1146. Z/*
  1147. Z *  FUNCTION
  1148. Z *
  1149. Z *    DoTrace    check to see if tracing is current enabled
  1150. Z *
  1151. Z *  SYNOPSIS
  1152. Z *
  1153. Z *    LOCAL BOOLEAN DoTrace ()
  1154. Z *
  1155. Z *  DESCRIPTION
  1156. Z *
  1157. Z *    Checks to see if tracing is enabled based on whether the
  1158. Z *    user has specified tracing, the maximum trace depth has
  1159. Z *    not yet been reached, the current function is selected,
  1160. Z *    and the current process is selected.  Returns TRUE if
  1161. Z *    tracing is enabled, FALSE otherwise.
  1162. Z *
  1163. Z */
  1164. Z
  1165. ZLOCAL BOOLEAN DoTrace ()
  1166. Z{
  1167. Z    REGISTER BOOLEAN trace;
  1168. Z
  1169. Z    trace = FALSE;
  1170. Z    if (TRACING) {
  1171. Z    if (stack -> level <= stack -> maxdepth) {
  1172. Z        if (InList (stack -> functions, func)) {
  1173. Z        if (InList (stack -> processes, _db_process_)) {
  1174. Z            trace = TRUE;
  1175. Z        }
  1176. Z        }
  1177. Z    }
  1178. Z    }
  1179. Z    return (trace);
  1180. Z}
  1181. Z
  1182. Z
  1183. Z/*
  1184. Z *  FUNCTION
  1185. Z *
  1186. Z *    DoProfile    check to see if profiling is current enabled
  1187. Z *
  1188. Z *  SYNOPSIS
  1189. Z *
  1190. Z *    LOCAL BOOLEAN DoProfile ()
  1191. Z *
  1192. Z *  DESCRIPTION
  1193. Z *
  1194. Z *    Checks to see if profiling is enabled based on whether the
  1195. Z *    user has specified profiling, the maximum trace depth has
  1196. Z *    not yet been reached, the current function is selected,
  1197. Z *    and the current process is selected.  Returns TRUE if
  1198. Z *    profiling is enabled, FALSE otherwise.
  1199. Z *
  1200. Z */
  1201. Z
  1202. ZLOCAL BOOLEAN DoProfile ()
  1203. Z{
  1204. Z    REGISTER BOOLEAN profile;
  1205. Z
  1206. Z    profile = FALSE;
  1207. Z    if (PROFILING) {
  1208. Z    if (stack -> level <= stack -> maxdepth) {
  1209. Z        if (InList (stack -> p_functions, func)) {
  1210. Z        if (InList (stack -> processes, _db_process_)) {
  1211. Z            profile = TRUE;
  1212. Z        }
  1213. Z        }
  1214. Z    }
  1215. Z    }
  1216. Z    return (profile);
  1217. Z}
  1218. Z
  1219. Z
  1220. Z/*
  1221. Z *  FUNCTION
  1222. Z *
  1223. Z *    _db_keyword_    test keyword for member of keyword list
  1224. Z *
  1225. Z *  SYNOPSIS
  1226. Z *
  1227. Z *    BOOLEAN _db_keyword_ (keyword)
  1228. Z *    char *keyword;
  1229. Z *
  1230. Z *  DESCRIPTION
  1231. Z *
  1232. Z *    Test a keyword to determine if it is in the currently active
  1233. Z *    keyword list.  As with the function list, a keyword is accepted
  1234. Z *    if the list is null, otherwise it must match one of the list
  1235. Z *    members.  When debugging is not on, no keywords are accepted.
  1236. Z *    After the maximum trace level is exceeded, no keywords are
  1237. Z *    accepted (this behavior subject to change).  Additionally,
  1238. Z *    the current function and process must be accepted based on
  1239. Z *    their respective lists.
  1240. Z *
  1241. Z *    Returns TRUE if keyword accepted, FALSE otherwise.
  1242. Z *
  1243. Z */
  1244. Z
  1245. ZBOOLEAN _db_keyword_ (keyword)
  1246. Zchar *keyword;
  1247. Z{
  1248. Z    REGISTER BOOLEAN accept;
  1249. Z
  1250. Z    if (!init_done) {
  1251. Z    _db_push_ ("");
  1252. Z    }
  1253. Z    accept = FALSE;
  1254. Z    if (DEBUGGING) {
  1255. Z    if (stack -> level <= stack -> maxdepth) {
  1256. Z        if (InList (stack -> functions, func)) {
  1257. Z        if (InList (stack -> keywords, keyword)) {
  1258. Z            if (InList (stack -> processes, _db_process_)) {
  1259. Z            accept = TRUE;
  1260. Z            }
  1261. Z        }
  1262. Z        }
  1263. Z    }
  1264. Z    }
  1265. Z    return (accept);
  1266. Z}
  1267. Z
  1268. Z
  1269. Z/*
  1270. Z *  FUNCTION
  1271. Z *
  1272. Z *    Indent    indent a line to the given indentation level
  1273. Z *
  1274. Z *  SYNOPSIS
  1275. Z *
  1276. Z *    LOCAL VOID Indent (indent)
  1277. Z *    int indent;
  1278. Z *
  1279. Z *  DESCRIPTION
  1280. Z *
  1281. Z *    Indent a line to the given level.  Note that this is
  1282. Z *    a simple minded but portable implementation.
  1283. Z *    There are better ways.
  1284. Z *
  1285. Z *    Also, the indent must be scaled by the compile time option
  1286. Z *    of character positions per nesting level.
  1287. Z *
  1288. Z */
  1289. Z
  1290. ZLOCAL VOID Indent (indent)
  1291. Zint indent;
  1292. Z{
  1293. Z    REGISTER int count;
  1294. Z    AUTO char buffer[PRINTBUF];
  1295. Z
  1296. Z    indent *= INDENT;
  1297. Z    for (count = 0; (count < (indent - INDENT)) && (count < (PRINTBUF - 1)); count++) {
  1298. Z    if ((count % INDENT) == 0) {
  1299. Z        buffer[count] = '|';
  1300. Z    } else {
  1301. Z        buffer[count] = ' ';
  1302. Z    }
  1303. Z    }
  1304. Z    buffer[count] = EOS;
  1305. Z    (VOID) fprintf (_db_fp_, buffer);
  1306. Z    (VOID) fflush (_db_fp_);
  1307. Z}
  1308. Z
  1309. Z
  1310. Z/*
  1311. Z *  FUNCTION
  1312. Z *
  1313. Z *    FreeList    free all memory associated with a linked list
  1314. Z *
  1315. Z *  SYNOPSIS
  1316. Z *
  1317. Z *    LOCAL VOID FreeList (linkp)
  1318. Z *    struct link *linkp;
  1319. Z *
  1320. Z *  DESCRIPTION
  1321. Z *
  1322. Z *    Given pointer to the head of a linked list, frees all
  1323. Z *    memory held by the list and the members of the list.
  1324. Z *
  1325. Z */
  1326. Z
  1327. ZLOCAL VOID FreeList (linkp)
  1328. Zstruct link *linkp;
  1329. Z{
  1330. Z    REGISTER struct link *old;
  1331. Z
  1332. Z    while (linkp != NULL) {
  1333. Z    old = linkp;
  1334. Z    linkp = linkp -> next_link;
  1335. Z    if (old -> string != NULL) {
  1336. Z        free (old -> string);
  1337. Z    }
  1338. Z    free ((char *) old);
  1339. Z    }
  1340. Z}
  1341. Z
  1342. Z
  1343. Z/*
  1344. Z *  FUNCTION
  1345. Z *
  1346. Z *    StrDup   make a duplicate of a string in new memory
  1347. Z *
  1348. Z *  SYNOPSIS
  1349. Z *
  1350. Z *    LOCAL char *StrDup (string)
  1351. Z *    char *string;
  1352. Z *
  1353. Z *  DESCRIPTION
  1354. Z *
  1355. Z *    Given pointer to a string, allocates sufficient memory to make
  1356. Z *    a duplicate copy, and copies the string to the newly allocated
  1357. Z *    memory.  Failure to allocated sufficient memory is immediately
  1358. Z *    fatal.
  1359. Z *
  1360. Z */
  1361. Z
  1362. Z
  1363. ZLOCAL char *StrDup (string)
  1364. Zchar *string;
  1365. Z{
  1366. Z    REGISTER char *new;
  1367. Z
  1368. Z    new = (char *) DbugMalloc (strlen (string) + 1);
  1369. Z    (VOID) strcpy (new, string);
  1370. Z    return (new);
  1371. Z}
  1372. Z
  1373. Z
  1374. Z/*
  1375. Z *  FUNCTION
  1376. Z *
  1377. Z *    DoPrefix    print debugger line prefix prior to indentation
  1378. Z *
  1379. Z *  SYNOPSIS
  1380. Z *
  1381. Z *    LOCAL VOID DoPrefix (_line_)
  1382. Z *    int _line_;
  1383. Z *
  1384. Z *  DESCRIPTION
  1385. Z *
  1386. Z *    Print prefix common to all debugger output lines, prior to
  1387. Z *    doing indentation if necessary.  Print such information as
  1388. Z *    current process name, current source file name and line number,
  1389. Z *    and current function nesting depth.
  1390. Z *
  1391. Z */
  1392. Z  
  1393. Z 
  1394. ZLOCAL VOID DoPrefix (_line_)
  1395. Zint _line_;
  1396. Z{
  1397. Z#if (unix || xenix)
  1398. Z    extern int getpid ();
  1399. Z#endif
  1400. Z
  1401. Z    lineno++;
  1402. Z#if (unix || xenix)
  1403. Z    if (stack -> flags & PID_ON) {
  1404. Z    (VOID) fprintf (_db_fp_, "%5d: ", getpid ());
  1405. Z    }
  1406. Z#endif
  1407. Z    if (stack -> flags & NUMBER_ON) {
  1408. Z    (VOID) fprintf (_db_fp_, "%5d: ", lineno);
  1409. Z    }
  1410. Z    if (stack -> flags & PROCESS_ON) {
  1411. Z    (VOID) fprintf (_db_fp_, "%s: ", _db_process_);
  1412. Z    }
  1413. Z    if (stack -> flags & FILE_ON) {
  1414. Z    (VOID) fprintf (_db_fp_, "%14s: ", file);
  1415. Z    }
  1416. Z    if (stack -> flags & LINE_ON) {
  1417. Z    (VOID) fprintf (_db_fp_, "%5d: ", _line_);
  1418. Z    }
  1419. Z    if (stack -> flags & DEPTH_ON) {
  1420. Z    (VOID) fprintf (_db_fp_, "%4d: ", stack -> level);
  1421. Z    }
  1422. Z    (VOID) fflush (_db_fp_);
  1423. Z}
  1424. Z
  1425. Z
  1426. Z/*
  1427. Z *  FUNCTION
  1428. Z *
  1429. Z *    OpenFile    open new output stream for debugger output
  1430. Z *
  1431. Z *  SYNOPSIS
  1432. Z *
  1433. Z *    LOCAL VOID OpenFile (name)
  1434. Z *    char *name;
  1435. Z *
  1436. Z *  DESCRIPTION
  1437. Z *
  1438. Z *    Given name of a new file (or "-" for stdout) opens the file
  1439. Z *    and sets the output stream to the new file.
  1440. Z *
  1441. Z */
  1442. Z
  1443. ZLOCAL VOID OpenFile (name)
  1444. Zchar *name;
  1445. Z{
  1446. Z    REGISTER FILE *fp;
  1447. Z    REGISTER BOOLEAN newfile;
  1448. Z
  1449. Z    if (name != NULL) {
  1450. Z    if (strcmp (name, "-") == 0) {
  1451. Z        _db_fp_ = stdout;
  1452. Z        stack -> out_file = _db_fp_;
  1453. Z    } else {
  1454. Z        if (!Writable (name)) {
  1455. Z        (VOID) fprintf (_db_fp_, ERR_OPEN, _db_process_, name);
  1456. Z        perror ("");
  1457. Z        (VOID) fflush (_db_fp_);
  1458. Z        (VOID) Delay (stack -> delay);
  1459. Z        } else {
  1460. Z        if (EXISTS (name)) {
  1461. Z            newfile = FALSE;
  1462. Z        } else {
  1463. Z            newfile = TRUE;
  1464. Z        }
  1465. Z        fp = fopen (name, "a");
  1466. Z        if (fp == NULL) {
  1467. Z             (VOID) fprintf (_db_fp_, ERR_OPEN, _db_process_, name);
  1468. Z            perror ("");
  1469. Z            (VOID) fflush (_db_fp_);
  1470. Z            (VOID) Delay (stack -> delay);
  1471. Z        } else {
  1472. Z            _db_fp_ = fp;
  1473. Z            stack -> out_file = fp;
  1474. Z            if (newfile) {
  1475. Z            ChangeOwner (name);
  1476. Z            }
  1477. Z        }
  1478. Z        }
  1479. Z    }
  1480. Z    }
  1481. Z}
  1482. Z
  1483. Z
  1484. Z/*
  1485. Z *  FUNCTION
  1486. Z *
  1487. Z *    OpenProfile    open new output stream for profiler output
  1488. Z *
  1489. Z *  SYNOPSIS
  1490. Z *
  1491. Z *    LOCAL VOID OpenProfile (name)
  1492. Z *    char *name;
  1493. Z *
  1494. Z *  DESCRIPTION
  1495. Z *
  1496. Z *    Given name of a new file, opens the file
  1497. Z *    and sets the profiler output stream to the new file.
  1498. Z *
  1499. Z *    It is currently unclear whether the prefered behavior is
  1500. Z *    to truncate any existing file, or simply append to it.
  1501. Z *    The latter behavior would be desirable for collecting
  1502. Z *    accumulated runtime history over a number of separate
  1503. Z *    runs.  It might take some changes to the analyzer program
  1504. Z *    though, and the notes that Binayak sent with the profiling
  1505. Z *    diffs indicated that append was the normal mode, but this
  1506. Z *    does not appear to agree with the actual code. I haven't
  1507. Z *    investigated at this time [fnf; 24-Jul-87].
  1508. Z */
  1509. Z
  1510. ZLOCAL VOID OpenProfile (name)
  1511. Zchar *name;
  1512. Z{
  1513. Z    REGISTER FILE *fp;
  1514. Z    REGISTER BOOLEAN newfile;
  1515. Z
  1516. Z    if (name != NULL) {
  1517. Z    if (!Writable (name)) {
  1518. Z        (VOID) fprintf (_db_fp_, ERR_OPEN, _db_process_, name);
  1519. Z        perror ("");
  1520. Z        (VOID) fflush (_db_fp_);
  1521. Z        (VOID) Delay (stack -> delay);
  1522. Z    } else {
  1523. Z        if (EXISTS (name)) {
  1524. Z        newfile = FALSE;
  1525. Z        } else {
  1526. Z        newfile = TRUE;
  1527. Z        }
  1528. Z        fp = fopen (name, "w");
  1529. Z        if (fp == NULL) {
  1530. Z        (VOID) fprintf (_db_fp_, ERR_OPEN, _db_process_, name);
  1531. Z        perror ("");
  1532. Z        (VOID) fflush (_db_fp_);
  1533. Z        (VOID) Delay (stack -> delay);
  1534. Z        } else {
  1535. Z        _db_pfp_ = fp;
  1536. Z        stack -> prof_file = fp;
  1537. Z        if (newfile) {
  1538. Z            ChangeOwner (name);
  1539. Z        }
  1540. Z        }
  1541. Z    }
  1542. Z    }
  1543. Z}
  1544. Z
  1545. Z
  1546. Z/*
  1547. Z *  FUNCTION
  1548. Z *
  1549. Z *    CloseFile    close the debug output stream
  1550. Z *
  1551. Z *  SYNOPSIS
  1552. Z *
  1553. Z *    LOCAL VOID CloseFile (fp)
  1554. Z *    FILE *fp;
  1555. Z *
  1556. Z *  DESCRIPTION
  1557. Z *
  1558. Z *    Closes the debug output stream unless it is standard output
  1559. Z *    or standard error.
  1560. Z *
  1561. Z */
  1562. Z
  1563. ZLOCAL VOID CloseFile (fp)
  1564. ZFILE *fp;
  1565. Z{
  1566. Z    if (fp != stderr && fp != stdout) {
  1567. Z    if (fclose (fp) == EOF) {
  1568. Z        (VOID) fprintf (stderr, ERR_CLOSE, _db_process_);
  1569. Z        perror ("");
  1570. Z        (VOID) fflush (stderr);
  1571. Z        (VOID) Delay (stack -> delay);
  1572. Z    }
  1573. Z    }
  1574. Z}
  1575. Z
  1576. Z
  1577. Z/*
  1578. Z *  FUNCTION
  1579. Z *
  1580. Z *    DbugExit    print error message and exit
  1581. Z *
  1582. Z *  SYNOPSIS
  1583. Z *
  1584. Z *    LOCAL VOID DbugExit (why)
  1585. Z *    char *why;
  1586. Z *
  1587. Z *  DESCRIPTION
  1588. Z *
  1589. Z *    Prints error message using current process name, the reason for
  1590. Z *    aborting (typically out of memory), and exits with status 1.
  1591. Z *    This should probably be changed to use a status code
  1592. Z *    defined in the user's debugger include file.
  1593. Z *
  1594. Z */
  1595. Z 
  1596. ZLOCAL VOID DbugExit (why)
  1597. Zchar *why;
  1598. Z{
  1599. Z    (VOID) fprintf (stderr, ERR_ABORT, _db_process_, why);
  1600. Z    (VOID) fflush (stderr);
  1601. Z    (VOID) Delay (stack -> delay);
  1602. Z    exit (1);
  1603. Z}
  1604. Z
  1605. Z
  1606. Z/*
  1607. Z *  FUNCTION
  1608. Z *
  1609. Z *    DbugMalloc    allocate memory for debugger runtime support
  1610. Z *
  1611. Z *  SYNOPSIS
  1612. Z *
  1613. Z *    LOCAL long *DbugMalloc (size)
  1614. Z *    int size;
  1615. Z *
  1616. Z *  DESCRIPTION
  1617. Z *
  1618. Z *    Allocate more memory for debugger runtime support functions.
  1619. Z *    Failure to to allocate the requested number of bytes is
  1620. Z *    immediately fatal to the current process.  This may be
  1621. Z *    rather unfriendly behavior.  It might be better to simply
  1622. Z *    print a warning message, freeze the current debugger state,
  1623. Z *    and continue execution.
  1624. Z *
  1625. Z */
  1626. Z 
  1627. ZLOCAL long *DbugMalloc (size)
  1628. Zint size;
  1629. Z{
  1630. Z    register long *new;
  1631. Z
  1632. Z    new = (long *) malloc ((unsigned int) size);
  1633. Z    if (new == NULL) {
  1634. Z    DbugExit ("out of memory");
  1635. Z    }
  1636. Z    return (new);
  1637. Z}
  1638. Z
  1639. Z
  1640. Z/*
  1641. Z *    This function may be eliminated when strtok is available
  1642. Z *    in the runtime environment (missing from BSD4.1).
  1643. Z */
  1644. Z
  1645. ZLOCAL char *strtok (s1, s2)
  1646. Zchar *s1, *s2;
  1647. Z{
  1648. Z    static char *end = NULL;
  1649. Z    REGISTER char *rtnval;
  1650. Z
  1651. Z    rtnval = NULL;
  1652. Z    if (s2 != NULL) {
  1653. Z    if (s1 != NULL) {
  1654. Z        end = s1;
  1655. Z        rtnval = strtok ((char *) NULL, s2);
  1656. Z    } else if (end != NULL) {
  1657. Z        if (*end != EOS) {
  1658. Z        rtnval = end;
  1659. Z        while (*end != *s2 && *end != EOS) {end++;}
  1660. Z        if (*end != EOS) {
  1661. Z            *end++ = EOS;
  1662. Z        }
  1663. Z        }
  1664. Z    }
  1665. Z    }
  1666. Z    return (rtnval);
  1667. Z}
  1668. Z
  1669. Z
  1670. Z/*
  1671. Z *  FUNCTION
  1672. Z *
  1673. Z *    BaseName    strip leading pathname components from name
  1674. Z *
  1675. Z *  SYNOPSIS
  1676. Z *
  1677. Z *    LOCAL char *BaseName (pathname)
  1678. Z *    char *pathname;
  1679. Z *
  1680. Z *  DESCRIPTION
  1681. Z *
  1682. Z *    Given pointer to a complete pathname, locates the base file
  1683. Z *    name at the end of the pathname and returns a pointer to
  1684. Z *    it.
  1685. Z *
  1686. Z */
  1687. Z
  1688. ZLOCAL char *BaseName (pathname)
  1689. Zchar *pathname;
  1690. Z{
  1691. Z    register char *base;
  1692. Z
  1693. Z    base = strrchr (pathname, '/');
  1694. Z    if (base++ == NULL) {
  1695. Z    base = pathname;
  1696. Z    }
  1697. Z    return (base);
  1698. Z}
  1699. Z
  1700. Z
  1701. Z/*
  1702. Z *  FUNCTION
  1703. Z *
  1704. Z *    Writable    test to see if a pathname is writable/creatable
  1705. Z *
  1706. Z *  SYNOPSIS
  1707. Z *
  1708. Z *    LOCAL BOOLEAN Writable (pathname)
  1709. Z *    char *pathname;
  1710. Z *
  1711. Z *  DESCRIPTION
  1712. Z *
  1713. Z *    Because the debugger might be linked in with a program that
  1714. Z *    runs with the set-uid-bit (suid) set, we have to be careful
  1715. Z *    about opening a user named file for debug output.  This consists
  1716. Z *    of checking the file for write access with the real user id,
  1717. Z *    or checking the directory where the file will be created.
  1718. Z *
  1719. Z *    Returns TRUE if the user would normally be allowed write or
  1720. Z *    create access to the named file.  Returns FALSE otherwise.
  1721. Z *
  1722. Z */
  1723. Z
  1724. ZLOCAL BOOLEAN Writable (pathname)
  1725. Zchar *pathname;
  1726. Z{
  1727. Z    REGISTER BOOLEAN granted;
  1728. Z#if (unix || xenix)
  1729. Z    REGISTER char *lastslash;
  1730. Z#endif
  1731. Z
  1732. Z#if (!unix && !xenix)
  1733. Z    granted = TRUE;
  1734. Z#else
  1735. Z    granted = FALSE;
  1736. Z    if (EXISTS (pathname)) {
  1737. Z    if (WRITABLE (pathname)) {
  1738. Z        granted = TRUE;
  1739. Z    }
  1740. Z    } else {
  1741. Z    lastslash = strrchr (pathname, '/');
  1742. Z    if (lastslash != NULL) {
  1743. Z        *lastslash = EOS;
  1744. Z    } else {
  1745. Z        pathname = ".";
  1746. Z    }
  1747. Z    if (WRITABLE (pathname)) {
  1748. Z        granted = TRUE;
  1749. Z    }
  1750. Z    if (lastslash != NULL) {
  1751. Z        *lastslash = '/';
  1752. Z    }
  1753. Z    }
  1754. Z#endif
  1755. Z    return (granted);
  1756. Z}
  1757. Z
  1758. Z
  1759. Z/*
  1760. Z *    This function may be eliminated when strrchr is available
  1761. Z *    in the runtime environment (missing from BSD4.1).
  1762. Z *    Alternately, you can use rindex() on BSD systems.
  1763. Z */
  1764. Z
  1765. ZLOCAL char *strrchr (s, c)
  1766. Zchar *s;
  1767. Zchar c;
  1768. Z{
  1769. Z    REGISTER char *scan;
  1770. Z
  1771. Z    for (scan = s; *scan != EOS; scan++) {;}
  1772. Z    while (scan > s && *--scan != c) {;}
  1773. Z    if (*scan != c) {
  1774. Z    scan = NULL;
  1775. Z    }
  1776. Z    return (scan);
  1777. Z}
  1778. Z
  1779. Z
  1780. Z/*
  1781. Z *  FUNCTION
  1782. Z *
  1783. Z *    ChangeOwner    change owner to real user for suid programs
  1784. Z *
  1785. Z *  SYNOPSIS
  1786. Z *
  1787. Z *    LOCAL VOID ChangeOwner (pathname)
  1788. Z *
  1789. Z *  DESCRIPTION
  1790. Z *
  1791. Z *    For unix systems, change the owner of the newly created debug
  1792. Z *    file to the real owner.  This is strictly for the benefit of
  1793. Z *    programs that are running with the set-user-id bit set.
  1794. Z *
  1795. Z *    Note that at this point, the fact that pathname represents
  1796. Z *    a newly created file has already been established.  If the
  1797. Z *    program that the debugger is linked to is not running with
  1798. Z *    the suid bit set, then this operation is redundant (but
  1799. Z *    harmless).
  1800. Z *
  1801. Z */
  1802. Z
  1803. ZLOCAL VOID ChangeOwner (pathname)
  1804. Zchar *pathname;
  1805. Z{
  1806. Z#if (unix || xenix)
  1807. Z    if (chown (pathname, getuid (), getgid ()) == -1) {
  1808. Z    (VOID) fprintf (stderr, ERR_CHOWN, _db_process_, pathname);
  1809. Z    perror ("");
  1810. Z    (VOID) fflush (stderr);
  1811. Z    (VOID) Delay (stack -> delay);
  1812. Z    }
  1813. Z#endif
  1814. Z}
  1815. Z
  1816. Z
  1817. Z/*
  1818. Z *  FUNCTION
  1819. Z *
  1820. Z *    _db_setjmp_    save debugger environment
  1821. Z *
  1822. Z *  SYNOPSIS
  1823. Z *
  1824. Z *    VOID _db_setjmp_ ()
  1825. Z *
  1826. Z *  DESCRIPTION
  1827. Z *
  1828. Z *    Invoked as part of the user's DBUG_SETJMP macro to save
  1829. Z *    the debugger environment in parallel with saving the user's
  1830. Z *    environment.
  1831. Z *
  1832. Z */
  1833. Z
  1834. ZVOID _db_setjmp_ ()
  1835. Z{
  1836. Z   jmplevel = stack -> level;
  1837. Z   jmpfunc = func;
  1838. Z   jmpfile = file;
  1839. Z}
  1840. Z
  1841. Z
  1842. Z/*
  1843. Z *  FUNCTION
  1844. Z *
  1845. Z *    _db_longjmp_    restore previously saved debugger environment
  1846. Z *
  1847. Z *  SYNOPSIS
  1848. Z *
  1849. Z *    VOID _db_longjmp_ ()
  1850. Z *
  1851. Z *  DESCRIPTION
  1852. Z *
  1853. Z *    Invoked as part of the user's DBUG_LONGJMP macro to restore
  1854. Z *    the debugger environment in parallel with restoring the user's
  1855. Z *    previously saved environment.
  1856. Z *
  1857. Z */
  1858. Z
  1859. ZVOID _db_longjmp_ ()
  1860. Z{
  1861. Z    stack -> level = jmplevel;
  1862. Z    if (jmpfunc) {
  1863. Z    func = jmpfunc;
  1864. Z    }
  1865. Z    if (jmpfile) {
  1866. Z    file = jmpfile;
  1867. Z    }
  1868. Z}
  1869. Z
  1870. Z
  1871. Z/*
  1872. Z *  FUNCTION
  1873. Z *
  1874. Z *    DelayArg   convert D flag argument to appropriate value
  1875. Z *
  1876. Z *  SYNOPSIS
  1877. Z *
  1878. Z *    LOCAL int DelayArg (value)
  1879. Z *    int value;
  1880. Z *
  1881. Z *  DESCRIPTION
  1882. Z *
  1883. Z *    Converts delay argument, given in tenths of a second, to the
  1884. Z *    appropriate numerical argument used by the system to delay
  1885. Z *    that that many tenths of a second.  For example, on the
  1886. Z *    amiga, there is a system call "Delay()" which takes an
  1887. Z *    argument in ticks (50 per second).  On unix, the sleep
  1888. Z *    command takes seconds.  Thus a value of "10", for one
  1889. Z *    second of delay, gets converted to 50 on the amiga, and 1
  1890. Z *    on unix.  Other systems will need to use a timing loop.
  1891. Z *
  1892. Z */
  1893. Z
  1894. ZLOCAL int DelayArg (value)
  1895. Zint value;
  1896. Z{
  1897. Z    unsigned int delayarg = 0;
  1898. Z    
  1899. Z#if (unix || xenix)
  1900. Z    delayarg = value / 10;        /* Delay is in seconds for sleep () */
  1901. Z#endif
  1902. Z#if amiga
  1903. Z    delayarg = (HZ * value) / 10;    /* Delay in ticks for Delay () */
  1904. Z#endif
  1905. Z    return (delayarg);
  1906. Z}
  1907. Z
  1908. Z
  1909. Z/*
  1910. Z *    A dummy delay stub for systems that do not support delays.
  1911. Z *    With a little work, this can be turned into a timing loop.
  1912. Z */
  1913. Z
  1914. Z#if (!unix && !xenix && !amiga)
  1915. ZDelay ()
  1916. Z{
  1917. Z}
  1918. Z#endif
  1919. Z
  1920. Z
  1921. Z/*
  1922. Z *  FUNCTION
  1923. Z *
  1924. Z *    perror    perror simulation for systems that don't have it
  1925. Z *
  1926. Z *  SYNOPSIS
  1927. Z *
  1928. Z *    LOCAL VOID perror (s)
  1929. Z *    char *s;
  1930. Z *
  1931. Z *  DESCRIPTION
  1932. Z *
  1933. Z *    Perror produces a message on the standard error stream which
  1934. Z *    provides more information about the library or system error
  1935. Z *    just encountered.  The argument string s is printed, followed
  1936. Z *    by a ':', a blank, and then a message and a newline.
  1937. Z *
  1938. Z *    An undocumented feature of the unix perror is that if the string
  1939. Z *    's' is a null string (NOT a NULL pointer!), then the ':' and
  1940. Z *    blank are not printed.
  1941. Z *
  1942. Z *    This version just complains about an "unknown system error".
  1943. Z *
  1944. Z */
  1945. Z
  1946. Z#if !unix && !xenix && !(amiga && LATTICE)
  1947. Z
  1948. ZLOCAL VOID perror (s)
  1949. Zchar *s;
  1950. Z{
  1951. Z    if (s && *s != EOS) {
  1952. Z    (VOID) fprintf (stderr, "%s: ", s);
  1953. Z    }
  1954. Z    (VOID) fprintf (stderr, "<unknown system error>\n");
  1955. Z}
  1956. Z
  1957. Z#endif    /* !unix && !xenix && !(amiga && LATTICE) */
  1958. Z
  1959. Z/*
  1960. Z * Here we need the definitions of the clock routine.  Add your
  1961. Z * own for whatever system that you have.
  1962. Z */
  1963. Z
  1964. Z#if (unix || xenix)
  1965. Z
  1966. Z# include <sys/param.h>
  1967. Z# if BSD4_3 || sun
  1968. Z
  1969. Z/*
  1970. Z * Definition of the Clock() routine for 4.3 BSD.
  1971. Z */
  1972. Z
  1973. Z#include <sys/time.h>
  1974. Z#include <sys/resource.h>
  1975. Z
  1976. Z/*
  1977. Z * Returns the user time in milliseconds used by this process so
  1978. Z * far.
  1979. Z */
  1980. Z
  1981. ZLOCAL unsigned long Clock ()
  1982. Z{
  1983. Z    struct rusage ru;
  1984. Z
  1985. Z    (VOID) getrusage (RUSAGE_SELF, &ru);
  1986. Z    return ((ru.ru_utime.tv_sec * 1000) + (ru.ru_utime.tv_usec / 1000));
  1987. Z}
  1988. Z
  1989. Z#else
  1990. Z
  1991. ZLOCAL unsigned long Clock ()
  1992. Z{
  1993. Z    return (0);
  1994. Z}
  1995. Z
  1996. Z# endif
  1997. Z
  1998. Z#else
  1999. Z
  2000. Z#if amiga
  2001. Z
  2002. Zstruct DateStamp {        /* Yes, this is a hack, but doing it right */
  2003. Z    long ds_Days;        /* is incredibly ugly without splitting this */
  2004. Z    long ds_Minute;        /* off into a separate file */
  2005. Z    long ds_Tick;
  2006. Z};
  2007. Z
  2008. Zstatic int first_clock = TRUE;
  2009. Zstatic struct DateStamp begin;
  2010. Zstatic struct DateStamp elapsed;
  2011. Z
  2012. ZLOCAL unsigned long Clock ()
  2013. Z{
  2014. Z    register struct DateStamp *now;
  2015. Z    register unsigned long millisec = 0;
  2016. Z    extern VOID *AllocMem ();
  2017. Z
  2018. Z    now = (struct DateStamp *) AllocMem ((long) sizeof (struct DateStamp), 0L);
  2019. Z    if (now != NULL) {
  2020. Z    if (first_clock == TRUE) {
  2021. Z        first_clock = FALSE;
  2022. Z        (VOID) DateStamp (now);
  2023. Z        begin = *now;
  2024. Z    }
  2025. Z    (VOID) DateStamp (now);
  2026. Z    millisec = 24 * 3600 * (1000 / HZ) * (now -> ds_Days - begin.ds_Days);
  2027. Z    millisec += 60 * (1000 / HZ) * (now -> ds_Minute - begin.ds_Minute);
  2028. Z    millisec += (1000 / HZ) * (now -> ds_Tick - begin.ds_Tick);
  2029. Z    (VOID) FreeMem (now, (long) sizeof (struct DateStamp));
  2030. Z    }
  2031. Z    return (millisec);
  2032. Z}
  2033. Z
  2034. Z#endif    /* amiga */
  2035. Z#endif    /* unix */
  2036. STUNKYFLUFF
  2037. set `sum dbug.c`
  2038. if test 40274 != $1
  2039. then
  2040. echo dbug.c: Checksum error. Is: $1, should be: 40274.
  2041. fi
  2042. #
  2043. #
  2044. echo Extracting Makefile:
  2045. sed 's/^Z//' >Makefile <<\STUNKYFLUFF
  2046. Z#
  2047. Z#  FILE
  2048. Z#
  2049. Z#    Makefile    Makefile for dbug package
  2050. Z#
  2051. Z#  SCCS ID
  2052. Z#
  2053. Z#    @(#)Makefile    1.11 3/12/88
  2054. Z#
  2055. Z#  DESCRIPTION
  2056. Z#
  2057. Z#    Makefile for the dbug package (under UNIX system V or 4.2BSD).
  2058. Z#
  2059. Z#    Interesting things to make are:
  2060. Z#
  2061. Z#    lib    =>    Makes the runtime support library in the
  2062. Z#            current directory.
  2063. Z#
  2064. Z#    lintlib    =>    Makes the lint library in the current directory.
  2065. Z#
  2066. Z#    install    =>    Install pieces from current directory to
  2067. Z#            where they belong.
  2068. Z#
  2069. Z#    doc    =>    Makes the documentation in the current
  2070. Z#            directory.
  2071. Z#
  2072. Z#    clean    =>    Remove objects, temporary files, etc from
  2073. Z#            current directory.
  2074. Z#
  2075. Z#    superclean =>    Remove everything except sccs source files.
  2076. Z#            Uses interactive remove for verification.
  2077. Z
  2078. Z# Define NO_VARARGS if you have no <varargs.h> to include.
  2079. Z#VARARGS =    -DNO_VARARGS
  2080. Z
  2081. ZSH =        /bin/sh
  2082. ZAR =        ar
  2083. ZRM =        rm
  2084. ZCFLAGS =    -O $(VARARGS)
  2085. ZGFLAGS =    -s
  2086. ZINSTALL =    $(SH) install.sh
  2087. ZCHMOD =        chmod
  2088. ZMAKE =        make
  2089. ZINC =        /usr/include/local
  2090. ZLIB =        /usr/lib
  2091. ZRANLIB =    $(SH) ranlib.sh
  2092. ZMODE =        664
  2093. Z
  2094. Z# The following is provided for example only, it is set by "doinstall.sh".
  2095. ZLLIB =        /usr/lib
  2096. Z
  2097. Z.SUFFIXES:    .r .r~ .c .c~
  2098. Z
  2099. Z.c~.c:
  2100. Z        $(GET) $(GFLAGS) -p $< >$*.c
  2101. Z
  2102. Z.r~.r:
  2103. Z        $(GET) $(GFLAGS) -p $< >$*.r
  2104. Z
  2105. Z.c~.r:
  2106. Z        $(GET) $(GFLAGS) -p $< >$*.c
  2107. Z        sed "s/\\\/\\\e/" <$*.c >$*.r
  2108. Z        $(RM) -f $*.c
  2109. Z
  2110. Z.c.r:
  2111. Z        sed "s/\\\/\\\e/" <$< >$*.r
  2112. Z
  2113. ZEXAMPLES =    example1.r example2.r example3.r
  2114. ZOUTPUTS =    output1.r output2.r output3.r output4.r output5.r
  2115. Z
  2116. ZNROFF_INC =    main.r factorial.r $(OUTPUTS) $(EXAMPLES)
  2117. Z
  2118. Z
  2119. Z#
  2120. Z#    The default thing to do is remake the local runtime support
  2121. Z#    library, local lint library, and local documentation as
  2122. Z#    necessary.
  2123. Z#
  2124. Z
  2125. Zall :        lib lintlib analyze doc
  2126. Z
  2127. Zlib :        libdbug.a
  2128. Z
  2129. Zlintlib :    llib-ldbug.ln
  2130. Z
  2131. Zdoc :        factorial user.t
  2132. Z
  2133. Z#
  2134. Z#    Make the local runtime support library "libdbug.a" from
  2135. Z#    sources.
  2136. Z#
  2137. Z
  2138. Zlibdbug.a :    dbug.o
  2139. Z        rm -f $@
  2140. Z        $(AR) cr $@ $?
  2141. Z        $(RANLIB) $@
  2142. Z
  2143. Z#
  2144. Z#    Clean up the local directory.
  2145. Z#
  2146. Z
  2147. Zclean :
  2148. Z        $(RM) -f *.o *.ln *.a *.BAK nohup.out factorial $(NROFF_INC)
  2149. Z
  2150. Zsuperclean :
  2151. Z        $(RM) -i ?[!.]*
  2152. Z
  2153. Z#
  2154. Z#    Install the new header and library files.  Since things go in
  2155. Z#    different places depending upon the system (lint libraries
  2156. Z#    go in /usr/lib under SV and /usr/lib/lint under BSD for example),
  2157. Z#    the shell script "doinstall.sh" figures out the environment and
  2158. Z#    does a recursive make with the appropriate pathnames set.
  2159. Z#
  2160. Z
  2161. Zinstall :        
  2162. Z            $(SH) doinstall.sh $(MAKE) sysinstall
  2163. Z
  2164. Zsysinstall:        $(INC) $(INC)/dbug.h $(LIB)/libdbug.a \
  2165. Z            $(LLIB)/llib-ldbug.ln $(LLIB)/llib-ldbug
  2166. Z
  2167. Z$(INC) :
  2168. Z            -if test -d $@ ;then true ;else mkdir $@ ;fi
  2169. Z
  2170. Z$(INC)/dbug.h :        dbug.h
  2171. Z            $(INSTALL) $? $@
  2172. Z            $(CHMOD) $(MODE) $@
  2173. Z
  2174. Z$(LIB)/libdbug.a :    libdbug.a
  2175. Z            $(INSTALL) $? $@
  2176. Z            $(CHMOD) $(MODE) $@
  2177. Z
  2178. Z$(LLIB)/llib-ldbug.ln :    llib-ldbug.ln
  2179. Z            $(INSTALL) $? $@
  2180. Z            $(CHMOD) $(MODE) $@
  2181. Z
  2182. Z$(LLIB)/llib-ldbug :    llib-ldbug
  2183. Z            $(INSTALL) $? $@
  2184. Z            $(CHMOD) $(MODE) $@
  2185. Z
  2186. Z#
  2187. Z#    Make the local lint library.
  2188. Z#
  2189. Z
  2190. Zllib-ldbug.ln :     llib-ldbug
  2191. Z            $(SH) mklintlib.sh $? $@
  2192. Z
  2193. Z#
  2194. Z#    Make the test/example program "factorial".
  2195. Z#
  2196. Z#    Note that the objects depend on the LOCAL dbug.h file and
  2197. Z#    the compilations are set up to find dbug.h in the current
  2198. Z#    directory even though the sources have "#include <dbug.h>".
  2199. Z#    This allows the examples to look like the code a user would
  2200. Z#    write but still be used as test cases for new versions
  2201. Z#    of dbug.
  2202. Z
  2203. Zfactorial :    main.o factorial.o libdbug.a
  2204. Z        $(CC) -o $@ main.o factorial.o libdbug.a
  2205. Z
  2206. Zmain.o :    main.c dbug.h
  2207. Z        $(CC) $(CFLAGS) -c -I. main.c
  2208. Z
  2209. Zfactorial.o :    factorial.c dbug.h
  2210. Z        $(CC) $(CFLAGS) -c -I. factorial.c
  2211. Z
  2212. Z
  2213. Z#
  2214. Z#    Make the analyze program for runtime profiling support.
  2215. Z#
  2216. Z
  2217. Zanalyze :    analyze.o libdbug.a
  2218. Z        $(CC) -o $@ analyze.o libdbug.a
  2219. Z
  2220. Zanalyze.o :    analyze.c useful.h dbug.h
  2221. Z        $(CC) $(CFLAGS) -c -I. analyze.c
  2222. Z
  2223. Z#
  2224. Z#    Rebuild the documentation
  2225. Z#
  2226. Z
  2227. Zuser.t :    user.r $(NROFF_INC)
  2228. Z        nroff -cm user.r >$@
  2229. Z
  2230. Z#
  2231. Z#    Run the factorial program to produce the sample outputs.
  2232. Z#
  2233. Z
  2234. Zoutput1.r:    factorial
  2235. Z        ./factorial 1 2 3 4 5 >$@
  2236. Z
  2237. Zoutput2.r:    factorial
  2238. Z        ./factorial -#t:o 2 3 >$@
  2239. Z
  2240. Zoutput3.r:    factorial
  2241. Z        ./factorial -#d:t:o 3 >$@
  2242. Z
  2243. Zoutput4.r:    factorial
  2244. Z        ./factorial -#d,result:o 4 >$@
  2245. Z
  2246. Zoutput5.r:    factorial
  2247. Z        ./factorial -#d:f,factorial:F:L:o 3 >$@
  2248. Z
  2249. Z#
  2250. Z#    All files included by user.r depend on user.r, thus
  2251. Z#    forcing them to be remade if user.r changes.
  2252. Z#
  2253. Z
  2254. Z$(NROFF_INC) :    user.r
  2255. Z
  2256. STUNKYFLUFF
  2257. set `sum Makefile`
  2258. if test 62626 != $1
  2259. then
  2260. echo Makefile: Checksum error. Is: $1, should be: 62626.
  2261. fi
  2262. #
  2263. #
  2264. echo Extracting README.prof:
  2265. sed 's/^Z//' >README.prof <<\STUNKYFLUFF
  2266. ZHi,
  2267. Z
  2268. ZI'm sending you the modifications I made to your Dbug routines to
  2269. Zallow profiling in a (relatively) machine independent fashion.
  2270. ZI use your Dbug routines fairly extensively.  Unfortunately, it's
  2271. Za royal pain to have to keep profiled versions of various libraries
  2272. Zaround.  The modifications allow profiling without the need for this.
  2273. Z
  2274. ZHow it works.
  2275. Z------------
  2276. Z
  2277. ZBasically, I just added code in the dbug routines to write out a file
  2278. Zcalled dbugmon.out (by default).  This is an ascii file containing lines
  2279. Zof the form:
  2280. Z
  2281. Z<function-name> E <time-entered>
  2282. Z<function-name> X <time-exited>
  2283. Z
  2284. ZA second program (analyze) reads this file, and produces a report on
  2285. Zstandard output.
  2286. Z
  2287. ZProfiling is enabled through the `g' flag.  It can take a list of
  2288. Zprocedure names for which profiling is enabled.  By default, it
  2289. Zprofiles all procedures.
  2290. Z
  2291. ZThe code in ``dbug.c'' opens the profile file for appending.  This
  2292. Zis in order that one can run a program several times, and get the
  2293. Zsum total of all the times, etc.
  2294. Z
  2295. ZThe only system dependent part that I'm aware of is the routine
  2296. ZClock() at the end of dbug.c.  This returns the elapsed user time
  2297. Zin milliseconds.  The version which I have is for 4.3 BSD.  As I
  2298. Zdon't have access to other systems, I'm not certain how this would
  2299. Zchange.
  2300. Z
  2301. ZAn example of the report generated follows:
  2302. Z
  2303. Z        Profile of Execution
  2304. Z        Execution times are in milliseconds
  2305. Z
  2306. Z            Calls                Time
  2307. Z            -----                ----
  2308. Z        Times    Percentage    Time Spent    Percentage
  2309. ZFunction    Called    of total    in Function    of total    Importance
  2310. Z========    ======    ==========    ===========    ==========  ==========
  2311. Zfactorial               5         83.33             30        100.00        8333
  2312. Zmain                    1         16.67              0          0.00           0
  2313. Z========    ======    ==========    ===========    ==========
  2314. ZTotals                  6        100.00             30        100.00
  2315. Z
  2316. Z
  2317. ZAs you can see, it's quite self-evident.  The ``Importance'' column is a
  2318. Zmetric obtained by multiplying the percentage of the calls and the percentage
  2319. Zof the time.  Functions with higher 'importance' benefit the most from
  2320. Zbeing sped up.
  2321. Z
  2322. ZI'm really not certain how to add support for setjmp/longjmp, or for
  2323. Zchild processes, so I've ignored that for the time being.  In most of
  2324. Zthe code that I write, it isn't necessary.  If you have any good ideas,
  2325. Zfeel free to add them.
  2326. Z
  2327. ZThis has been very useful to me.  If you can use it as part of your
  2328. Zdbug distribution, please feel free to do so.
  2329. Z
  2330. ZRegards,
  2331. Z
  2332. Z                Binayak Banerjee
  2333. Z        {allegra | astrovax | bpa | burdvax}!sjuvax!bbanerje
  2334. Z            bbanerje%sjuvax.sju.edu@relay.cs.net
  2335. Z                July 9, 1987
  2336. STUNKYFLUFF
  2337. set `sum README.prof`
  2338. if test 15724 != $1
  2339. then
  2340. echo README.prof: Checksum error. Is: $1, should be: 15724.
  2341. fi
  2342. echo ALL DONE BUNKY!
  2343. exit 0
  2344.  
  2345.  
  2346.