home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / unix / volume3 / ctags < prev    next >
Encoding:
Internet Message Format  |  1986-11-30  |  23.8 KB
  1. From: decvax!ucbvax!ucsf-cgl.ARPA!arnold (Ken Arnold)
  2. Subject: ctags source
  3. Newsgroups: mod.sources
  4. Approved: jpn@panda.UUCP
  5.  
  6. Mod.sources:  Volume 3, Issue 53
  7. Submitted by: ucbvax!ucsf-cgl.ARPA!arnold (Ken Arnold)
  8.  
  9.  
  10. #!/bin/sh
  11. #
  12. # I have received enough requests for the current source to ctags to
  13. # post it.  Here is the latest version (what will go out with 4.3,
  14. # modulo any bugs fixed during the beta period).  It is the 4.2 ctags
  15. # with recognition of yacc and lex tags added.  Files ending in .y are
  16. # presumed to be yacc files, .l files are either lisp or lex files,
  17. # depending upon the first non-blank character (yeah, it's a hack, but
  18. # it works).  Man page is included.  Note that I wrote the original
  19. # ctags (recognized only C), and added the YACC and lex after others
  20. # wrote the recognizers for FORTRAN, PASCAL, and lisp, so this code is
  21. # rather a mix of styles, for which I take no responsibility.  So, here
  22. # come those famous words:
  23. #
  24. # This is a shell archive, meaning:
  25. # 1. Remove everything above the #!/bin/sh line.
  26. # 2. Save the resulting text in a file.
  27. # 3. Execute the file with /bin/sh (not csh) to create the files:
  28. #    ctags.1
  29. #    ctags.c
  30. # This archive created: Mon Nov 25 12:53:49 1985
  31. export PATH; PATH=/bin:$PATH
  32. if test -f 'ctags.1'
  33. then
  34.     echo shar: over-writing existing file "'ctags.1'"
  35. fi
  36. cat << \SHAR_EOF > 'ctags.1'
  37. .TH CTAGS 1 "25 August 1982"
  38. .UC 4
  39. .SH NAME
  40. ctags \- create a tags file
  41. .SH SYNOPSIS
  42. .B ctags
  43. [ 
  44. .B \-BFatuwvx
  45. ]
  46. name ...
  47. .SH DESCRIPTION
  48. .I Ctags
  49. makes a tags file for
  50. .IR ex (1)
  51. from the specified C, Pascal, Fortran, YACC, lex, and lisp sources.
  52. A tags file gives the locations of specified objects (in this case
  53. functions and typedefs) in a group of files.  Each line of the tags
  54. file contains the object name, the file in which it is defined, and
  55. an address specification for the object definition. Functions are
  56. searched with a pattern, typedefs with a line number. Specifiers are
  57. given in separate fields on the line, separated by blanks or tabs.
  58. Using the
  59. .I tags
  60. file,
  61. .I ex
  62. can quickly find these objects definitions.
  63. .PP
  64. If the
  65. .B \-x
  66. flag is given, 
  67. .I ctags
  68. produces a list of object names, the line number and file
  69. name on which each is defined, as well as the text of that line
  70. and prints this on the standard output.  This is a simple index
  71. which can be printed out as an off-line readable function index.
  72. .PP
  73. If the
  74. .B \-v
  75. flag is given,
  76. an index of the form expected by
  77. .IR vgrind (1)
  78. is produced on the standard output.
  79. This listing contains the function name,
  80. file name, and page number
  81. (assuming 64 line pages).
  82. Since the output will be sorted into lexicographic order,
  83. it may be desired to run the output through
  84. .BR "sort \-f" .
  85. Sample use:
  86. .nf
  87.     ctags \-v files | sort \-f > index
  88.     vgrind \-x index
  89. .fi
  90. .PP
  91. Files whose names end in 
  92. .B \.c
  93. or
  94. .B \.h
  95. are assumed to be C source files and are searched for C routine and
  96. macro definitions.
  97. Files whose names end in
  98. .B \.y
  99. are assumed to be YACC source files.
  100. Files whose names end in
  101. .B \.l
  102. are assumed to be either lisp files
  103. if their first non-blank character is `;', `(', or `[',
  104. or lex files otherwise.
  105. Other files are first examined to see if they contain any Pascal or
  106. Fortran routine definitions; if not, they are processed again
  107. looking for C definitions.
  108. .PP
  109. Other options are:
  110. .TP 5
  111. .B \-F
  112. use forward searching patterns (/.../) (default).
  113. .TP 5
  114. .B \-B
  115. use backward searching patterns (?...?).
  116. .TP 5
  117. .B \-a
  118. append to tags file.
  119. .TP 5
  120. .B \-t
  121. create tags for typedefs.
  122. .TP 5
  123. .B \-w
  124. suppressing warning diagnostics.
  125. .TP 5
  126. .B \-u
  127. causing the specified files to be
  128. .I updated
  129. in tags, that is, all references to them are deleted,
  130. and the new values are appended to the file.
  131. (Beware: this option is implemented in a way which is rather slow;
  132. it is usually faster to simply rebuild the
  133. .I tags
  134. file.)
  135. .PP
  136. The tag
  137. .I main
  138. is treated specially in C programs.
  139. The tag formed is created by prepending
  140. .I M
  141. to the name of the file, with a trailing .c removed, if
  142. any, and leading pathname components also removed.
  143. This makes use of
  144. .I ctags
  145. practical in directories with more than one program.
  146. .SH FILES
  147. .DT
  148. tags        output tags file
  149. .SH SEE ALSO
  150. ex(1), vi(1)
  151. .SH AUTHOR
  152. Ken Arnold; FORTRAN added by Jim Kleckner; Bill Joy
  153. added Pascal and
  154. .B \-x,
  155. replacing
  156. .I cxref;
  157. C typedefs added by Ed Pelegri-Llopart.
  158. .SH BUGS
  159. Recognition of \fBfunctions\fR, \fBsubroutines\fR and \fBprocedures\fR
  160. for FORTRAN and Pascal is done is a very simpleminded way.
  161. No attempt is made to deal with block structure; if you have two
  162. Pascal procedures in different blocks with the same name you lose.
  163. .PP
  164. The method of deciding whether to look for C or Pascal and FORTRAN
  165. functions is a hack.
  166. .PP
  167. Does not know about #ifdefs.
  168. .PP
  169. Should know about Pascal types.
  170. Relies on the input being well formed to detect typedefs.
  171. Use of -tx shows only the last line of typedefs.
  172. SHAR_EOF
  173. if test -f 'ctags.c'
  174. then
  175.     echo shar: over-writing existing file "'ctags.c'"
  176. fi
  177. cat << \SHAR_EOF > 'ctags.c'
  178. /* $Header */
  179.  
  180. static char *sccsid = "@(#)ctags.c    4.7 (Berkeley) 8/18/83";
  181.  
  182. #include <stdio.h>
  183. #include <ctype.h>
  184.  
  185. /*
  186.  * ctags: create a tags file
  187.  */
  188.  
  189. #define    reg    register
  190. #define    bool    char
  191.  
  192. #define    TRUE    (1)
  193. #define    FALSE    (0)
  194.  
  195. #define    iswhite(arg)    (_wht[arg])    /* T if char is white        */
  196. #define    begtoken(arg)    (_btk[arg])    /* T if char can start token    */
  197. #define    intoken(arg)    (_itk[arg])    /* T if char can be in token    */
  198. #define    endtoken(arg)    (_etk[arg])    /* T if char ends tokens    */
  199. #define    isgood(arg)    (_gd[arg])    /* T if char can be after ')'    */
  200.  
  201. #define    max(I1,I2)    (I1 > I2 ? I1 : I2)
  202.  
  203. struct    nd_st {            /* sorting structure            */
  204.     char    *entry;            /* function or type name    */
  205.     char    *file;            /* file name            */
  206.     bool    f;            /* use pattern or line no    */
  207.     int    lno;            /* for -x option        */
  208.     char    *pat;            /* search pattern        */
  209.     bool    been_warned;        /* set if noticed dup        */
  210.     struct    nd_st    *left,*right;    /* left and right sons        */
  211. };
  212.  
  213. long    ftell();
  214. typedef    struct    nd_st    NODE;
  215.  
  216. bool    number,                /* T if on line starting with #    */
  217.     term    = FALSE,        /* T if print on terminal    */
  218.     makefile= TRUE,            /* T if to creat "tags" file    */
  219.     gotone,                /* found a func already on line    */
  220.                     /* boolean "func" (see init)    */
  221.     _wht[0177],_etk[0177],_itk[0177],_btk[0177],_gd[0177];
  222.  
  223.     /* typedefs are recognized using a simple finite automata,
  224.      * tydef is its state variable.
  225.      */
  226. typedef enum {none, begin, middle, end } TYST;
  227.  
  228. TYST tydef = none;
  229.  
  230. char    searchar = '/';            /* use /.../ searches         */
  231.  
  232. int    lineno;                /* line number of current line */
  233. char    line[4*BUFSIZ],        /* current input line            */
  234.     *curfile,        /* current input file name        */
  235.     *outfile= "tags",    /* output file                */
  236.     *white    = " \f\t\n",    /* white chars                */
  237.     *endtk    = " \t\n\"'#()[]{}=-+%*/&|^~!<>;,.:?",
  238.                 /* token ending chars            */
  239.     *begtk    = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz",
  240.                 /* token starting chars            */
  241.     *intk    = "ABCDEFGHIJKLMNOPQRSTUVWXYZ_abcdefghijklmnopqrstuvwxyz0123456789",
  242.                 /* valid in-token chars            */
  243.     *notgd    = ",;";        /* non-valid after-function chars    */
  244.  
  245. int    file_num;        /* current file number            */
  246. int    aflag;            /* -a: append to tags */
  247. int    tflag;            /* -t: create tags for typedefs */
  248. int    uflag;            /* -u: update tags */
  249. int    wflag;            /* -w: suppress warnings */
  250. int    vflag;            /* -v: create vgrind style index output */
  251. int    xflag;            /* -x: create cxref style output */
  252.  
  253. char    lbuf[BUFSIZ];
  254.  
  255. FILE    *inf,            /* ioptr for current input file        */
  256.     *outf;            /* ioptr for tags file            */
  257.  
  258. long    lineftell;        /* ftell after getc( inf ) == '\n'     */
  259.  
  260. NODE    *head;            /* the head of the sorted binary tree    */
  261.  
  262. char    *savestr();
  263. char    *rindex(), *index();
  264. char    *toss_comment();
  265.  
  266. main(ac,av)
  267. int    ac;
  268. char    *av[];
  269. {
  270.     char cmd[100];
  271.     int i;
  272.  
  273.     while (ac > 1 && av[1][0] == '-') {
  274.         for (i=1; av[1][i]; i++) {
  275.             switch(av[1][i]) {
  276.               case 'B':
  277.                 searchar='?';
  278.                 break;
  279.               case 'F':
  280.                 searchar='/';
  281.                 break;
  282.               case 'a':
  283.                 aflag++;
  284.                 break;
  285.               case 't':
  286.                 tflag++;
  287.                 break;
  288.               case 'u':
  289.                 uflag++;
  290.                 break;
  291.               case 'w':
  292.                 wflag++;
  293.                 break;
  294.               case 'v':
  295.                 vflag++;
  296.                 xflag++;
  297.                 break;
  298.               case 'x':
  299.                 xflag++;
  300.                 break;
  301.               default:
  302.                 goto usage;
  303.         }
  304.         }
  305.         ac--; av++;
  306.     }
  307.  
  308.     if (ac <= 1) {
  309. usage:
  310.         printf("Usage: ctags [-BFatuwvx] file ...\n");
  311.         exit(1);
  312.     }
  313.  
  314.     init();            /* set up boolean "functions"        */
  315.     /*
  316.      * loop through files finding functions
  317.      */
  318.     for (file_num = 1; file_num < ac; file_num++)
  319.         find_entries(av[file_num]);
  320.  
  321.     if (xflag) {
  322.         put_entries(head);
  323.         exit(0);
  324.     }
  325.     if (uflag) {
  326.         for (i=1; i<ac; i++) {
  327.             sprintf(cmd,
  328.                 "mv %s OTAGS;fgrep -v '\t%s\t' OTAGS >%s;rm OTAGS",
  329.                 outfile, av[i], outfile);
  330.             system(cmd);
  331.         }
  332.         aflag++;
  333.     }
  334.     outf = fopen(outfile, aflag ? "a" : "w");
  335.     if (outf == NULL) {
  336.         perror(outfile);
  337.         exit(1);
  338.     }
  339.     put_entries(head);
  340.     fclose(outf);
  341.     if (uflag) {
  342.         sprintf(cmd, "sort %s -o %s", outfile, outfile);
  343.         system(cmd);
  344.     }
  345.     exit(0);
  346. }
  347.  
  348. /*
  349.  * This routine sets up the boolean psuedo-functions which work
  350.  * by seting boolean flags dependent upon the corresponding character
  351.  * Every char which is NOT in that string is not a white char.  Therefore,
  352.  * all of the array "_wht" is set to FALSE, and then the elements
  353.  * subscripted by the chars in "white" are set to TRUE.  Thus "_wht"
  354.  * of a char is TRUE if it is the string "white", else FALSE.
  355.  */
  356. init()
  357. {
  358.  
  359.     reg    char    *sp;
  360.     reg    int    i;
  361.  
  362.     for (i = 0; i < 0177; i++) {
  363.         _wht[i] = _etk[i] = _itk[i] = _btk[i] = FALSE;
  364.         _gd[i] = TRUE;
  365.     }
  366.     for (sp = white; *sp; sp++)
  367.         _wht[*sp] = TRUE;
  368.     for (sp = endtk; *sp; sp++)
  369.         _etk[*sp] = TRUE;
  370.     for (sp = intk; *sp; sp++)
  371.         _itk[*sp] = TRUE;
  372.     for (sp = begtk; *sp; sp++)
  373.         _btk[*sp] = TRUE;
  374.     for (sp = notgd; *sp; sp++)
  375.         _gd[*sp] = FALSE;
  376. }
  377.  
  378. /*
  379.  * This routine opens the specified file and calls the function
  380.  * which finds the function and type definitions.
  381.  */
  382. find_entries(file)
  383. char    *file;
  384. {
  385.     char *cp;
  386.  
  387.     if ((inf = fopen(file,"r")) == NULL) {
  388.         perror(file);
  389.         return;
  390.     }
  391.     curfile = savestr(file);
  392.     lineno = 0;
  393.     cp = rindex(file, '.');
  394.     /* .l implies lisp or lex source code */
  395.     if (cp && cp[1] == 'l' && cp[2] == '\0') {
  396.         if (index(";([", first_char()) != NULL) {    /* lisp */
  397.             L_funcs(inf);
  398.             fclose(inf);
  399.             return;
  400.         }
  401.         else {                        /* lex */
  402.             /*
  403.              * throw away all the code before the second "%%"
  404.              */
  405.             toss_yysec();
  406.             getline();
  407.             pfnote("yylex", lineno, TRUE);
  408.             toss_yysec();
  409.             C_entries();
  410.             fclose(inf);
  411.             return;
  412.         }
  413.     }
  414.     /* .y implies a yacc file */
  415.     if (cp && cp[1] == 'y' && cp[2] == '\0') {
  416.         toss_yysec();
  417.         Y_entries();
  418.         C_entries();
  419.         fclose(inf);
  420.         return;
  421.     }
  422.     /* if not a .c or .h file, try fortran */
  423.     if (cp && (cp[1] != 'c' && cp[1] != 'h') && cp[2] == '\0') {
  424.         if (PF_funcs(inf) != 0) {
  425.             fclose(inf);
  426.             return;
  427.         }
  428.         rewind(inf);    /* no fortran tags found, try C */
  429.     }
  430.     C_entries();
  431.     fclose(inf);
  432. }
  433.  
  434. pfnote(name, ln, f)
  435. char    *name;
  436. int    ln;
  437. bool    f;        /* f == TRUE when function */
  438. {
  439.     register char *fp;
  440.     register NODE *np;
  441.     char nbuf[BUFSIZ];
  442.  
  443.     if ((np = (NODE *) malloc(sizeof (NODE))) == NULL) {
  444.         fprintf(stderr, "ctags: too many entries to sort\n");
  445.         put_entries(head);
  446.         free_tree(head);
  447.         head = np = (NODE *) malloc(sizeof (NODE));
  448.     }
  449.     if (xflag == 0 && !strcmp(name, "main")) {
  450.         fp = rindex(curfile, '/');
  451.         if (fp == 0)
  452.             fp = curfile;
  453.         else
  454.             fp++;
  455.         sprintf(nbuf, "M%s", fp);
  456.         fp = rindex(nbuf, '.');
  457.         if (fp && fp[2] == 0)
  458.             *fp = 0;
  459.         name = nbuf;
  460.     }
  461.     np->entry = savestr(name);
  462.     np->file = curfile;
  463.     np->f = f;
  464.     np->lno = ln;
  465.     np->left = np->right = 0;
  466.     if (xflag == 0) {
  467.         lbuf[50] = 0;
  468.         strcat(lbuf, "$");
  469.         lbuf[50] = 0;
  470.     }
  471.     np->pat = savestr(lbuf);
  472.     if (head == NULL)
  473.         head = np;
  474.     else
  475.         add_node(np, head);
  476. }
  477.  
  478. /*
  479.  * This routine finds functions and typedefs in C syntax and adds them
  480.  * to the list.
  481.  */
  482. C_entries()
  483. {
  484.     register int c;
  485.     register char *token, *tp;
  486.     bool incomm, inquote, inchar, midtoken;
  487.     int level;
  488.     char *sp;
  489.     char tok[BUFSIZ];
  490.  
  491.     number = gotone = midtoken = inquote = inchar = incomm = FALSE;
  492.     level = 0;
  493.     sp = tp = token = line;
  494.     lineno++;
  495.     lineftell = ftell(inf);
  496.     for (;;) {
  497.         *sp = c = getc(inf);
  498.         if (feof(inf))
  499.             break;
  500.         if (c == '\n')
  501.             lineno++;
  502.         else if (c == '\\') {
  503.             c = *++sp = getc(inf);
  504.             if (c == '\n')
  505.                 c = ' ';
  506.         }
  507.         else if (incomm) {
  508.             if (c == '*') {
  509.                 while ((*++sp=c=getc(inf)) == '*')
  510.                     continue;
  511.                 if (c == '\n')
  512.                     lineno++;
  513.                 if (c == '/')
  514.                     incomm = FALSE;
  515.             }
  516.         }
  517.         else if (inquote) {
  518.             /*
  519.              * Too dumb to know about \" not being magic, but
  520.              * they usually occur in pairs anyway.
  521.              */
  522.             if (c == '"')
  523.                 inquote = FALSE;
  524.             continue;
  525.         }
  526.         else if (inchar) {
  527.             if (c == '\'')
  528.                 inchar = FALSE;
  529.             continue;
  530.         }
  531.         else switch (c) {
  532.           case '"':
  533.             inquote = TRUE;
  534.             continue;
  535.           case '\'':
  536.             inchar = TRUE;
  537.             continue;
  538.           case '/':
  539.             if ((*++sp=c=getc(inf)) == '*')
  540.                 incomm = TRUE;
  541.             else
  542.                 ungetc(*sp, inf);
  543.             continue;
  544.           case '#':
  545.             if (sp == line)
  546.                 number = TRUE;
  547.             continue;
  548.           case '{':
  549.             if (tydef == begin) {
  550.                 tydef=middle;
  551.             }
  552.             level++;
  553.             continue;
  554.           case '}':
  555.             if (sp == line)
  556.                 level = 0;    /* reset */
  557.             else
  558.                 level--;
  559.             if (!level && tydef==middle) {
  560.                 tydef=end;
  561.             }
  562.             continue;
  563.         }
  564.         if (!level && !inquote && !incomm && gotone == FALSE) {
  565.             if (midtoken) {
  566.                 if (endtoken(c)) {
  567.                     int f;
  568.                     int pfline = lineno;
  569.                     if (start_entry(&sp,token,tp,&f)) {
  570.                         strncpy(tok,token,tp-token+1);
  571.                         tok[tp-token+1] = 0;
  572.                         getline();
  573.                         pfnote(tok, pfline, f);
  574.                         gotone = f;    /* function */
  575.                     }
  576.                     midtoken = FALSE;
  577.                     token = sp;
  578.                 }
  579.                 else if (intoken(c))
  580.                     tp++;
  581.             }
  582.             else if (begtoken(c)) {
  583.                 token = tp = sp;
  584.                 midtoken = TRUE;
  585.             }
  586.         }
  587.         if (c == ';'  &&  tydef==end)    /* clean with typedefs */
  588.             tydef=none;
  589.         sp++;
  590.         if (c == '\n' || sp > &line[sizeof (line) - BUFSIZ]) {
  591.             tp = token = sp = line;
  592.             lineftell = ftell(inf);
  593.             number = gotone = midtoken = inquote = inchar = FALSE;
  594.         }
  595.     }
  596. }
  597.  
  598. /*
  599.  * This routine  checks to see if the current token is
  600.  * at the start of a function, or corresponds to a typedef
  601.  * It updates the input line * so that the '(' will be
  602.  * in it when it returns.
  603.  */
  604. start_entry(lp,token,tp,f)
  605. char    **lp,*token,*tp;
  606. int    *f;
  607. {
  608.     reg    char    c,*sp,*tsp;
  609.     static    bool    found;
  610.     bool    firsttok;        /* T if have seen first token in ()'s */
  611.     int    bad;
  612.  
  613.     *f = 1;            /* a function */
  614.     sp = *lp;
  615.     c = *sp;
  616.     bad = FALSE;
  617.     if (!number) {        /* space is not allowed in macro defs    */
  618.         while (iswhite(c)) {
  619.             *++sp = c = getc(inf);
  620.             if (c == '\n') {
  621.                 lineno++;
  622.                 if (sp > &line[sizeof (line) - BUFSIZ])
  623.                     goto ret;
  624.             }
  625.         }
  626.     /* the following tries to make it so that a #define a b(c)    */
  627.     /* doesn't count as a define of b.                */
  628.     }
  629.     else {
  630.         if (!strncmp(token, "define", 6))
  631.             found = 0;
  632.         else
  633.             found++;
  634.         if (found >= 2) {
  635.             gotone = TRUE;
  636. badone:            bad = TRUE;
  637.             goto ret;
  638.         }
  639.     }
  640.     /* check for the typedef cases        */
  641.     if (tflag && !strncmp(token, "typedef", 7)) {
  642.         tydef=begin;
  643.         goto badone;
  644.     }
  645.     if (tydef==begin && (!strncmp(token, "struct", 6) ||
  646.         !strncmp(token, "union", 5) || !strncmp(token, "enum", 4))) {
  647.         goto badone;
  648.     }
  649.     if (tydef==begin) {
  650.         tydef=end;
  651.         goto badone;
  652.     }
  653.     if (tydef==end) {
  654.         *f = 0;
  655.         goto ret;
  656.     }
  657.     if (c != '(')
  658.         goto badone;
  659.     firsttok = FALSE;
  660.     while ((*++sp=c=getc(inf)) != ')') {
  661.         if (c == '\n') {
  662.             lineno++;
  663.             if (sp > &line[sizeof (line) - BUFSIZ])
  664.                 goto ret;
  665.         }
  666.         /*
  667.          * This line used to confuse ctags:
  668.          *    int    (*oldhup)();
  669.          * This fixes it. A nonwhite char before the first
  670.          * token, other than a / (in case of a comment in there)
  671.          * makes this not a declaration.
  672.          */
  673.         if (begtoken(c) || c=='/')
  674.             firsttok++;
  675.         else if (!iswhite(c) && !firsttok)
  676.             goto badone;
  677.     }
  678.     while (iswhite(*++sp=c=getc(inf)))
  679.         if (c == '\n') {
  680.             lineno++;
  681.             if (sp > &line[sizeof (line) - BUFSIZ])
  682.                 break;
  683.         }
  684. ret:
  685.     *lp = --sp;
  686.     if (c == '\n')
  687.         lineno--;
  688.     ungetc(c,inf);
  689.     return !bad && (!*f || isgood(c));
  690.                     /* hack for typedefs */
  691. }
  692.  
  693. /*
  694.  * Y_entries:
  695.  *    Find the yacc tags and put them in.
  696.  */
  697. Y_entries()
  698. {
  699.     register char    *sp, *orig_sp;
  700.     register int    brace;
  701.     register bool    in_rule, toklen;
  702.     char        tok[BUFSIZ];
  703.  
  704.     brace = 0;
  705.     getline();
  706.     pfnote("yyparse", lineno, TRUE);
  707.     while (fgets(line, sizeof line, inf) != NULL)
  708.         for (sp = line; *sp; sp++)
  709.             switch (*sp) {
  710.               case '\n':
  711.                 lineno++;
  712.                 /* FALLTHROUGH */
  713.               case ' ':
  714.               case '\t':
  715.               case '\f':
  716.               case '\r':
  717.                 break;
  718.               case '"':
  719.                 do {
  720.                     while (*++sp != '"')
  721.                         continue;
  722.                 } while (sp[-1] == '\\');
  723.                 break;
  724.               case '\'':
  725.                 do {
  726.                     while (*++sp != '\'')
  727.                         continue;
  728.                 } while (sp[-1] == '\\');
  729.                 break;
  730.               case '/':
  731.                 if (*++sp == '*')
  732.                     sp = toss_comment(sp);
  733.                 else
  734.                     --sp;
  735.                 break;
  736.               case '{':
  737.                 brace++;
  738.                 break;
  739.               case '}':
  740.                 brace--;
  741.                 break;
  742.               case '%':
  743.                 if (sp[1] == '%' && sp == line)
  744.                     return;
  745.                 break;
  746.               case '|':
  747.               case ';':
  748.                 in_rule = FALSE;
  749.                 break;
  750.               default:
  751.                 if (brace == 0  && !in_rule && (isalpha(*sp) ||
  752.                                 *sp == '.' ||
  753.                                 *sp == '_')) {
  754.                     orig_sp = sp;
  755.                     ++sp;
  756.                     while (isalnum(*sp) || *sp == '_' ||
  757.                            *sp == '.')
  758.                         sp++;
  759.                     toklen = sp - orig_sp;
  760.                     while (isspace(*sp))
  761.                         sp++;
  762.                     if (*sp == ':' || (*sp == '\0' &&
  763.                                first_char() == ':'))
  764.                     {
  765.                         strncpy(tok, orig_sp, toklen);
  766.                         tok[toklen] = '\0';
  767.                         strcpy(lbuf, line);
  768.                         lbuf[strlen(lbuf) - 1] = '\0';
  769.                         pfnote(tok, lineno, TRUE);
  770.                         in_rule = TRUE;
  771.                     }
  772.                     else
  773.                         sp--;
  774.                 }
  775.                 break;
  776.             }
  777. }
  778.  
  779. char *
  780. toss_comment(start)
  781. char    *start;
  782. {
  783.     register char    *sp;
  784.  
  785.     /*
  786.      * first, see if the end-of-comment is on the same line
  787.      */
  788.     do {
  789.         while ((sp = index(start, '*')) != NULL)
  790.             if (sp[1] == '/')
  791.                 return ++sp;
  792.             else
  793.                 start = ++sp;
  794.         start = line;
  795.         lineno++;
  796.     } while (fgets(line, sizeof line, inf) != NULL);
  797. }
  798.  
  799. getline()
  800. {
  801.     long saveftell = ftell( inf );
  802.     register char *cp;
  803.  
  804.     fseek( inf , lineftell , 0 );
  805.     fgets(lbuf, sizeof lbuf, inf);
  806.     cp = rindex(lbuf, '\n');
  807.     if (cp)
  808.         *cp = 0;
  809.     fseek(inf, saveftell, 0);
  810. }
  811.  
  812. free_tree(node)
  813. NODE    *node;
  814. {
  815.  
  816.     while (node) {
  817.         free_tree(node->right);
  818.         cfree(node);
  819.         node = node->left;
  820.     }
  821. }
  822.  
  823. add_node(node, cur_node)
  824.     NODE *node,*cur_node;
  825. {
  826.     register int dif;
  827.  
  828.     dif = strcmp(node->entry, cur_node->entry);
  829.     if (dif == 0) {
  830.         if (node->file == cur_node->file) {
  831.             if (!wflag) {
  832. fprintf(stderr,"Duplicate entry in file %s, line %d: %s\n",
  833.     node->file,lineno,node->entry);
  834. fprintf(stderr,"Second entry ignored\n");
  835.             }
  836.             return;
  837.         }
  838.         if (!cur_node->been_warned)
  839.             if (!wflag)
  840. fprintf(stderr,"Duplicate entry in files %s and %s: %s (Warning only)\n",
  841.     node->file, cur_node->file, node->entry);
  842.         cur_node->been_warned = TRUE;
  843.         return;
  844.     }
  845.  
  846.     if (dif < 0) {
  847.         if (cur_node->left != NULL)
  848.             add_node(node,cur_node->left);
  849.         else
  850.             cur_node->left = node;
  851.         return;
  852.     }
  853.     if (cur_node->right != NULL)
  854.         add_node(node,cur_node->right);
  855.     else
  856.         cur_node->right = node;
  857. }
  858.  
  859. put_entries(node)
  860. reg NODE    *node;
  861. {
  862.     reg char    *sp;
  863.  
  864.     if (node == NULL)
  865.         return;
  866.     put_entries(node->left);
  867.     if (xflag == 0)
  868.         if (node->f) {        /* a function */
  869.             fprintf(outf, "%s\t%s\t%c^",
  870.                 node->entry, node->file, searchar);
  871.             for (sp = node->pat; *sp; sp++)
  872.                 if (*sp == '\\')
  873.                     fprintf(outf, "\\\\");
  874.                 else if (*sp == searchar)
  875.                     fprintf(outf, "\\%c", searchar);
  876.                 else
  877.                     putc(*sp, outf);
  878.             fprintf(outf, "%c\n", searchar);
  879.         }
  880.         else {        /* a typedef; text pattern inadequate */
  881.             fprintf(outf, "%s\t%s\t%d\n",
  882.                 node->entry, node->file, node->lno);
  883.         }
  884.     else if (vflag)
  885.         fprintf(stdout, "%s %s %d\n",
  886.                 node->entry, node->file, (node->lno+63)/64);
  887.     else
  888.         fprintf(stdout, "%-16s%4d %-16s %s\n",
  889.             node->entry, node->lno, node->file, node->pat);
  890.     put_entries(node->right);
  891. }
  892. char    *dbp = lbuf;
  893. int    pfcnt;
  894.  
  895. PF_funcs(fi)
  896.     FILE *fi;
  897. {
  898.  
  899.     pfcnt = 0;
  900.     while (fgets(lbuf, sizeof(lbuf), fi)) {
  901.         lineno++;
  902.         dbp = lbuf;
  903.         if ( *dbp == '%' ) dbp++ ;    /* Ratfor escape to fortran */
  904.         while (isspace(*dbp))
  905.             dbp++;
  906.         if (*dbp == 0)
  907.             continue;
  908.         switch (*dbp |' ') {
  909.  
  910.           case 'i':
  911.             if (tail("integer"))
  912.                 takeprec();
  913.             break;
  914.           case 'r':
  915.             if (tail("real"))
  916.                 takeprec();
  917.             break;
  918.           case 'l':
  919.             if (tail("logical"))
  920.                 takeprec();
  921.             break;
  922.           case 'c':
  923.             if (tail("complex") || tail("character"))
  924.                 takeprec();
  925.             break;
  926.           case 'd':
  927.             if (tail("double")) {
  928.                 while (isspace(*dbp))
  929.                     dbp++;
  930.                 if (*dbp == 0)
  931.                     continue;
  932.                 if (tail("precision"))
  933.                     break;
  934.                 continue;
  935.             }
  936.             break;
  937.         }
  938.         while (isspace(*dbp))
  939.             dbp++;
  940.         if (*dbp == 0)
  941.             continue;
  942.         switch (*dbp|' ') {
  943.  
  944.           case 'f':
  945.             if (tail("function"))
  946.                 getit();
  947.             continue;
  948.           case 's':
  949.             if (tail("subroutine"))
  950.                 getit();
  951.             continue;
  952.           case 'p':
  953.             if (tail("program")) {
  954.                 getit();
  955.                 continue;
  956.             }
  957.             if (tail("procedure"))
  958.                 getit();
  959.             continue;
  960.         }
  961.     }
  962.     return (pfcnt);
  963. }
  964.  
  965. tail(cp)
  966.     char *cp;
  967. {
  968.     register int len = 0;
  969.  
  970.     while (*cp && (*cp&~' ') == ((*(dbp+len))&~' '))
  971.         cp++, len++;
  972.     if (*cp == 0) {
  973.         dbp += len;
  974.         return (1);
  975.     }
  976.     return (0);
  977. }
  978.  
  979. takeprec()
  980. {
  981.  
  982.     while (isspace(*dbp))
  983.         dbp++;
  984.     if (*dbp != '*')
  985.         return;
  986.     dbp++;
  987.     while (isspace(*dbp))
  988.         dbp++;
  989.     if (!isdigit(*dbp)) {
  990.         --dbp;        /* force failure */
  991.         return;
  992.     }
  993.     do
  994.         dbp++;
  995.     while (isdigit(*dbp));
  996. }
  997.  
  998. getit()
  999. {
  1000.     register char *cp;
  1001.     char c;
  1002.     char nambuf[BUFSIZ];
  1003.  
  1004.     for (cp = lbuf; *cp; cp++)
  1005.         ;
  1006.     *--cp = 0;    /* zap newline */
  1007.     while (isspace(*dbp))
  1008.         dbp++;
  1009.     if (*dbp == 0 || !isalpha(*dbp))
  1010.         return;
  1011.     for (cp = dbp+1; *cp && (isalpha(*cp) || isdigit(*cp)); cp++)
  1012.         continue;
  1013.     c = cp[0];
  1014.     cp[0] = 0;
  1015.     strcpy(nambuf, dbp);
  1016.     cp[0] = c;
  1017.     pfnote(nambuf, lineno);
  1018.     pfcnt++;
  1019. }
  1020.  
  1021. char *
  1022. savestr(cp)
  1023.     char *cp;
  1024. {
  1025.     register int len;
  1026.     register char *dp;
  1027.  
  1028.     len = strlen(cp);
  1029.     dp = (char *)malloc(len+1);
  1030.     strcpy(dp, cp);
  1031.     return (dp);
  1032. }
  1033.  
  1034. /*
  1035.  * Return the ptr in sp at which the character c last
  1036.  * appears; NULL if not found
  1037.  *
  1038.  * Identical to v7 rindex, included for portability.
  1039.  */
  1040.  
  1041. char *
  1042. rindex(sp, c)
  1043. register char *sp, c;
  1044. {
  1045.     register char *r;
  1046.  
  1047.     r = NULL;
  1048.     do {
  1049.         if (*sp == c)
  1050.             r = sp;
  1051.     } while (*sp++);
  1052.     return(r);
  1053. }
  1054.  
  1055. /*
  1056.  * lisp tag functions
  1057.  * just look for (def or (DEF
  1058.  */
  1059.  
  1060. L_funcs (fi)
  1061. FILE *fi;
  1062. {
  1063.     register int    special;
  1064.  
  1065.     pfcnt = 0;
  1066.     while (fgets(lbuf, sizeof(lbuf), fi)) {
  1067.         lineno++;
  1068.         dbp = lbuf;
  1069.         if (dbp[0] == '(' &&
  1070.             (dbp[1] == 'D' || dbp[1] == 'd') &&
  1071.             (dbp[2] == 'E' || dbp[2] == 'e') &&
  1072.             (dbp[3] == 'F' || dbp[3] == 'f')) {
  1073.             dbp += 4;
  1074.             if (striccmp(dbp, "method") == 0 ||
  1075.                 striccmp(dbp, "wrapper") == 0 ||
  1076.                 striccmp(dbp, "whopper") == 0)
  1077.                 special = TRUE;
  1078.             else
  1079.                 special = FALSE;
  1080.             while (!isspace(*dbp))
  1081.                 dbp++;
  1082.             while (isspace(*dbp))
  1083.                 dbp++;
  1084.             L_getit(special);
  1085.         }
  1086.     }
  1087. }
  1088.  
  1089. L_getit(special)
  1090. int    special;
  1091. {
  1092.     register char    *cp;
  1093.     register char    c;
  1094.     char        nambuf[BUFSIZ];
  1095.  
  1096.     for (cp = lbuf; *cp; cp++)
  1097.         continue;
  1098.     *--cp = 0;        /* zap newline */
  1099.     if (*dbp == 0)
  1100.         return;
  1101.     if (special) {
  1102.         if ((cp = index(dbp, ')')) == NULL)
  1103.             return;
  1104.         while (cp >= dbp && *cp != ':')
  1105.             cp--;
  1106.         if (cp < dbp)
  1107.             return;
  1108.         dbp = cp;
  1109.         while (*cp && *cp != ')' && *cp != ' ')
  1110.             cp++;
  1111.     }
  1112.     else
  1113.         for (cp = dbp + 1; *cp && *cp != '(' && *cp != ' '; cp++)
  1114.             continue;
  1115.     c = cp[0];
  1116.     cp[0] = 0;
  1117.     strcpy(nambuf, dbp);
  1118.     cp[0] = c;
  1119.     pfnote(nambuf, lineno,TRUE);
  1120.     pfcnt++;
  1121. }
  1122.  
  1123. /*
  1124.  * striccmp:
  1125.  *    Compare two strings over the length of the second, ignoring
  1126.  *    case distinctions.  If they are the same, return 0.  If they
  1127.  *    are different, return the difference of the first two different
  1128.  *    characters.  It is assumed that the pattern (second string) is
  1129.  *    completely lower case.
  1130.  */
  1131. striccmp(str, pat)
  1132. register char    *str, *pat;
  1133. {
  1134.     register int    c1;
  1135.  
  1136.     while (*pat) {
  1137.         if (isupper(*str))
  1138.             c1 = tolower(*str);
  1139.         else
  1140.             c1 = *str;
  1141.         if (c1 != *pat)
  1142.             return c1 - *pat;
  1143.         pat++;
  1144.         str++;
  1145.     }
  1146.     return 0;
  1147. }
  1148.  
  1149. /*
  1150.  * first_char:
  1151.  *    Return the first non-blank character in the file.  After
  1152.  *    finding it, rewind the input file so we start at the beginning
  1153.  *    again.
  1154.  */
  1155. first_char()
  1156. {
  1157.     register int    c;
  1158.     register long    off;
  1159.  
  1160.     off = ftell(inf);
  1161.     while ((c = getc(inf)) != EOF)
  1162.         if (!isspace(c) && c != '\r') {
  1163.             fseek(inf, off, 0);
  1164.             return c;
  1165.         }
  1166.     fseek(inf, off, 0);
  1167.     return EOF;
  1168. }
  1169.  
  1170. /*
  1171.  * toss_yysec:
  1172.  *    Toss away code until the next "%%" line.
  1173.  */
  1174. toss_yysec()
  1175. {
  1176.     char        buf[BUFSIZ];
  1177.  
  1178.     for (;;) {
  1179.         lineftell = ftell(inf);
  1180.         if (fgets(buf, BUFSIZ, inf) == NULL)
  1181.             return;
  1182.         lineno++;
  1183.         if (strncmp(buf, "%%", 2) == 0)
  1184.             return;
  1185.     }
  1186. }
  1187. SHAR_EOF
  1188. #    End of shell archive
  1189. exit 0
  1190.  
  1191.