home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_300 / 344_02 / xc2.c < prev    next >
Text File  |  1989-08-08  |  35KB  |  1,057 lines
  1. /*
  2.         HEADER:         CUG236;
  3.         TITLE:          Cross Reference Generator;
  4.         DATE:           04/27/1988;
  5.         DESCRIPTION:    "C-language program cross-referencer, modified for
  6.                             Microsoft C5.0, with enhancements."
  7.         VERSION:        1.1;
  8.         KEYWORDS:       Cross Reference;
  9.         FILENAME:       XC2.C;
  10.         SEE-ALSO:       CUG126, CUG171;
  11.         COMPILERS:      Vanilla;
  12.         AUTHORS:        Phillip N. Hisley, David N. Smith, Fred C. Smith,
  13.                         William C. Colley III;
  14. */
  15. /**********************************************************
  16.  
  17.         XC - A 'C' Concordance Utility
  18.  
  19.         Version 1.0 January, 1982
  20.  
  21.         Copyright (c) 1982 by Philip N. Hisley
  22.  
  23.             Philip N. Hisley
  24.             548H Jamestown Court
  25.             Edgewood, Maryland 21040
  26.             (301) 679-4606
  27.  
  28.         Released for non-commercial distribution only
  29.  
  30.  
  31.         Converted to IBM/PC CI/C86 by David N. Smith, May/June 1983
  32.         with enhancements and Lattice compiler support in December 1983.
  33.  
  34.             David N. Smith
  35.             44 Ole Musket Lane
  36.             Danbury, CT 06810
  37.             (203) 748-5934
  38.  
  39.         Changes Copyright (c) 1983 by David N. Smith
  40.  
  41.         PC Enhancements include:
  42.  
  43.             1)  Nested #INCLUDE statements
  44.             2)  Single spaced cross-reference list
  45.             3)  Removal of tabbing on output device
  46.                 (Since many printers don't support it)
  47.             4)  #INCLUDE statements with both "--" and <-->
  48.                 syntax and with a full fileid in the quotes.
  49.             5)  Multiple input filenames on command line.
  50.  
  51.  
  52.         Converted to Microsoft C V5.0 with enhancements.
  53.         November/December 1987.
  54.  
  55.                 Fred C. Smith
  56.                 20 Whipple Ave.
  57.                 Stoneham, MA 02180
  58.  
  59.         Enhancements/modifications include:
  60.  
  61.         1)  Call to reargv() at beginning of main(). If you are running
  62.             Allen Holub's Unix-like shell, reargv() will rebuild argc/argv
  63.             to contain the 2kbyte command-line which the shell provides.
  64.             If not using that shell, reargv is a no-op. (That shell is
  65.             available from M&T Books for around $40, including source!)
  66.         2)  Modify the include file lookups to use the same algorithm as
  67.             used by the Microsoft C compiler, i.e., look first in the
  68.             current directory for quote-delimited files. If a complete
  69.             pathname is specified look there only then quit. Any remaining
  70.             includes, including '<' or '"' delimited ones are then
  71.             searched for in the place(s) (if any) specified in the
  72.             optional parameter to the -i switch. If not found there,
  73.             searches the pathname(s) specified in the INCLUDE environment
  74.             variable.
  75.         3)  Modify the -i switch so that an optional trailing argument
  76.             specifies an alternate path for the includes, as in the -I
  77.             switch in the Microsoft C compiler's "cl" command. Multiple
  78.             -i switches may be given, each with a single pathname. These
  79.             multiple pathnames are saved in the order given.
  80.         4)  Make the default behavior to assume that comments are NOT
  81.             nested. Some PC-based C compilers (e.g. Lattice) support
  82.             nested comments, but Microsoft's does not. Also, those on
  83.             Unix and other larger systems do not. The ANSI standard
  84.             does not. For those who prefer to have support for nested
  85.             comments, a new command-line switch has been added so that
  86.             you can (optionally) have your cake, and eat it, too!
  87.         5)  Add recognition of keywords recognized in ANSI C, i.e.,
  88.             const, enum, signed, volatile, void. Remove recognition of
  89.             entry as a keyword (not in ANSI C). Also, add optional
  90.             recognition of Microsoft-specific keywords: cdecl, far,
  91.             fortran, huge, near and pascal. Use the -m switch for this
  92.             last group.
  93.         6)  Fix the awful kludge which previously existed in xc, in
  94.             which struct rf_blk.ref_cnt was declared as an int, but
  95.             under certain circumstances was used to hold a pointer to
  96.             a struct rf_blk. Replaced the declaration of ref_cnt as
  97.             an int with an appropriately declared union of the two
  98.             types needed.
  99.         7)  Minor tweaks to proc_file to fix incorrect line numbers
  100.             being generated around included files.
  101.         8)  In fil_chr(), used ferror() and feof() to implement the
  102.             original error-checking logic which had been commented
  103.             out in previous versions of the code.
  104.  
  105.     Version 1.1 -- April 1988:
  106.  
  107.         Microsoft-isms removed by William C. Colley, III.  In particular
  108.         the function access() is not available in many environments.  A
  109.         reorganization of the code eliminates the use of this function.  Note,
  110.         however, that the function open_include_file() does chop on file names
  111.         which is an inherently non-portable operation, so that function will
  112.         have to be cut to fit different operating systems' file naming
  113.         conventions.  Also, the call to getenv() may have to be modified or
  114.         removed.
  115.  
  116.         Also, added the -x option to remove the directories specified in the
  117.         INCLUDE environment variable from the search path for #include files.
  118.         WCC3.
  119.  
  120.     Abstract:
  121.  
  122.         'XC' is a cross-reference utility for 'C' programs.  Its has the
  123.         ability to handle nested include files to a depth of 8 levels and
  124.         properly processes nested comments as supported by BDS C. Option flags
  125.         support the following features:
  126.  
  127.             - Routing of list output to disk
  128.             - Cross-referencing of reserved words
  129.             - Processing of nested include files
  130.             - Generation of listing only
  131.  
  132.         Usage: xc <filename> <flag(s)>
  133.  
  134.         Flags:  -i [pathname]     = Enable file inclusion
  135.                 -l                = Generate listing only
  136.                 -m                = recognize Microsoft-specific keywords
  137.                 -n                = Allow nested comments
  138.                 -o <filename>     = Write output to named file
  139.                 -r                = Cross-ref reserved words
  140.                 -w <width>        = Maximum listing width
  141.                 -x                = Exclude default include file dir's
  142.  
  143.         Note:   For the -i option, the pathname is optional.  The -i flag may
  144.                 be given multiple times, each time with a pathname. These
  145.                 pathnames are saved, building a list of places to search for
  146.                 include files.  If no list is given the standard places will
  147.                 be used.  If the -i option flag is not used, includes will not
  148.                 be cross-referenced.
  149.  
  150. ***********************************************************/
  151.  
  152. /* Compiler specific stuff */
  153.  
  154. #define LINT_ARGS
  155. #include <stdio.h>
  156. #include <stdlib.h>
  157. #include <ctype.h>
  158. #include <alloc.h>         /* was malloc.h dnh 7/21/89 */
  159. #include <string.h>
  160. #undef LINT_ARGS
  161.  
  162. /* end compiler specific section */
  163.  
  164. /* Function declarations for xc's routines. */
  165.  
  166. #include "xc2.h"
  167.  
  168. #ifndef TRUE
  169. #define TRUE        1
  170. #define FALSE       0
  171. #endif
  172.  
  173. #define DUMMY       0       /* a dummy integer value */
  174. #define ERROR       -1
  175. #define MAX_REF     5       /* maximum refs per ref-block */
  176. #define MAX_LEN     32      /* maximum identifier length */
  177.                             /* was 20 dnh 7/21/89 - deeper error !! */
  178. #define MAX_WRD     749     /* maximum number of identifiers */
  179. #define MAX_ALPHA   53      /* maximum alpha chain heads */
  180. #define REFS_PER_LINE 10    /* maximum refs per line */
  181. #define LINES_PER_PAGE 60
  182. #define MAXCOL      78      /* default max column number for listing line */
  183. #define MINCOL      30      /* minimum value for -w option */
  184. #define PATHLEN     128     /* maximum pathname length in chars. */
  185. #define FF          0x0C    /* formfeed */
  186.  
  187. typedef union {
  188.     int cnt;
  189.     struct rf_blk *pnext;
  190. } cnt;
  191.  
  192. struct rf_blk {
  193.     int  ref_item[MAX_REF];
  194.     cnt ref_cnt;
  195. } onerf;
  196.  
  197. struct id_blk {
  198.     char id_name[MAX_LEN];
  199.     struct id_blk *alpha_lnk;
  200.     struct rf_blk *top_lnk;
  201.     struct rf_blk *lst_lnk;
  202. } oneid;
  203.  
  204. struct id_blk *id_vector[MAX_WRD];
  205.  
  206. struct alpha_hdr {
  207.     struct id_blk *alpha_top;
  208.     struct id_blk *alpha_lst;
  209. };
  210.  
  211. struct alpha_hdr alpha_vector[MAX_ALPHA];
  212.  
  213. int lin_refs = MAXCOL/7;/* max refs on a printed line */
  214. int linum;              /* line number */
  215. int edtnum = 0;         /* edit line number */
  216. int fil_cnt = 0;        /* active file index */
  217. int wrd_cnt = 0;        /* token count */
  218. int pagno = 0;          /* page number */
  219. int id_cnt = 0;         /* number of unique identifiers */
  220. int rhsh_cnt = 0;       /* number of conflict hits */
  221. int filevl = 0;         /* file level  */
  222. int paglin = 0;         /* page line counter */
  223. int maxcol = MAXCOL;    /* maximum right column for listing line */
  224. int prt_ref = FALSE;
  225. char act_fil[PATHLEN];
  226. char lst_fil[PATHLEN];
  227. char gbl_fil[PATHLEN];
  228. char i_path[PATHLEN];
  229. FILE *f_lst_fil;
  230. int n_flg = FALSE;
  231. int i_flg = FALSE;
  232. int o_flg = FALSE;
  233. int r_flg = FALSE;
  234. int l_flg = FALSE;
  235. int m_flg = FALSE;
  236. int x_flg = FALSE;
  237.  
  238.  
  239. /*************************************************************************/
  240.  
  241. int main(p_argc, p_argv)
  242. int p_argc;
  243. char **p_argv;
  244. {
  245.     char *arg, **argv;
  246.     int argc, i;
  247.     FILE *f;
  248.  
  249. #ifdef REARGV
  250.     reargv (&p_argc, &p_argv);
  251. #endif
  252.  
  253.     argc = p_argc;  argv = p_argv;
  254.     if (argc < 2) use_err();
  255.     while (--argc) {
  256.         if (*(arg = *++argv) == '-') {
  257.             switch (*++arg) {
  258.                 case 'i':
  259.                 case 'I':
  260.                     i_flg = TRUE;
  261.                     if (argc > 1 && **(argv + 1) != '-' && **(argv + 1)) {
  262.                         if (strlen(i_path)) {
  263.                             strcat(i_path,";");  strcat(i_path,*++argv);
  264.                         }
  265.                         else strcpy(i_path,*++argv);
  266.                     }
  267.                     else i_path[0] = '\0';
  268.                     if (i_path[0] == '-') use_err();
  269.                     break;
  270.                 case 'r':
  271.                 case 'R':
  272.                     r_flg++;
  273.                     break;
  274.                 case 'l':
  275.                 case 'L':
  276.                     l_flg++;
  277.                     break;
  278.                 case 'n':
  279.                 case 'N':
  280.                     n_flg++;
  281.                     break;
  282.                 case 'm':
  283.                 case 'M':
  284.                     m_flg++;
  285.                     break;
  286.                 case 'o':
  287.                 case 'O':
  288.                     o_flg++;
  289.                     if (!--argc) use_err();
  290.                     strcpy(lst_fil,*++argv);
  291.                     if (lst_fil[0] == '-') use_err();
  292.                     break;
  293.                 case 'w':
  294.                 case 'W':
  295.                     if (!--argc) use_err();
  296.                     if ((i = atoi(*++argv)) <= MINCOL || i >= 255) use_err();
  297.                     maxcol = i;
  298.                     lin_refs = maxcol/7;
  299.                     break;
  300.                 case 'x':
  301.                 case 'X':
  302.                     x_flg++;
  303.                     break;
  304.                 default:
  305.                     use_err();
  306.                     break;
  307.             }
  308.         }
  309.     }
  310.     if (o_flg) {
  311.         if (!(f_lst_fil = fopen(lst_fil,"w"))) {
  312.             printf("ERROR: Unable to create list file - %s\n",lst_fil);
  313.             exit(0);
  314.         }
  315.         printf("XC ... 'C' Concordance Utility  v1.0\n\n");
  316.     }
  317.     for (linum = 0;  linum < MAX_WRD;  ++linum) id_vector[linum] = NULL;
  318.     for (linum = 0; linum < MAX_ALPHA; ++linum)
  319.         alpha_vector[linum].alpha_top = alpha_vector[linum].alpha_lst = NULL;
  320.     linum = 0;
  321.     while (--p_argc && **++p_argv != '-') {
  322.         strcpy(gbl_fil,*p_argv);  strcpy(act_fil,*p_argv);
  323.         if (!(f = fopen(gbl_fil,"r")))
  324.             printf("\nERROR: Unable to open input file: %s\n",gbl_fil);
  325.         else proc_file(f,DUMMY);
  326.     }
  327.     if (!l_flg) {
  328.         prnt_tbl();
  329.         printf("\nAllowable Symbols: %d\n",MAX_WRD);
  330.         printf("   Unique Symbols: %d\n",id_cnt);
  331.     }
  332.     if (o_flg) {
  333.         echo(FF);  fclose(f_lst_fil);
  334.     }
  335.     return 0;
  336. }
  337.  
  338. /*************************************************************************/
  339.  
  340. void lst_err() {
  341.     printf("\nERROR: Write error on list output file - %s\n", lst_fil);
  342.     exit(0);
  343. }
  344.  
  345. /*************************************************************************/
  346.  
  347. void use_err() {
  348.     printf("\nERROR: Invalid parameter specification\n\n");
  349.     printf("Usage: xc <filename>... <flag(s)>\n\n");
  350.     printf("Flags: -i <opt. path(s)> = enable file inclusion\n");
  351.     printf("       -l                = Generate listing only\n");
  352.     printf("       -m                = Recognize Microsoft specific keywords\n");
  353.     printf("       -n                = Allow nested comments\n");
  354.     printf("       -o <outfile>      = Write output to named file\n");
  355.     printf("       -r                = Cross-reference reserved words\n");
  356.     printf("       -w width          = Width of output page; default=78\n");
  357.     printf("       -x                = Exclude default include file dir's\n");
  358.     printf("Flags must follow all input file names");
  359.     exit(0);
  360. }
  361.  
  362. /*************************************************************************/
  363.  
  364. int proc_file(infile,incnum)
  365. FILE *infile;
  366. int incnum;         /* prev. included line number (return to caller) */
  367. {
  368.     char token[MAX_LEN];    /* token buffer */
  369.     char cur_fil[PATHLEN];  /* name of file we are currently processing */
  370.     int eof_flg;            /* end-of-file indicator */
  371.     int tok_len;            /* token length */
  372.     FILE *f, *get_include_file();
  373.  
  374.     edtnum=0;
  375.     if (!filevl++) prt_hdr();
  376.     else nl();
  377.     eof_flg = FALSE;
  378.     do {
  379.         if (get_token(infile,token,&tok_len,&eof_flg,0)) {
  380.             if (chk_token(token)) {
  381.                 if((!strcmp(token,"#include")) && i_flg) {
  382.                     strcpy(cur_fil,act_fil);
  383.                     if (f = get_include_file(infile))
  384.                         edtnum = proc_file(f,edtnum);
  385.                     else if (!i_flg)
  386.                         printf("\nERROR: Unable to open input file: %s\n",
  387.                             act_fil);
  388.                     strcpy(act_fil,cur_fil);
  389.                 }
  390.                 else put_token(token,linum);
  391.             }
  392.         }
  393.     } while (!eof_flg);
  394.  
  395.     --filevl;  fclose(infile);  return incnum;
  396. }
  397.  
  398. /*****************************************************************************
  399.  *  Reads the include filename from the source file and saves it into a global
  400.  *  variable, act_fil[].  It is assumed that the include statement gives the
  401.  *  filename only, without any drive specifier or path, as in the previous
  402.  *  version of XC.  Calls open_include_file() to flesh out the filename into a
  403.  *  full pathname and actually get the file opened.
  404.  */
  405.  
  406. FILE *get_include_file(infile)
  407. FILE *infile;
  408. {
  409.     char c, term, *p;
  410.     FILE *open_include_file();
  411.  
  412.     p = act_fil;
  413.  
  414.     while ((term = getc(infile)) == ' ') echo(term);
  415.     echo(term);
  416.     if (term == '<') term = '>';    /* terminator is > or " */
  417.     if ((term != '>') && (term != '"')) {
  418.         printf("Error scanning #INCLUDE fileid: %c\n",term);
  419.         exit(1);
  420.     }
  421.  
  422.     do {
  423.         if ((c = getc(infile)) != ' ') *p++ = c;
  424.         echo(c);
  425.     } while (c != term);
  426.     *--p = '\0';
  427.  
  428.     if (i_flg) return open_include_file(act_fil,term);
  429.     else return NULL;
  430. }
  431.  
  432. /*************************************************************************/
  433.  
  434. FILE *open_include_file(filenam,delim)
  435. char *filenam, delim;
  436. {
  437.     char fullnam[PATHLEN];
  438.     char includevar[4 * PATHLEN];
  439.     char *temp1, *temp2;
  440.     int include_len;
  441.     FILE *f;
  442.  
  443. /*
  444.  *  First, if delimited by quotes and file exists in current directory, return
  445.  *  a file handle for the opened file.  Next, if a complete pathname
  446.  *  specified, return a file handle for the opened file or NULL if the file
  447.  *  cannot be found.
  448.  */
  449.  
  450.     if (delim == '"' && (f = fopen(filenam,"r"))) return f;
  451.     if (filenam[1] == ':' || filenam[0] == '\\' || filenam[0] == '/')
  452.         return fopen(filenam,"r");
  453.  
  454. /*
  455.  *  Next, if a non-null pathname was provided with the -i switch, check in
  456.  *  that place.  Finally, check in the places specified by the INCLUDE
  457.  *  environment variable unless the -x switch was used.
  458.  */
  459.  
  460.     if (i_path[0] || (temp1 = getenv("INCLUDE"))) {
  461.         strcpy(includevar,";");
  462.         if (i_path[0]) { strcat(includevar,i_path);  strcat(includevar,";"); }
  463.         if (!x_flg) strcat(includevar,temp1);
  464.         include_len = strlen(temp2 = includevar);
  465.  
  466. /*
  467.  *  Break up the semicolon-delimited list of directories into
  468.  *  null-terminated strings and check each of them.
  469.  */
  470.  
  471.         while (include_len > 0) {
  472.             for (temp1 = temp2;  *temp2 != ';' && *temp2;  ++temp2)
  473.                 --include_len;
  474.             if (*temp2 == ';') 
  475.             {
  476.                *temp2++ = '\0';
  477.                --include_len;
  478.             }
  479.             strcpy(fullnam,temp1);  strcat(fullnam,"\\");
  480.             strcat(fullnam,filenam);
  481.             if (f = fopen(fullnam,"r")) return f;
  482.         }
  483.     }
  484.     return NULL;
  485. }
  486.  
  487. /*************************************************************************/
  488.  
  489. void echo(c)
  490. char c;
  491. {
  492.     static int col = 11;
  493.     int i;
  494.  
  495.     echochar(c);
  496.     if (c == '\n') col = 11;
  497.     else if (++col > maxcol) {
  498.         col = 11;  ++paglin;
  499.         echochar('\n');
  500.         for (i = 1;  i <= 11;  ++i) echochar(' ');
  501.     }
  502. }
  503. /************************************************************/
  504. void echochar(c)
  505. char c;
  506. {
  507.     if (o_flg) {
  508.         if (fprintf(f_lst_fil,"%c",c) == ERROR) lst_err();
  509.     }
  510.     else printf("%c",c);
  511. }
  512.  
  513. /*************************************************************************/
  514.  
  515. int get_token(infile,g_token,g_toklen,g_eoflg,g_flg)
  516. FILE *infile;
  517. char *g_token;
  518. int *g_toklen, *g_eoflg, g_flg;
  519. {
  520.  
  521. /*
  522.         'getoken' returns the next valid identifier or
  523.         reserved word from a given file along with the
  524.         character length of the token and an end-of-file
  525.         indicator
  526. */
  527.  
  528.     int c;
  529.     char *h_token, tmpchr;
  530.  
  531.     h_token = g_token;
  532.  
  533.     gtk:
  534.     *g_toklen = 0;  g_token = h_token;
  535.  
  536. /*
  537.         Scan and discard any characters until an alphabetic or
  538.         '_' (underscore) character is encountered or an end-of-file
  539.         condition occurs
  540. */
  541.  
  542.     while ((!isalpha(*g_token = rdchr(infile,g_eoflg,g_flg)))
  543.         && !*g_eoflg && *g_token != '_' && *g_token != '0'
  544.         && *g_token != '#');
  545.  
  546.     if (*g_eoflg) return FALSE;
  547.     *g_toklen += 1;
  548.  
  549. /*
  550.         Scan and collect identified alpanumeric token until
  551.         a non-alphanumeric character is encountered or and
  552.         end-of-file condition occurs
  553. */
  554.  
  555.     if (g_flg) tmpchr = '.';
  556.     else tmpchr = '_';
  557.     while ((isalpha(c = rdchr(infile,g_eoflg,g_flg))
  558.         || isdigit(c) || c == '_' || c == tmpchr) && !*g_eoflg) {
  559.         if (*g_toklen < MAX_LEN) { *++g_token = c;  ++*g_toklen; }
  560.     }
  561.  
  562. /*
  563.         Check to see if a numeric hex or octal constant has
  564.         been encountered ... if so dump it and try again
  565. */
  566.  
  567.     if (*h_token == '0') goto gtk;
  568.  
  569. /*
  570.         Tack a NUL character onto the end of the token
  571. */
  572.  
  573.     *++g_token = '\0';
  574.  
  575. /*
  576.         Screen out all #token strings except #include
  577. */
  578.  
  579.     if (*h_token == '#' && strcmp(h_token,"#include")) goto gtk;
  580.  
  581.     return(TRUE);
  582. }
  583.  
  584. /*************************************************************************/
  585.  
  586. int fil_chr(infile,f_eof)
  587. FILE *infile;
  588. int *f_eof;
  589. {
  590.     int fc;
  591.  
  592.     if ((fc = getc(infile)) == EOF) {
  593.         if (ferror (infile)) {
  594.             printf("\nERROR: Error while processing input file - %s\n",
  595.                 act_fil);
  596.             exit(0);
  597.         }
  598.         else if (feof(infile)) {
  599.             *f_eof = TRUE;  fc = NULL;
  600.         }
  601.     }
  602.     return fc;
  603. }
  604.  
  605. /*************************************************************************/
  606.  
  607. int rdchr(infile,r_eoflg,rd_flg)
  608. FILE *infile;
  609. int *r_eoflg, rd_flg;
  610. {
  611.  
  612. /*
  613.         'rdchr' returns the next valid character in a file
  614.         and an end-of-file indicator. A valid character is
  615.         defined as any which does not appear in either a
  616.         commented or a quoted string ... 'rdchr' will correctly
  617.         handle comment tokens which appear within a quoted
  618.         string
  619. */
  620.  
  621.     int c;
  622.     int q_flg;          /* double quoted string flag */
  623.     int q1_flg;         /* single quoted string flag */
  624.     int cs_flg;         /* comment start flag */
  625.     int ce_flg;         /* comment end flag */
  626.     int c_cnt;          /* comment nesting level */
  627.     int t_flg;          /* transparency flag */
  628.  
  629.     q_flg = q1_flg = cs_flg = ce_flg = t_flg = FALSE;
  630.     c_cnt  = 0;
  631.  
  632.     rch:
  633.  
  634. /*
  635.         Fetch character from file
  636. */
  637.  
  638.     c = fil_chr(infile,r_eoflg);
  639.     if (*r_eoflg) return c;        /* EOF encountered */
  640.     if (c == '\n') nl();
  641.     else echo(c);
  642.  
  643.     if (rd_flg) return c;
  644.  
  645.     if (t_flg) { t_flg = !t_flg;  goto rch; }
  646.     if (c == '\\') { t_flg = TRUE;  goto rch; }
  647.  
  648. /*
  649.         If the character is not part of a quoted string
  650.         check for and process commented strings...
  651.         nested comments are handled correctly but unbalanced
  652.         comments are not ... the assumption is made that
  653.         the syntax of the program being xref'd is correct.
  654.   NOTE: Now nested comment support is optional. The source for XC
  655.         formerly contained an un-matched begin comment. If nested
  656.         comment support is used to cross-reference the xc source
  657.         the program produces an incorrect cross-reference, yet
  658.         the Microsoft compiler compiles it correctly, as it
  659.         should. Nested comments are a non-standard extension to
  660.         the language. Therefore, nested comment support has been made
  661.         optional.
  662.         See usage information in comment at top of file.
  663. */
  664.  
  665.     if (!q_flg && !q1_flg) {
  666.         if (c == '*' && c_cnt && !cs_flg) { ce_flg = TRUE;  goto rch; }
  667.         if (c == '/' && ce_flg) {
  668.             c_cnt -= 1;  ce_flg = FALSE;  goto rch;
  669.         }
  670.         ce_flg = FALSE;
  671.         if (c == '/') { cs_flg = TRUE;  goto rch; }
  672.         if (c == '*' && cs_flg) {
  673.             c_cnt = (n_flg) ? TRUE : c_cnt + 1; /* optional nested comments */
  674.             cs_flg = FALSE;  goto rch;
  675.         }
  676.         cs_flg = FALSE;
  677.         if (c_cnt) goto rch;
  678.     }
  679.  
  680. /*
  681.         Check for and process quoted strings
  682. */
  683.  
  684.     if (c == '"' && !q1_flg) {
  685.         q_flg =  !q_flg;        /* toggle quote flag */
  686.         goto rch;
  687.     }
  688.     if (q_flg) goto rch;
  689.  
  690.     if (c == '\'') {
  691.         q1_flg = !q1_flg;       /* toggle quote flag */
  692.         goto rch;
  693.     }
  694.     if (q1_flg) goto rch;
  695.  
  696. /*
  697.         Valid character ... return to caller
  698. */
  699.  
  700.     return c;
  701. }
  702.  
  703. /*************************************************************************/
  704.  
  705. int chk_token(c_token)
  706. char *c_token;
  707. {
  708.     char u_token[MAX_LEN];
  709.     int i;
  710.  
  711.     if (r_flg) return TRUE;
  712.     i = 0;
  713.     do {
  714.         u_token[i] = toupper(c_token[i]);
  715.     } while (c_token[i++] != NULL);
  716.  
  717. /*
  718.  *  Support for the Microsoft extended keywords.
  719.  */
  720.  
  721.     if (m_flg) {
  722.         switch (u_token[0]) {
  723.             case 'C':
  724.                 if (!strcmp(u_token,"CDECL")) return FALSE;
  725.                 break;
  726.             case 'F':
  727.                 if (!strcmp(u_token,"FORTRAN")) return FALSE;
  728.                 if (!strcmp(u_token,"FAR")) return FALSE;
  729.                 break;
  730.             case 'H':
  731.                 if (!strcmp(u_token,"HUGE")) return FALSE;
  732.                 break;
  733.             case 'N':
  734.                 if (!strcmp(u_token,"NEAR")) return FALSE;
  735.                 break;
  736.             case 'P':
  737.                 if (!strcmp(u_token,"PASCAL")) return FALSE;
  738.                 break;
  739.             case '_':
  740.                 if (!strcmp(u_token,"_CDECL")) return FALSE;
  741.                 if (!strcmp(u_token,"_FAR")) return FALSE;
  742.                 break;
  743.         }
  744.     }
  745.  
  746. /*
  747.  *  Standard keyword support.
  748.  */
  749.  
  750.     switch (u_token[0]) {
  751.         case 'A':
  752.             if (!strcmp(u_token,"AUTO")) return FALSE;
  753.             break;
  754.         case 'B':
  755.             if (!strcmp(u_token,"BREAK")) return FALSE;
  756.             break;
  757.         case 'C':
  758.             if (!strcmp(u_token,"CHAR")) return  FALSE;
  759.             if (!strcmp(u_token,"CONTINUE")) return  FALSE;
  760.             if (!strcmp(u_token,"CONST")) return  FALSE;
  761.             if (!strcmp(u_token,"CASE")) return  FALSE;
  762.             break;
  763.         case 'D':
  764.             if (!strcmp(u_token,"DOUBLE")) return FALSE;
  765.             if (!strcmp(u_token,"DO")) return FALSE;
  766.             if (!strcmp(u_token,"DEFAULT")) return FALSE;
  767.             break;
  768.         case 'E':
  769.             if (!strcmp(u_token,"EXTERN")) return FALSE;
  770.             if (!strcmp(u_token,"ELSE")) return FALSE;
  771.             if (!strcmp(u_token,"ENUM")) return FALSE;
  772.             break;
  773.         case 'F':
  774.             if (!strcmp(u_token,"FLOAT")) return FALSE;
  775.             if (!strcmp(u_token,"FOR")) return FALSE;
  776.             break;
  777.         case 'G':
  778.             if (!strcmp(u_token,"GOTO")) return FALSE;
  779.             break;
  780.         case 'I':
  781.             if (!strcmp(u_token,"INT")) return FALSE;
  782.             if (!strcmp(u_token,"IF")) return FALSE;
  783.             break;
  784.         case 'L':
  785.             if (!strcmp(u_token,"LONG")) return FALSE;
  786.             break;
  787.         case 'R':
  788.             if (!strcmp(u_token,"RETURN")) return FALSE;
  789.             if (!strcmp(u_token,"REGISTER")) return FALSE;
  790.             break;
  791.         case 'S':
  792.             if (!strcmp(u_token,"STRUCT")) return FALSE;
  793.             if (!strcmp(u_token,"SHORT")) return FALSE;
  794.             if (!strcmp(u_token,"STATIC")) return FALSE;
  795.             if (!strcmp(u_token,"SIZEOF")) return FALSE;
  796.             if (!strcmp(u_token,"SWITCH")) return FALSE;
  797.             if (!strcmp(u_token,"SIGNED")) return FALSE;
  798.             break;
  799.         case 'T':
  800.             if (!strcmp(u_token,"TYPEDEF")) return FALSE;
  801.             break;
  802.         case 'U':
  803.             if (!strcmp(u_token,"UNION")) return FALSE;
  804.             if (!strcmp(u_token,"UNSIGNED")) return FALSE;
  805.             break;
  806.         case 'V':
  807.             if (!strcmp(u_token,"VOID")) return FALSE;
  808.             if (!strcmp(u_token,"VOLATILE")) return FALSE;
  809.             break;
  810.         case 'W':
  811.             if (!strcmp(u_token,"WHILE")) return FALSE;
  812.             break;
  813.     }
  814.     return TRUE;
  815. }
  816.  
  817. /*************************************************************************/
  818.  
  819. /*
  820.    Install parsed token and line reference in linked structure
  821. */
  822.  
  823. void put_token(p_token,p_ref)
  824. char *p_token;
  825. int p_ref;
  826. {
  827.     int hsh_index, i, j, d, found;
  828.     struct id_blk *idptr;
  829.     struct id_blk *alloc_id();
  830.     struct rf_blk *alloc_rf(), *add_rf();
  831.  
  832.     if (l_flg) return;
  833.     j=0;
  834.     for (i = 0;  p_token[i] != NULL;  ++i) {    /* Hashing algorithm is far */
  835.         j = j * 10 + p_token[i];                /* from optimal but is      */
  836.     }                                           /* adequate for a memory-   */
  837.     hsh_index = abs(j) % MAX_WRD;               /* bound index vector!      */
  838.     found = FALSE;  d = 1;
  839.     do {
  840.         idptr = id_vector[hsh_index];
  841.         if (idptr == NULL) {
  842.             id_cnt++;
  843.             idptr = id_vector[hsh_index] = alloc_id(p_token);
  844.             chain_alpha(idptr,p_token);
  845.             idptr->top_lnk = idptr->lst_lnk = alloc_rf(p_ref);
  846.             found = TRUE;
  847.         }
  848.         else if (!strcmp(p_token,idptr->id_name)) {
  849.             idptr->lst_lnk = add_rf(idptr->lst_lnk,p_ref);
  850.             found = TRUE;
  851.         }
  852.         else {
  853.             hsh_index += d;  d += 2;  rhsh_cnt++;
  854.             if (hsh_index >= MAX_WRD) hsh_index -= MAX_WRD;
  855.             if (d == MAX_WRD) {
  856.                 printf("\nERROR: Symbol table overflow\n");
  857.                 exit(0);
  858.             }
  859.         }
  860.     } while (!found);
  861. }
  862.  
  863. /*************************************************************************/
  864.  
  865. void chain_alpha(ca_ptr,ca_token)
  866. struct id_blk *ca_ptr;
  867. char  *ca_token;
  868. {
  869.     char c;
  870.     struct id_blk *cur_ptr;
  871.     struct id_blk *lst_ptr;
  872.  
  873.     if ((c = ca_token[0]) == '_') c = 0;
  874.     else if (isupper(c)) c = 1 + ((c - 'A') * 2);
  875.     else c = 2 + ((c - 'a') * 2);
  876.  
  877.     if (!alpha_vector[c].alpha_top) {
  878.         alpha_vector[c].alpha_top = alpha_vector[c].alpha_lst = ca_ptr;
  879.         ca_ptr->alpha_lnk = NULL;  return;
  880.     }
  881.  
  882. /*
  883.     check to see if new id_blk should be inserted between
  884.     the alpha_vector header block and the first id_blk in
  885.     the current alpha chain
  886. */
  887.  
  888.     if (strcmp(alpha_vector[c].alpha_top->id_name,ca_token) > 0) {
  889.         ca_ptr->alpha_lnk=alpha_vector[c].alpha_top;
  890.         alpha_vector[c].alpha_top=ca_ptr;  return;
  891.     }
  892.     if (strcmp(alpha_vector[c].alpha_lst->id_name,ca_token) < 0) {
  893.         alpha_vector[c].alpha_lst->alpha_lnk = ca_ptr;
  894.         ca_ptr->alpha_lnk = NULL;  alpha_vector[c].alpha_lst=ca_ptr;  return;
  895.     }
  896.     cur_ptr = alpha_vector[c].alpha_top;
  897.     while (strcmp(cur_ptr->id_name,ca_token) < 0) {
  898.         lst_ptr = cur_ptr;  cur_ptr = lst_ptr->alpha_lnk;
  899.     }
  900.     lst_ptr->alpha_lnk = ca_ptr;  ca_ptr->alpha_lnk = cur_ptr;  return;
  901. }
  902.  
  903. /*************************************************************************/
  904.  
  905. struct id_blk *alloc_id(aid_token)
  906. char *aid_token;
  907. {
  908.     int ai;
  909.     struct id_blk *aid_ptr;
  910.  
  911.     if (!(aid_ptr = (struct id_blk *)malloc(sizeof(struct id_blk)))) {
  912.         printf("\nERROR: Unable to allocate identifier block\n");
  913.         exit(0);
  914.     }
  915.     ai = 0;
  916.     do
  917.         aid_ptr->id_name[ai] = aid_token[ai];
  918.     while (aid_token[ai++] != NULL);
  919.     return aid_ptr;
  920. }
  921.  
  922. /*************************************************************************/
  923.  
  924. struct rf_blk *alloc_rf(arf_ref)
  925. int arf_ref;
  926. {
  927.     int ri;
  928.     struct rf_blk *arf_ptr;
  929.  
  930.     if (!(arf_ptr = (struct rf_blk *)malloc(sizeof(struct rf_blk)))) {
  931.         printf("\nERROR: Unable to allocate reference block\n");
  932.         exit(0);
  933.     }
  934.     arf_ptr->ref_item[0] = arf_ref;  arf_ptr->ref_cnt.cnt = 1;
  935.     for (ri = 1;  ri < MAX_REF;  ++ri) arf_ptr->ref_item[ri] = NULL;
  936.     return arf_ptr;
  937. }
  938.  
  939. /*************************************************************************/
  940.  
  941. struct rf_blk *add_rf(adr_ptr,adr_ref)
  942. struct rf_blk *adr_ptr;
  943. int adr_ref;
  944. {
  945.     struct rf_blk *tmp_ptr;
  946.  
  947.     tmp_ptr = adr_ptr;
  948.     if (adr_ptr->ref_cnt.cnt == MAX_REF) {
  949.         tmp_ptr = alloc_rf(adr_ref);
  950.         adr_ptr->ref_cnt.pnext = tmp_ptr;
  951.     }
  952.     else adr_ptr->ref_item[adr_ptr->ref_cnt.cnt++] = adr_ref;
  953.     return tmp_ptr;
  954. }
  955.  
  956. /*************************************************************************/
  957.  
  958. void prnt_tbl()
  959. {
  960.     int prf_cnt, pti, pref, lin_cnt;
  961.     struct id_blk *pid_ptr;
  962.     struct rf_blk *ptb_ptr;
  963.  
  964.     prt_ref = TRUE;  prt_hdr();
  965.     for (pti = 0;  pti < MAX_ALPHA;  ++pti) {
  966.         if (pid_ptr = alpha_vector[pti].alpha_top) {
  967.             do {
  968.                 if (o_flg) {
  969.                     if (fprintf(f_lst_fil,"     %-20.19s: ",pid_ptr->id_name)
  970.                         == ERROR) lst_err();
  971.                 }
  972.                 else printf("%-20.19s: ",pid_ptr->id_name);
  973.                 ptb_ptr = pid_ptr->top_lnk;  lin_cnt = -1;  prf_cnt = 0;
  974.                 do {
  975.                     if (prf_cnt == MAX_REF) {
  976.                         prf_cnt = 0;
  977.                         if ((ptb_ptr->ref_cnt.cnt > MAX_REF) ||
  978.                             (ptb_ptr->ref_cnt.cnt < 0) &&
  979.                             (ptb_ptr->ref_cnt.cnt != NULL))
  980.                            ptb_ptr = (struct rf_blk *)ptb_ptr->ref_cnt.pnext;
  981.                         else
  982.                            ptb_ptr = NULL;
  983.                     }
  984.                     if (ptb_ptr) {
  985.                         if (pref = ptb_ptr->ref_item[prf_cnt++]) {
  986.                             if (++lin_cnt == lin_refs) {   /* was REFS_PER_LINE dnh 7/21/89 */
  987.                                 nl();
  988.                                 if (o_flg) {
  989.                                     if (fprintf(f_lst_fil,
  990.                                         "                           ") == ERROR)
  991.                                         lst_err();
  992.                                 }
  993.                                 else printf("                      ");
  994.                                 lin_cnt=0;
  995.                             }
  996.                             if (o_flg) {
  997.                                 if (fprintf(f_lst_fil,"%4d ",pref) == ERROR)
  998.                                     lst_err();
  999.                             }
  1000.                             else printf("%4d ",pref);
  1001.                         }
  1002.                     }
  1003.                     else pref=0;
  1004.                 } while (pref);
  1005.                 nl();
  1006.             } while ((pid_ptr=pid_ptr->alpha_lnk) != NULL);
  1007.         }
  1008.     }
  1009. /*for*/
  1010.  
  1011.     echo( '\n' );
  1012. }
  1013.  
  1014. /*************************************************************************/
  1015.  
  1016. void prt_hdr()
  1017. {
  1018.     if (pagno++) { echo('\n'); echo(FF); }
  1019.     if (o_flg) {
  1020.         if (fprintf(f_lst_fil,
  1021.             "XC ... 'C' Concordance Utility   %-20s       Page %d",
  1022.             gbl_fil,pagno) == ERROR) lst_err();
  1023.         }
  1024.     else printf("XC ... 'C' Concordance Utility   %-20s       Page %d",
  1025.         gbl_fil,pagno);
  1026.     echo('\n');  paglin = 3;  nl();
  1027. }
  1028.  
  1029. /*************************************************************************/
  1030.  
  1031. void nl()
  1032. {
  1033.     echo('\n');
  1034.     if (++paglin >= LINES_PER_PAGE) prt_hdr();
  1035.     else if (!prt_ref) {
  1036.         if (o_flg) {
  1037.             if (fprintf(f_lst_fil,"     ") == ERROR)
  1038.                 lst_err();
  1039.             ++linum;
  1040.             ++edtnum;
  1041.         }
  1042.         else printf("%-4d %4d: ",++linum,++edtnum);
  1043.         if (o_flg) {
  1044.             if (linum % 60 == 1) printf("\n<%d> ",linum);
  1045.             else {
  1046.                 printf(".");
  1047.                 fflush(stdout);
  1048.             }
  1049.         }
  1050.     }
  1051.     return;
  1052. }
  1053.  
  1054.  
  1055. /***************************************/
  1056. 
  1057.