home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_300 / 344_02 / xc3.c < prev    next >
C/C++ Source or Header  |  1990-12-11  |  38KB  |  1,324 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:  -c                = Recognize Mapper C keywords
  135.                 -i [pathname]     = Enable file inclusion
  136.                 -l                = Generate listing only
  137.                 -m                = Recognize Microsoft-specific keywords
  138.                 -n                = Allow nested comments
  139.                 -o <filename>     = Write output to named file
  140.                 -p                = Exclude page breaks
  141.                 -r                = Cross-ref reserved words
  142.                 -w <width>        = Maximum listing width
  143.                 -x                = Exclude default include file dir's
  144.  
  145.         Note:   For the -i option, the pathname is optional.  The -i flag may
  146.                 be given multiple times, each time with a pathname. These
  147.                 pathnames are saved, building a list of places to search for
  148.                 include files.  If no list is given the standard places will
  149.                 be used.  If the -i option flag is not used, includes will not
  150.                 be cross-referenced.
  151.  
  152. ***********************************************************/
  153.  
  154. /* Compiler specific stuff */
  155.  
  156. #define LINT_ARGS
  157. #include <stdio.h>
  158. #include <stdlib.h>
  159. #include <ctype.h>
  160. #include <alloc.h>         /* was malloc.h dnh 7/21/89 */
  161. #include <string.h>
  162. #include <dos.h>           /* DNH 10/16/89 */
  163. #undef LINT_ARGS
  164.  
  165. /* end compiler specific section */
  166.  
  167. /* Function declarations for xc's routines. */
  168.  
  169. #include "xc2.h"
  170.  
  171. #ifndef TRUE
  172. #define TRUE        1
  173. #define FALSE       0
  174. #endif
  175.  
  176. #define INDENT      15
  177. #define DUMMY       0       /* a dummy integer value */
  178. #define ERROR       -1
  179. #define MAX_REF     5       /* maximum refs per ref-block */
  180. #define MAX_LEN     32      /* maximum identifier length */
  181. /* was 20 dnh 7/21/89 - deeper error !! */
  182. #define MAX_WRD     749     /* maximum number of identifiers */
  183. #define MAX_ALPHA   53      /* maximum alpha chain heads */
  184. #define REFS_PER_LINE 10    /* maximum refs per line */
  185. #define LINES_PER_PAGE 57
  186. #define MAXCOL      78      /* default max column number for listing line */
  187. #define MINCOL      30      /* minimum value for -w option */
  188. #define PATHLEN     128     /* maximum pathname length in chars. */
  189. #define FF          0x0C    /* formfeed */
  190.  
  191. /*      typedef union {
  192.     int cnt;
  193.     struct rf_blk *pnext;
  194. } cnt;               */
  195.  
  196. struct rf_blk {
  197.    int           ref_item[MAX_REF];
  198.    int           ref_cnt;
  199.    struct rf_blk *pnext;
  200. } 
  201. onerf;
  202.  
  203. struct id_blk {
  204.    char id_name[MAX_LEN];
  205.    struct id_blk *alpha_lnk;
  206.    struct rf_blk *top_lnk;
  207.    struct rf_blk *lst_lnk;
  208. } 
  209. oneid;
  210.  
  211. struct id_blk *id_vector[MAX_WRD];
  212.  
  213. struct alpha_hdr {
  214.    struct id_blk *alpha_top;
  215.    struct id_blk *alpha_lst;
  216. };
  217.  
  218. struct alpha_hdr alpha_vector[MAX_ALPHA];
  219.  
  220. struct date today;
  221.  
  222. struct time now;
  223.  
  224. int lin_refs = (MAXCOL-30)/5; /* max refs on a printed line */
  225. int linum;              /* line number */
  226. int edtnum = 0;         /* edit line number */
  227. int fil_cnt = 0;        /* active file index */
  228. int wrd_cnt = 0;        /* token count */
  229. int pagno = 0;          /* page number */
  230. int id_cnt = 0;         /* number of unique identifiers */
  231. int rhsh_cnt = 0;       /* number of conflict hits */
  232. int filevl = 0;         /* file level  */
  233. int paglin = 0;         /* page line counter */
  234. int maxcol = MAXCOL;    /* maximum right column for listing line */
  235. int prt_ref = FALSE;
  236. char act_fil[PATHLEN];
  237. char lst_fil[PATHLEN];
  238. char gbl_fil[PATHLEN];
  239. char gbl_trc[PATHLEN];
  240. char i_path[PATHLEN];
  241. FILE *f_lst_fil;
  242. int c_flg = FALSE;
  243. int i_flg = FALSE;
  244. int l_flg = FALSE;
  245. int m_flg = FALSE;
  246. int n_flg = FALSE;
  247. int o_flg = FALSE;
  248. int p_flg = FALSE;
  249. int r_flg = FALSE;
  250. int x_flg = FALSE;
  251. int in_refs = 0;
  252.  
  253. /*************************************************************************/
  254.  
  255. int main(p_argc, p_argv)
  256. int p_argc;
  257. char **p_argv;
  258. {
  259.    char *arg, **argv;
  260.    int argc, i;
  261.    FILE *f;
  262.  
  263. #ifdef REARGV
  264.    reargv (&p_argc, &p_argv);
  265. #endif
  266.  
  267.    argc = p_argc;  
  268.    argv = p_argv;
  269.    if (argc < 2) 
  270.       use_err();
  271.    while (--argc)
  272.       if (*(arg = *++argv) == '-')
  273.          switch (*++arg) {
  274.  
  275.          case 'c':
  276.          case 'C':
  277.             c_flg++;
  278.             break;
  279.  
  280.          case 'i':
  281.          case 'I':
  282.             i_flg = TRUE;
  283.             if (argc > 1 && **(argv + 1) != '-' && **(argv + 1)) {
  284.                if (strlen(i_path)) {
  285.                   strcat(i_path,";");
  286.                   strcat(i_path,*++argv);
  287.                } 
  288.                else
  289.                   strcpy(i_path,*++argv);
  290.             } 
  291.             else
  292.                i_path[0] = '\0';
  293.             if (i_path[0] == '-')
  294.                use_err();
  295.             break;
  296.  
  297.          case 'l':
  298.          case 'L':
  299.             l_flg++;
  300.             break;
  301.  
  302.          case 'm':
  303.          case 'M':
  304.             m_flg++;
  305.             break;
  306.  
  307.          case 'n':
  308.          case 'N':
  309.             n_flg++;
  310.             break;
  311.  
  312.          case 'o':
  313.          case 'O':
  314.             o_flg++;
  315.             if (!--argc)
  316.                use_err();
  317.             strcpy(lst_fil,*++argv);
  318.             if (lst_fil[0] == '-')
  319.                use_err();
  320.             break;
  321.  
  322.          case 'p':
  323.          case 'P':
  324.             p_flg++;
  325.             break;
  326.  
  327.          case 'r':
  328.          case 'R':
  329.             r_flg++;
  330.             break;
  331.  
  332.          case 'w':
  333.          case 'W':
  334.             if (!--argc)
  335.                use_err();
  336.             if ((i = atoi(*++argv)) <= MINCOL || i >= 255)
  337.                use_err();
  338.             maxcol = i;
  339.             lin_refs = (maxcol-30)/5;
  340.             break;
  341.  
  342.          case 'x':
  343.          case 'X':
  344.             x_flg++;
  345.             break;
  346.  
  347.          default:
  348.             use_err();
  349.             break;
  350.          }
  351.  
  352.    getdate(&today);
  353.    gettime(&now);
  354.    if (o_flg) {
  355.       if (!(f_lst_fil = fopen(lst_fil,"w"))) {
  356.          printf("ERROR: Unable to create list file - %s\n",lst_fil);
  357.          exit(0);
  358.       }
  359.       printf("XC ... 'C' Concordance Utility  v1.0\n\n");
  360.    }
  361.    for (linum = 0;  linum < MAX_WRD;  ++linum)
  362.       id_vector[linum] = NULL;
  363.    for (linum = 0; linum < MAX_ALPHA; ++linum)
  364.       alpha_vector[linum].alpha_top = alpha_vector[linum].alpha_lst = NULL;
  365.    linum = 0;
  366.    while (--p_argc && **++p_argv != '-') {
  367.       strcpy(gbl_fil,*p_argv);  
  368.       strcpy(act_fil,*p_argv);
  369.       i = 0;
  370.       while ((gbl_fil[i] != '.') & (gbl_fil[i] != 0x00)) {
  371.          gbl_trc[i] = gbl_fil[i];
  372.          i++;
  373.       }
  374.       gbl_trc[i] = 0x00;
  375.       if (!(f = fopen(gbl_fil,"r")))
  376.          printf("\nERROR: Unable to open input file: %s\n",gbl_fil);
  377.       else
  378.          proc_file(f,DUMMY);
  379.    }
  380.    if (!l_flg) {
  381.       prnt_tbl();
  382.       printf("\nAllowable Symbols: %d\n",MAX_WRD);
  383.       printf("   Unique Symbols: %d\n",id_cnt);
  384.    }
  385.    if (o_flg) {
  386.       fprintf(f_lst_fil,"     %d symbols\n",id_cnt);
  387.       echo(FF);
  388.       fclose(f_lst_fil);
  389.    }
  390.    return 0;
  391. }
  392.  
  393. /*************************************************************************/
  394.  
  395. void lst_err()
  396. {
  397.    printf("\nERROR: Write error on list output file - %s\n", lst_fil);
  398.    exit(0);
  399. }
  400.  
  401. /*************************************************************************/
  402.  
  403. void use_err()
  404. {
  405.    printf("\nERROR: Invalid parameter specification\n\n");
  406.    printf("Usage: xc <filename>... <flag(s)>\n\n");
  407.    printf("Flags: -c                = Recognize Mapper C keywords\n");
  408.    printf("       -i <opt. path(s)> = Enable file inclusion\n");
  409.    printf("       -l                = Generate listing only\n");
  410.    printf("       -m                = Recognize Microsoft keywords\n");
  411.    printf("       -n                = Allow nested comments\n");
  412.    printf("       -o <outfile>      = Write output to named file\n");
  413.    printf("       -p                = Exclude page headers\n");
  414.    printf("       -r                = Cross-reference reserved words\n");
  415.    printf("       -w width          = Width of output page; default=78\n");
  416.    printf("       -x                = Exclude default include file dir's\n");
  417.    printf("Flags must follow all input file names");
  418.    exit(0);
  419. }
  420.  
  421. /*************************************************************************/
  422.  
  423. int proc_file(infile,incnum)
  424. FILE *infile;
  425. int incnum;         /* prev. included line number (return to caller) */
  426. {
  427.    char token[MAX_LEN];    /* token buffer */
  428.    char cur_fil[PATHLEN];  /* name of file we are currently processing */
  429.    int eof_flg;            /* end-of-file indicator */
  430.    int tok_len;            /* token length */
  431.    char nl_flg;            /* newline flag */
  432.    FILE *f, *get_include_file();
  433.  
  434.    edtnum=0;
  435.    if (!filevl++)
  436.       prt_hdr();
  437.    else
  438.       nl();
  439.    eof_flg = FALSE;
  440.    do {
  441.       nl_flg = 0;
  442.       if (get_token(infile,token,&tok_len,&eof_flg,0)) {
  443.          if (token[tok_len] == '\n') { /* fix for doing nl() early */
  444.             token[tok_len] = '\0';
  445.             nl_flg = 1;
  446.          }
  447.          if (chk_token(token))
  448.             if (!strcmp(token,"#include")) {
  449.                strcpy(cur_fil,act_fil);
  450.                if (f = get_include_file(infile))
  451.                   edtnum = proc_file(f,edtnum);
  452.                else
  453.                   if (i_flg)
  454.                      printf("\nERROR: Unable to open input file: %s\n", act_fil);
  455.                strcpy(act_fil,cur_fil);
  456.             } 
  457.             else
  458.                if (nl_flg)
  459.                   put_token(token,linum - 1);
  460.                else
  461.                   put_token(token,linum);
  462.       }
  463.    } 
  464.    while (!eof_flg);
  465.  
  466.    --filevl;
  467.    fclose(infile);
  468.    return incnum;
  469. }
  470.  
  471. /*****************************************************************************
  472.  *  Reads the include filename from the source file and saves it into a global
  473.  *  variable, act_fil[].  It is assumed that the include statement gives the
  474.  *  filename only, without any drive specifier or path, as in the previous
  475.  *  version of XC.  Calls open_include_file() to flesh out the filename into a
  476.  *  full pathname and actually get the file opened.
  477.  */
  478.  
  479. FILE *get_include_file(infile)
  480. FILE *infile;
  481. {
  482.    char c, term, *p;
  483.    FILE *open_include_file();
  484.  
  485.    p = act_fil;
  486.  
  487.    while ((term = getc(infile)) == ' ')
  488.       echo(term);
  489.    echo(term);
  490.    if (term == '<')
  491.       term = '>';    /* terminator is > or " */
  492.    if ((term != '>') && (term != '"')) {
  493.       printf("Error scanning #INCLUDE fileid: %c\n",term);
  494.       exit(1);
  495.    }
  496.  
  497.    do {
  498.       if ((c = getc(infile)) != ' ')
  499.          *p++ = c;
  500.       echo(c);
  501.    } 
  502.    while (c != term);
  503.    *--p = '\0';
  504.  
  505.    if (i_flg)
  506.       return open_include_file(act_fil,term);
  507.    else
  508.       return NULL;
  509. }
  510.  
  511. /*************************************************************************/
  512.  
  513. FILE *open_include_file(filenam,delim)
  514. char *filenam, delim;
  515. {
  516.    char fullnam[PATHLEN];
  517.    char includevar[4 * PATHLEN];
  518.    char *temp1, *temp2;
  519.    int include_len;
  520.    FILE *f;
  521.  
  522.    /*
  523.     *  First, if delimited by quotes and file exists in current directory, return
  524.     *  a file handle for the opened file.  Next, if a complete pathname
  525.     *  specified, return a file handle for the opened file or NULL if the file
  526.     *  cannot be found.
  527.     */
  528.  
  529.    if (delim == '"' && (f = fopen(filenam,"r")))
  530.       return f;
  531.    if (filenam[1] == ':' || filenam[0] == '\\' || filenam[0] == '/')
  532.       return fopen(filenam,"r");
  533.  
  534.    /*
  535.     *  Next, if a non-null pathname was provided with the -i switch, check in
  536.     *  that place.  Finally, check in the places specified by the INCLUDE
  537.     *  environment variable unless the -x switch was used.
  538.     */
  539.  
  540.    if (i_path[0] || (temp1 = getenv("INCLUDE"))) {
  541.       strcpy(includevar,";");
  542.       if (i_path[0]) {
  543.          strcat(includevar,i_path);
  544.          strcat(includevar,";");
  545.       }
  546.       if (!x_flg)
  547.          strcat(includevar,temp1);
  548.       include_len = strlen(temp2 = includevar);
  549.  
  550.       /*
  551.        *  Break up the semicolon-delimited list of directories into
  552.        *  null-terminated strings and check each of them.
  553.        */
  554.  
  555.       while (include_len > 0) {
  556.          for (temp1 = temp2;  *temp2 != ';' && *temp2;  ++temp2)
  557.             --include_len;
  558.          if (*temp2 == ';') {
  559.             *temp2++ = '\0';
  560.             --include_len;
  561.          }
  562.          strcpy(fullnam,temp1);
  563.          strcat(fullnam,"\\");
  564.          strcat(fullnam,filenam);
  565.          if (f = fopen(fullnam,"r"))
  566.             return f;
  567.       }
  568.    }
  569.    return NULL;
  570. }
  571.  
  572. /*************************************************************************/
  573.  
  574. void echo(c)
  575. char c;
  576. {
  577.    static int col = INDENT;
  578.    int i;
  579.  
  580.    if (!p_flg | (p_flg & (c != FF)))
  581.       echochar(c);
  582.    if (c == '\n')
  583.       col = INDENT;
  584.    else
  585.       if (++col > (maxcol + 1)) {
  586.          col = INDENT;
  587.          ++paglin;
  588.          echochar('\n');
  589.          for (i = 1;  i <= INDENT;  ++i)
  590.             echochar(' ');
  591.       }
  592. }
  593. /************************************************************/
  594. void echochar(c)
  595. char c;
  596. {
  597.    if (o_flg) {
  598.       if (fprintf(f_lst_fil,"%c",c) == ERROR)
  599.          lst_err();
  600.    } 
  601.    else
  602.       printf("%c",c);
  603. }
  604.  
  605. /*************************************************************************/
  606.  
  607. int get_token(infile,g_token,g_toklen,g_eoflg,g_flg)
  608. FILE *infile;
  609. char *g_token;
  610. int *g_toklen, *g_eoflg, g_flg;
  611. {
  612.  
  613.    /*
  614.            'getoken' returns the next valid identifier or
  615.            reserved word from a given file along with the
  616.            character length of the token and an end-of-file
  617.            indicator
  618.    */
  619.  
  620.    int c;
  621.    char *h_token, tmpchr;
  622.  
  623.    h_token = g_token;
  624.  
  625. gtk:
  626.    *g_toklen = 0;
  627.    g_token = h_token;
  628.  
  629.    /*
  630.            Scan and discard any characters until an alphabetic or
  631.            '_' (underscore) character is encountered or an end-of-file
  632.            condition occurs
  633.    */
  634.  
  635.    while ((!isalpha(*g_token = rdchr(infile,g_eoflg,g_flg)))
  636.        && !*g_eoflg && *g_token != '_' && *g_token != '0'
  637.        && *g_token != '#');
  638.  
  639.    if (*g_eoflg)
  640.       return FALSE;
  641.    *g_toklen += 1;
  642.  
  643.    /*
  644.            Scan and collect identified alpanumeric token until
  645.            a non-alphanumeric character is encountered or and
  646.            end-of-file condition occurs
  647.    */
  648.  
  649.    if (g_flg)
  650.       tmpchr = '.';
  651.    else
  652.       tmpchr = '_';
  653.    while ((isalpha(c = rdchr(infile,g_eoflg,g_flg))
  654.        || isdigit(c) || c == '_' || c == tmpchr) && !*g_eoflg)
  655.       if (*g_toklen < MAX_LEN) {
  656.          *++g_token = c;
  657.          ++*g_toklen;
  658.       } 
  659.       else
  660.          *g_token = NULL;
  661.  
  662.    /*
  663.            Check to see if a numeric hex or octal constant has
  664.            been encountered ... if so dump it and try again
  665.    */
  666.  
  667.    if (*h_token == '0')
  668.       goto gtk;
  669.  
  670.    /*
  671.            Tack a NUL character onto the end of the token
  672.    */
  673.    if ((*h_token != '#') && (c == '\n'))
  674.       *++g_token = c;
  675.    else
  676.       *++g_token = '\0';
  677.  
  678.    /*
  679.            Screen out all #token strings except #include
  680.    */
  681.  
  682.    if (*h_token == '#' && strcmp(h_token,"#include"))
  683.       goto gtk;
  684.  
  685.    return(TRUE);
  686. }
  687.  
  688. /*************************************************************************/
  689.  
  690. int fil_chr(infile,f_eof)
  691. FILE *infile;
  692. int *f_eof;
  693. {
  694.    int fc;
  695.  
  696.    if ((fc = getc(infile)) == EOF)
  697.       if (ferror (infile)) {
  698.          printf("\nERROR: Error while processing input file - %s\n",
  699.          act_fil);
  700.          exit(0);
  701.       } 
  702.       else
  703.          if (feof(infile)) {
  704.             *f_eof = TRUE;
  705.             fc = NULL;
  706.          }
  707.  
  708.    return fc;
  709. }
  710.  
  711. /*************************************************************************/
  712.  
  713. int rdchr(infile,r_eoflg,rd_flg)
  714. FILE *infile;
  715. int *r_eoflg, rd_flg;
  716. {
  717.  
  718.    /*
  719.            'rdchr' returns the next valid character in a file
  720.            and an end-of-file indicator. A valid character is
  721.            defined as any which does not appear in either a
  722.            commented or a quoted string ... 'rdchr' will correctly
  723.            handle comment tokens which appear within a quoted
  724.            string
  725.    */
  726.  
  727.    int c;
  728.    int q_flg;          /* double quoted string flag */
  729.    int q1_flg;         /* single quoted string flag */
  730.    int cs_flg;         /* comment start flag */
  731.    int ce_flg;         /* comment end flag */
  732.    int c_cnt;          /* comment nesting level */
  733.    int t_flg;          /* transparency flag */
  734.  
  735.    q_flg = q1_flg = cs_flg = ce_flg = t_flg = FALSE;
  736.    c_cnt  = 0;
  737.  
  738. rch:
  739.  
  740.    /*
  741.            Fetch character from file
  742.    */
  743.  
  744.    c = fil_chr(infile,r_eoflg);
  745.    if (*r_eoflg)
  746.       return c;        /* EOF encountered */
  747.    if (c == '\n')
  748.       nl();
  749.    else
  750.       echo(c);
  751.  
  752.    if (rd_flg)
  753.       return c;
  754.  
  755.    if (t_flg) {
  756.       t_flg = !t_flg;
  757.       goto rch;
  758.    }
  759.    if (c == '\\') {
  760.       t_flg = TRUE;
  761.       goto rch;
  762.    }
  763.  
  764.    /*
  765.            If the character is not part of a quoted string
  766.            check for and process commented strings...
  767.            nested comments are handled correctly but unbalanced
  768.            comments are not ... the assumption is made that
  769.            the syntax of the program being xref'd is correct.
  770.      NOTE: Now nested comment support is optional. The source for XC
  771.            formerly contained an un-matched begin comment. If nested
  772.            comment support is used to cross-reference the xc source
  773.            the program produces an incorrect cross-reference, yet
  774.            the Microsoft compiler compiles it correctly, as it
  775.            should. Nested comments are a non-standard extension to
  776.            the language. Therefore, nested comment support has been made
  777.            optional.
  778.            See usage information in comment at top of file.
  779.    */
  780.  
  781.    if (!q_flg && !q1_flg) {
  782.       if (c == '*' && c_cnt && !cs_flg) {
  783.          ce_flg = TRUE;
  784.          goto rch;
  785.       }
  786.       if (c == '/' && ce_flg) {
  787.          c_cnt -= 1;
  788.          ce_flg = FALSE;
  789.          goto rch;
  790.       }
  791.       ce_flg = FALSE;
  792.       if (c == '/') {
  793.          cs_flg = TRUE;
  794.          goto rch;
  795.       }
  796.       if (c == '*' && cs_flg) {
  797.          c_cnt = (!n_flg) ? TRUE : c_cnt + 1; /* optional nested comments */
  798.          cs_flg = FALSE;
  799.          goto rch;
  800.       }
  801.       cs_flg = FALSE;
  802.       if (c_cnt)
  803.          goto rch;
  804.    }
  805.  
  806.    /*
  807.            Check for and process quoted strings
  808.    */
  809.  
  810.    if (c == '"' && !q1_flg) {
  811.       q_flg = !q_flg;        /* toggle quote flag */
  812.       goto rch;
  813.    }
  814.    if (q_flg)
  815.       goto rch;
  816.  
  817.    if (c == '\'') {
  818.       q1_flg = !q1_flg;       /* toggle quote flag */
  819.       goto rch;
  820.    }
  821.    if (q1_flg)
  822.       goto rch;
  823.  
  824.    /*
  825.            Valid character ... return to caller
  826.    */
  827.  
  828.    return c;
  829. }
  830.  
  831. /*************************************************************************/
  832.  
  833. int chk_token(c_token)
  834. char *c_token;
  835. {
  836.    char u_token[MAX_LEN];
  837.    int i;
  838.  
  839.    if (r_flg)
  840.       return TRUE;
  841.    i = 0;
  842.    do
  843.        u_token[i] = toupper(c_token[i]);
  844.    while (c_token[i++] != NULL);
  845.  
  846.    /*
  847.     *  Support for the Microsoft extended keywords.
  848.     */
  849.  
  850.    if (m_flg)
  851.       switch (u_token[0]) {
  852.       case 'C':
  853.          if (!strcmp(u_token,"CDECL")) 
  854.             return FALSE;
  855.          break;
  856.       case 'F':
  857.          if (!strcmp(u_token,"FORTRAN")) 
  858.             return FALSE;
  859.          if (!strcmp(u_token,"FAR")) 
  860.             return FALSE;
  861.          break;
  862.       case 'H':
  863.          if (!strcmp(u_token,"HUGE")) 
  864.             return FALSE;
  865.          break;
  866.       case 'N':
  867.          if (!strcmp(u_token,"NEAR")) 
  868.             return FALSE;
  869.          break;
  870.       case 'P':
  871.          if (!strcmp(u_token,"PASCAL")) 
  872.             return FALSE;
  873.          break;
  874.       case '_':
  875.          if (!strcmp(u_token,"_CDECL")) 
  876.             return FALSE;
  877.          if (!strcmp(u_token,"_FAR")) 
  878.             return FALSE;
  879.          break;
  880.       }
  881.  
  882.    /*
  883.     *  Support for the Mapper C keywords.
  884.     */
  885.  
  886.    if (c_flg)
  887.       switch (u_token[0]) {
  888.       case 'I':
  889.          if (!strcmp(u_token,"INTERNAL_NUMBER")) 
  890.             return FALSE;    
  891.          break;
  892.       case 'K':
  893.          if (!strcmp(u_token,"KONST")) 
  894.             return FALSE;    
  895.          break;
  896.       case 'L':
  897.          if (!strcmp(u_token,"LINT")) 
  898.             return FALSE;
  899.          if (!strcmp(u_token,"LO8")) 
  900.             return FALSE;
  901.          break;
  902.       case 'M':
  903.          if (!strcmp(u_token,"MO8")) 
  904.             return FALSE;
  905.          break;
  906.       case 'N':
  907.          if (!strcmp(u_token,"NORET")) 
  908.             return FALSE;
  909.          break;
  910.       case 'S':
  911.          if (!strcmp(u_token,"SINT")) 
  912.             return FALSE;
  913.          break;
  914.       case 'U':
  915.          if (!strcmp(u_token,"ULINT")) 
  916.             return FALSE;
  917.          if (!strcmp(u_token,"USINT")) 
  918.             return FALSE;
  919.          break;
  920.       }
  921.  
  922.    /*
  923.     *  Standard keyword support.
  924.     */
  925.  
  926.    switch (u_token[0]) {
  927.    case 'A':
  928.       if (!strcmp(u_token,"AUTO")) 
  929.          return FALSE;
  930.       break;
  931.    case 'B':
  932.       if (!strcmp(u_token,"BREAK")) 
  933.          return FALSE;
  934.       break;
  935.    case 'C':
  936.       if (!strcmp(u_token,"CHAR")) 
  937.          return  FALSE;
  938.       if (!strcmp(u_token,"CONTINUE")) 
  939.          return  FALSE;
  940.       if (!strcmp(u_token,"CONST")) 
  941.          return  FALSE;
  942.       if (!strcmp(u_token,"CASE")) 
  943.          return  FALSE;
  944.       break;
  945.    case 'D':
  946.       if (!strcmp(u_token,"DOUBLE")) 
  947.          return FALSE;
  948.       if (!strcmp(u_token,"DO")) 
  949.          return FALSE;
  950.       if (!strcmp(u_token,"DEFAULT")) 
  951.          return FALSE;
  952.       break;
  953.    case 'E':
  954.       if (!strcmp(u_token,"EXTERN")) 
  955.          return FALSE;
  956.       if (!strcmp(u_token,"ELSE")) 
  957.          return FALSE;
  958.       if (!strcmp(u_token,"ENUM")) 
  959.          return FALSE;
  960.       break;
  961.    case 'F':
  962.       if (!strcmp(u_token,"FLOAT")) 
  963.          return FALSE;
  964.       if (!strcmp(u_token,"FOR")) 
  965.          return FALSE;
  966.       break;
  967.    case 'G':
  968.       if (!strcmp(u_token,"GOTO")) 
  969.          return FALSE;
  970.       break;
  971.    case 'I':
  972.       if (!strcmp(u_token,"INT")) 
  973.          return FALSE;
  974.       if (!strcmp(u_token,"IF")) 
  975.          return FALSE;
  976.       break;
  977.    case 'L':
  978.       if (!strcmp(u_token,"LONG")) 
  979.          return FALSE;
  980.       break;
  981.    case 'R':
  982.       if (!strcmp(u_token,"RETURN")) 
  983.          return FALSE;
  984.       if (!strcmp(u_token,"REGISTER")) 
  985.          return FALSE;
  986.       break;
  987.    case 'S':
  988.       if (!strcmp(u_token,"STRUCT")) 
  989.          return FALSE;
  990.       if (!strcmp(u_token,"SHORT")) 
  991.          return FALSE;
  992.       if (!strcmp(u_token,"STATIC")) 
  993.          return FALSE;
  994.       if (!strcmp(u_token,"SIZEOF")) 
  995.          return FALSE;
  996.       if (!strcmp(u_token,"SWITCH")) 
  997.          return FALSE;
  998.       if (!strcmp(u_token,"SIGNED")) 
  999.          return FALSE;
  1000.       break;
  1001.    case 'T':
  1002.       if (!strcmp(u_token,"TYPEDEF")) 
  1003.          return FALSE;
  1004.       break;
  1005.    case 'U':
  1006.       if (!strcmp(u_token,"UNION")) 
  1007.          return FALSE;
  1008.       if (!strcmp(u_token,"UNSIGNED")) 
  1009.          return FALSE;
  1010.       break;
  1011.    case 'V':
  1012.       if (!strcmp(u_token,"VOID")) 
  1013.          return FALSE;
  1014.       if (!strcmp(u_token,"VOLATILE")) 
  1015.          return FALSE;
  1016.       break;
  1017.    case 'W':
  1018.       if (!strcmp(u_token,"WHILE")) 
  1019.          return FALSE;
  1020.       break;
  1021.    }
  1022.    return TRUE;
  1023. }
  1024.  
  1025. /*************************************************************************/
  1026.  
  1027. /*
  1028.    Install parsed token and line reference in linked structure
  1029. */
  1030.  
  1031. void put_token(p_token,p_ref)
  1032. char *p_token;
  1033. int p_ref;
  1034. {
  1035.    int hsh_index, i, j, d, found;
  1036.    struct id_blk *idptr;
  1037.    struct id_blk *alloc_id();
  1038.    struct rf_blk *alloc_rf(), *add_rf();
  1039.  
  1040.    if (l_flg)
  1041.       return;
  1042.    j=0;
  1043.    for (i = 0;  p_token[i] != NULL;  ++i)      /* Hashing algorithm is far */
  1044.       j = j * 10 + p_token[i];                /* from optimal but is      */
  1045.    /* adequate for a memory-   */
  1046.    hsh_index = abs(j) % MAX_WRD;               /* bound index vector!      */
  1047.    found = FALSE;
  1048.    d = 1;
  1049.    do {
  1050.       idptr = id_vector[hsh_index];
  1051.       if (idptr == NULL) {
  1052.          id_cnt++;
  1053.          idptr = id_vector[hsh_index] = alloc_id(p_token);
  1054.          chain_alpha(idptr,p_token);
  1055.          idptr->top_lnk = idptr->lst_lnk = alloc_rf(p_ref);
  1056.          found = TRUE;
  1057.       } 
  1058.       else
  1059.          if (!strcmp(p_token,idptr->id_name)) {
  1060.             idptr->lst_lnk = add_rf(idptr->lst_lnk,p_ref);
  1061.             found = TRUE;
  1062.          } 
  1063.          else {
  1064.             hsh_index += d;  
  1065.             d += 2;  
  1066.             rhsh_cnt++;
  1067.             if (hsh_index >= MAX_WRD)
  1068.                hsh_index -= MAX_WRD;
  1069.             if (d == MAX_WRD) {
  1070.                printf("\nERROR: Symbol table overflow\n");
  1071.                exit(0);
  1072.             }
  1073.          }
  1074.    } 
  1075.    while (!found);
  1076. }
  1077.  
  1078. /*************************************************************************/
  1079.  
  1080. void chain_alpha(ca_ptr,ca_token)
  1081. struct id_blk *ca_ptr;
  1082. char  *ca_token;
  1083. {
  1084.    char c;
  1085.    struct id_blk *cur_ptr;
  1086.    struct id_blk *lst_ptr;
  1087.  
  1088.    if ((c = ca_token[0]) == '_')
  1089.       c = 0;
  1090.    else
  1091.       if (isupper(c))
  1092.          c = 1 + ((c - 'A') * 2);
  1093.       else
  1094.          c = 2 + ((c - 'a') * 2);
  1095.  
  1096.    if (!alpha_vector[c].alpha_top) {
  1097.       alpha_vector[c].alpha_top = alpha_vector[c].alpha_lst = ca_ptr;
  1098.       ca_ptr->alpha_lnk = NULL;
  1099.       return;
  1100.    }
  1101.  
  1102.    /*
  1103.        check to see if new id_blk should be inserted between
  1104.        the alpha_vector header block and the first id_blk in
  1105.        the current alpha chain
  1106.    */
  1107.  
  1108.    if (strcmp(alpha_vector[c].alpha_top->id_name,ca_token) > 0) {
  1109.       ca_ptr->alpha_lnk=alpha_vector[c].alpha_top;
  1110.       alpha_vector[c].alpha_top=ca_ptr;
  1111.       return;
  1112.    }
  1113.    if (strcmp(alpha_vector[c].alpha_lst->id_name,ca_token) < 0) {
  1114.       alpha_vector[c].alpha_lst->alpha_lnk = ca_ptr;
  1115.       ca_ptr->alpha_lnk = NULL;
  1116.       alpha_vector[c].alpha_lst=ca_ptr;
  1117.       return;
  1118.    }
  1119.    cur_ptr = alpha_vector[c].alpha_top;
  1120.    while (strcmp(cur_ptr->id_name,ca_token) < 0) {
  1121.       lst_ptr = cur_ptr;
  1122.       cur_ptr = lst_ptr->alpha_lnk;
  1123.    }
  1124.    lst_ptr->alpha_lnk = ca_ptr;
  1125.    ca_ptr->alpha_lnk = cur_ptr;
  1126.    return;
  1127. }
  1128.  
  1129. /*************************************************************************/
  1130.  
  1131. struct id_blk *alloc_id(aid_token)
  1132. char *aid_token;
  1133. {
  1134.    int ai;
  1135.    struct id_blk *aid_ptr;
  1136.  
  1137.    if (!(aid_ptr = (struct id_blk *)malloc(sizeof(struct id_blk)))) {
  1138.       printf("\nERROR: Unable to allocate identifier block\n");
  1139.       exit(0);
  1140.    }
  1141.    ai = 0;
  1142.    do
  1143.        aid_ptr->id_name[ai] = aid_token[ai];
  1144.    while (aid_token[ai++] != NULL);
  1145.    return aid_ptr;
  1146. }
  1147.  
  1148. /*************************************************************************/
  1149.  
  1150. struct rf_blk *alloc_rf(arf_ref)
  1151. int arf_ref;
  1152. {
  1153.    int ri;
  1154.    struct rf_blk *arf_ptr;
  1155.  
  1156.    if (!(arf_ptr = (struct rf_blk *)malloc(sizeof(struct rf_blk)))) {
  1157.       printf("\nERROR: Unable to allocate reference block\n");
  1158.       exit(0);
  1159.    }
  1160.    arf_ptr->ref_item[0] = arf_ref;
  1161.    arf_ptr->ref_cnt = 1;
  1162.    for (ri = 1;  ri < MAX_REF;  ++ri)
  1163.       arf_ptr->ref_item[ri] = NULL;
  1164.    arf_ptr->pnext = NULL;
  1165.    in_refs++;
  1166.    return arf_ptr;
  1167. }
  1168.  
  1169. /*************************************************************************/
  1170.  
  1171. struct rf_blk *add_rf(adr_ptr,adr_ref)
  1172. struct rf_blk *adr_ptr;
  1173. int adr_ref;
  1174. {
  1175.    struct rf_blk *tmp_ptr;
  1176.  
  1177.    tmp_ptr = adr_ptr;
  1178.    if (adr_ptr->ref_cnt == MAX_REF) {
  1179.       tmp_ptr = alloc_rf(adr_ref);
  1180.       adr_ptr->pnext = tmp_ptr;
  1181.       in_refs--;
  1182.    } 
  1183.    else
  1184.       adr_ptr->ref_item[adr_ptr->ref_cnt++] = adr_ref;
  1185.    in_refs++;
  1186.    return tmp_ptr;
  1187. }
  1188.  
  1189. /*************************************************************************/
  1190.  
  1191. void prnt_tbl()
  1192. {
  1193.    int prf_cnt, pti, pref, lin_cnt, refs=0;
  1194.    struct id_blk *pid_ptr;
  1195.    struct rf_blk *ptb_ptr;
  1196.  
  1197.    prt_ref = TRUE;
  1198.    prt_hdr();
  1199.    for (pti = 0;  pti < MAX_ALPHA;  ++pti) {
  1200.       if (pid_ptr = alpha_vector[pti].alpha_top) {
  1201.          do {
  1202.             if (o_flg) {
  1203.                if (fprintf(f_lst_fil,"     %-20.19s:",pid_ptr->id_name)
  1204.                    == ERROR) lst_err();
  1205.             } 
  1206.             else
  1207.                printf("%-20.19s:",pid_ptr->id_name);
  1208.             ptb_ptr = pid_ptr->top_lnk;
  1209.             lin_cnt = -1;
  1210.             prf_cnt = 0;
  1211.             do {
  1212.                if (prf_cnt == MAX_REF) {
  1213.                   prf_cnt = 0;
  1214.                   ptb_ptr = (struct rf_blk *)ptb_ptr->pnext;
  1215.                }
  1216.                if (ptb_ptr) {
  1217.                   if (pref = ptb_ptr->ref_item[prf_cnt++]) {
  1218.                      refs += 1;
  1219.                      if (++lin_cnt == lin_refs) {   /* was REFS_PER_LINE dnh 7/21/89 */
  1220.                         nl();
  1221.                         if (o_flg) {
  1222.                            if (fprintf(f_lst_fil,
  1223.                            "                          ") == ERROR)
  1224.                               lst_err();
  1225.                         } 
  1226.                         else
  1227.                            printf("                          ");
  1228.                         lin_cnt=0;
  1229.                      }
  1230.                      if (o_flg) {
  1231.                         if (fprintf(f_lst_fil,"%5u",pref) == ERROR)
  1232.                            lst_err();
  1233.                      } 
  1234.                      else
  1235.                         printf("%5u",pref);
  1236.                   }
  1237.                }
  1238.                else
  1239.                   pref=0;
  1240.             } 
  1241.             while (pref);
  1242.             nl();
  1243.          } 
  1244.          while ((pid_ptr=pid_ptr->alpha_lnk) != NULL);
  1245.       }
  1246.    }
  1247.    /*for*/
  1248.    echo( '\n' );
  1249.    if (o_flg)
  1250.       if (fprintf(f_lst_fil, "  %6d references", refs) == ERROR)
  1251.          lst_err();
  1252.  
  1253.    printf("\n%6d references\n", refs);
  1254.    printf("%6d in_refs\n", in_refs);
  1255.    echo( '\n' );
  1256. }
  1257.  
  1258. /*************************************************************************/
  1259.  
  1260. void prt_hdr()
  1261. {
  1262.  
  1263.    if (pagno++) {
  1264.       echo('\n');
  1265.       echo(FF);
  1266.    }
  1267.  
  1268.    if (o_flg) {
  1269.       if (p_flg) {
  1270.          if (fprintf(f_lst_fil,
  1271.          "       'C' Concordance Utility   %-20s      Date:%d/%d/%02d %02d:%02d:%02d",
  1272.          gbl_trc, today.da_mon, today.da_day, today.da_year,
  1273.          now.ti_hour, now.ti_min, now.ti_sec)
  1274.              == ERROR) lst_err();
  1275.       } 
  1276.       else
  1277.          if (fprintf(f_lst_fil,
  1278.          "       'C' Concordance Utility   %-20s      Date:%d/%d/%02d %02d:%02d:%02d Page: %d",
  1279.          gbl_trc, today.da_mon, today.da_day, today.da_year,
  1280.          now.ti_hour, now.ti_min, now.ti_sec, pagno)
  1281.              == ERROR) lst_err();
  1282.    } 
  1283.    else
  1284.       printf("XC ... 'C' Concordance Utility   %-20s       Page %d", gbl_trc, pagno);
  1285.  
  1286.    echo('\n');
  1287.    paglin = 1;
  1288.    nl();
  1289.  
  1290. }
  1291.  
  1292. /*************************************************************************/
  1293.  
  1294. void nl()
  1295. {
  1296.    echo('\n');
  1297.  
  1298.    if (++paglin >= LINES_PER_PAGE & (!p_flg))
  1299.       prt_hdr();
  1300.    else
  1301.       if (!prt_ref) {
  1302.          if (o_flg) {
  1303.             if (fprintf(f_lst_fil,"     ") == ERROR)
  1304.                lst_err();
  1305.             ++linum;
  1306.             ++edtnum;
  1307.          } 
  1308.          else
  1309.             printf("%-4d %4d: ",++linum,++edtnum);
  1310.  
  1311.          if (o_flg)
  1312.             if (linum % 60 == 1)
  1313.                printf("\n<%04d> ",linum);
  1314.             else {
  1315.                printf(".");
  1316.                fflush(stdout);
  1317.             }
  1318.       }
  1319.    return;
  1320. }
  1321.  
  1322.  
  1323. /***************************************/
  1324.