home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / TOOLS2.ZIP / XREF.C < prev    next >
C/C++ Source or Header  |  1988-03-21  |  25KB  |  939 lines
  1. /*
  2.     HEADER:        CUG000.00;
  3.     TITLE:        Cross Reference Generator;
  4.     DATE:        04/05/1987;
  5.     DESCRIPTION:    "Generic version of programmer's cross-reference
  6.             generator originally for BDS.";
  7.     VERSION:    2.2;
  8.     KEYWORDS:    Cross Reference;
  9.     FILENAME:    XC.C;
  10.     SEE-ALSO:    CUG126, CUG171;
  11.     COMPILERS:    vanilla;
  12.     AUTHORS:    Phillip N. Hisley, W. H. Rauser, W. C. Colley III;
  13. */
  14.  
  15. /************************************************************************/
  16. /*   5 APR 1987      Portable C Conversion        WCC                */
  17. /*     -  Epson init string changed from hex (\x00) to octal (\000).    */
  18. /*     -  Use () with A?(c=B):(c=C) for portability.  If it's an error, */
  19. /*        it seems to be a very common one.            */
  20. /*     -  Made use of host compiler's strcmp() and strcpy() as they are */
  21. /*        usually written in assembly and run faster.        */
  22. /*     -  Globally replaced "alpha_" with "alp_", "alloc_" with        */
  23. /*        "allo_", and "tmpchr" with "tmpch" to avoid multiply    */
  24. /*        defined symbol errors on compilers that only support    */
  25. /*        @$%&*&?>}\~~@# 6-character names.            */
  26. /*     -  Added abs() macro for compilers that don't have one.          */
  27. /*     -  Used some data initialization to kill off some code.        */
  28. /*     -  Made miscellaneous small tweaks for portability.        */
  29. /*     -  Cleaned out old BDS C stuff to improve readability.        */
  30. /*     -  Cleaned up abortion with use of rf_blk.rf_cnt as a pointer    */
  31. /*        link to the next rf_blk.  This construct will NOT work    */
  32. /*        in environments like the MSDOS large model where ints    */
  33. /*        are smaller than pointers!                */
  34. /*                                    */
  35. /*   9-26-83   Microsoft C 1.04     Conversion    WHR            */
  36. /*     -  \t between line numbers and text to fix indenting problem.    */
  37. /*     -  added option -e for output to Epson in condensed print.    */
  38. /*     -  toupper() and isupper() are macros, not functions.        */
  39. /*     -  eliminate side effect in toupper(*++arg) in main().        */
  40. /*     -  change alloc() to malloc().                    */
  41. /*     -  add #define NAMES that are not in stdio.h            */
  42. /*     -  MS-C requires () in statement A?(c=B):(c=C)    error or not??    */
  43. /*                                    */
  44. /*   4-30-83   Computer Innovations C-86 1.31 Conversion    WHR        */
  45. /*     -  #include filename changed to allow a disk drive prefix, D:    */
  46. /*     -  convert if(fprintf(...) == ERROR) lst_err(); to fprintf(..);    */
  47. /*     -  convert if(fopen(...) == ERROR) statements to == NULL.    */
  48. /*     -  C86 requires () in statement A?(c=B):(c=C)    error or not??    */
  49. /*     -  remove getc() == ERROR check in fil_chr().            */
  50. /*     -  convert file conventions from BDS C to C-86.            */
  51. /*     -  comment out BDS unique statements, mark revised statements.    */
  52. /*      keep all BDS statements to document conversion effort.    */
  53. /*                                    */
  54. /**  4-19-83   BDS C Version file XC.CQ copied from Laurel RCPM       WHR    */
  55. /************************************************************************/
  56. /*                               */
  57. /*    XC  -  A 'C' Concordance Utility               */
  58. /*                               */
  59. /*    Version 1.0   January, 1982               */
  60. /*                               */
  61. /*    Copyright (c) 1982 by Philip N. Hisley           */
  62. /*                               */
  63. /*    Released for non-commercial distribution only       */
  64. /*                               */
  65. /*    Abstract:                           */
  66. /*                               */
  67. /*    'XC' is a cross-reference utility for 'C' programs.  */
  68. /*    Its has the ability to handle nested include files   */
  69. /*    to a depth of 8 levels and properly processes nested */
  70. /*    comments as supported by BDS C. Option flags support */
  71. /*    the following features:                   */
  72. /*                               */
  73. /*    - Routing of list output to disk               */
  74. /*    - Cross-referencing of reserved words           */
  75. /*    - Processing of nested include files           */
  76. /*    - Generation of listing only               */
  77. /*                               */
  78. /*    Usage: xc <filename> <flag(s)>               */
  79. /*                               */
  80. /*    Flags: -i           = Enable file inclusion       */
  81. /*         -l           = Generate listing only       */
  82. /*         -r           = Cross-ref reserved words       */
  83. /*         -o <filename> = Write output to named file       */
  84. /*                               */
  85. /*    Please report bugs/fixes/enhancements to:           */
  86. /*                               */
  87. /*          Philip N. Hisley                   */
  88. /*          548H Jamestown Court               */
  89. /*          Edgewood, Maryland 21040               */
  90. /*          (301) 679-4606                   */
  91. /*          Net Addr: PNH@MIT-AI               */
  92. /*                               */
  93. /***********************************************************/
  94.  
  95. #include <stdio.h>
  96.  
  97. /*
  98.  * Portability Note:  The AZTEC C compilers handle the binary/text file
  99.  * dichotomy differently from most other compilers.  Uncomment the following
  100.  * pair of #defines if you are running AZTEC C:
  101.  */
  102.  
  103. /*
  104. #define getc(f)        agetc(f)
  105. #define putc(c,f)    aputc(c,f)
  106. */
  107.  
  108. /*  Portability Note:  8-bit systems often don't have header files
  109.     ctype.h and string.h.  If your system doesn't have these,
  110.     uncomment the #defines NO_STRING_H and NO_CTYPE_H.           WCC    */
  111.  
  112. /*
  113. #define     NO_STRING_H
  114. #define     NO_CTYPE_H
  115. */
  116.  
  117. /*  Portability Note:  Some older compilers call the function malloc()
  118.     by its older name alloc().    If you have one of these older
  119.     compilers, uncomment the following #define.            WCC    */
  120.  
  121. /*
  122. #define     malloc(x)    alloc(x)
  123. */
  124.  
  125. /*  Portability Note:  A few compilers don't know the additional type
  126.     void.  If yours is one of these, uncomment the following #define.    */
  127.  
  128. /* #define    void        int                    */
  129.  
  130. #ifdef     NO_CTYPE_H                        /* WCC */
  131. int isalpha(), isdigit(), isupper(), toupper();
  132. #else
  133. #include <ctype.h>                        /* WHR */
  134. #endif
  135.  
  136. #ifdef     NO_STRING_H                        /* WCC */
  137. int strcmp();  
  138. char *strcpy();
  139. #else
  140. #include <string.h>
  141. #endif
  142.  
  143. #ifndef     abs                            /* WCC */
  144. #define     abs(x)        ((x < 0) ? (-x) : (x))
  145. #endif
  146.  
  147. /*  Portability Note:  Some stdio.h files define various of these
  148.     constants.    Some don't.  Therefore, each definition is
  149.     compiled only if needed.                       WCC */
  150.  
  151. #ifndef     NULL                            /* WCC */
  152. #define     NULL        0
  153. #endif
  154.  
  155. #ifndef     FALSE                            /* WCC */
  156. #define     FALSE        0                        /* WHR */
  157. #endif
  158.  
  159. #ifndef     TRUE                            /* WCC */
  160. #define     TRUE        1                        /* WHR */
  161. #endif
  162.  
  163. #define     MAX_REF    5        /* maximum refs per ref-block */
  164. #define     MAX_LEN    20        /* maximum identifier length  */
  165. #define     MAX_WRD   749        /* maximum number of identifiers */
  166. #define     MAX_ALPHA  53        /* maximum alpha chain heads */
  167. #define     REFS_PER_LINE    8    /* maximum refs per line */
  168. #define     LINES_PER_PAGE 60
  169. #define     FF 0x0C         /* formfeed */
  170.  
  171. /*  Order of the next two structure declarations reversed to avoid
  172.     a forward reference that chokes some compilers.            WCC */
  173.  
  174. struct rf_blk {
  175.     int ref_item[MAX_REF];
  176.     int ref_cnt;
  177.     struct rf_blk *ref_lnk;
  178. } 
  179. onerf;
  180.  
  181. struct id_blk {
  182.     char id_name[MAX_LEN];
  183.     struct id_blk *alp_lnk;
  184.     struct rf_blk *top_lnk;
  185.     struct rf_blk *lst_lnk;
  186. } 
  187. oneid, *id_vector[MAX_WRD];
  188.  
  189. struct alp_hdr { 
  190.     struct id_blk *alp_top;
  191.     struct id_blk *alp_lst;
  192. } 
  193. alp_vector[MAX_ALPHA];
  194.  
  195. int    linum;        /* line number */
  196. int    edtnum;        /* edit line number */
  197. int    fil_cnt;    /* active file index */
  198. int    wrd_cnt;    /* token count */
  199. int    pagno;        /* page number */
  200. int    id_cnt;        /* number of unique identifiers */
  201. int    rhsh_cnt;    /* number of conflict hits */
  202. int    filevl;        /* file level  */
  203. int    paglin;        /* page line counter */
  204. int    prt_ref = FALSE;
  205. char    act_fil[MAX_LEN];
  206. char    lst_fil[MAX_LEN];
  207. char    gbl_fil[MAX_LEN];
  208. FILE   *l_buffer;                         /* WHR */
  209. int    e_flg = FALSE, i_flg = FALSE, o_flg = FALSE;         /* WHR */
  210. int    r_flg = FALSE, l_flg = FALSE, debug = FALSE;         /* WCC */
  211. char    Epson[]     = "\033@\017\033Q\204";             /* WCC */
  212.  
  213. void exit();
  214.  
  215. /*-------------------------------------------*/
  216.  
  217. void main(argc,argv)
  218. int    argc;
  219. char    **argv;
  220. {
  221.     char  *arg, cc;
  222.     void nl(), prnt_tbl(), proc_file(), use_err();
  223.  
  224.     if (argc < 2) use_err();
  225.     (void)strcpy(gbl_fil,*++argv);
  226.     --argc;
  227.     if(gbl_fil[0] == '-')
  228.         use_err();
  229.     while(--argc != 0)
  230.     {      
  231.         if(*(arg=*++argv) == '-')
  232.             /*****{    switch( toupper(*++arg) )     *** side effect in Microsoft C */
  233.         {    
  234.             switch( cc=*++arg, toupper(cc) )             /* Microsoft C */
  235.             {   
  236.             case 'I':  
  237.                 i_flg++;
  238.                 break;
  239.             case 'R':  
  240.                 r_flg++;
  241.                 break;
  242.             case 'L':  
  243.                 l_flg++;
  244.                 break;
  245.             case 'O': 
  246.                 {
  247.                     o_flg++;
  248.                     if(--argc == 0) use_err();
  249.                     (void)strcpy(lst_fil,*++argv);
  250.                     if(lst_fil[0] == '-') use_err();
  251.                     if(debug) printf("lst_fil=>%s<",lst_fil);
  252.                     break;
  253.                 }
  254.             case 'D':  
  255.                 debug++;
  256.                 break;
  257.             case 'E':  
  258.                 e_flg++;                  /* WHR */
  259.                 o_flg++;
  260.                 (void)strcpy(lst_fil,"LPT1:");
  261.                 break;
  262.             default:   
  263.                 use_err();
  264.             }
  265.         }
  266.         else use_err();
  267.     }
  268.     if (debug) printf("\ni_flg=%d, r_flg=%d, l_flg=%d", i_flg,r_flg,l_flg);
  269.     if (debug) printf("\no_flg=%d, debug=%d", o_flg,debug);
  270.     if (o_flg)
  271.     {      
  272.         if ( (l_buffer = fopen(lst_fil,"w")) == NULL)      /*** output file ***/
  273.         {    
  274.             printf("ERROR Unable to create list file - %s\n",lst_fil);
  275.             exit(0);
  276.         }
  277.         printf("\nXC ....... 'C' Concordance Utility  v2.3\n");
  278.         printf("    Portable C,  Conversion 5 APR 1987\n\n");        /* WCC */
  279.         if (e_flg) fprintf(l_buffer,"%s",Epson);
  280.     }
  281.     for(linum=0;linum < MAX_WRD;linum++) {
  282.         id_vector[linum] = NULL;
  283.     }
  284.     for(linum=0;linum < MAX_ALPHA;linum++)
  285.     {
  286.         alp_vector[linum].alp_top =
  287.             alp_vector[linum].alp_lst = NULL;
  288.     }
  289.     fil_cnt = wrd_cnt = linum = 0;
  290.     filevl=paglin=pagno=edtnum=0;
  291.     id_cnt=rhsh_cnt=0;
  292.     proc_file(gbl_fil);
  293.     if(!l_flg) {
  294.         printf("Cross reference for file %s\n\n", gbl_fil ) ;
  295.         prnt_tbl();
  296.         printf("\nAllowable Symbols: %d\n",MAX_WRD);
  297.         printf("Unique    Symbols: %d\n",id_cnt);
  298.     }
  299.     if(o_flg) {
  300.         nl();
  301.         fprintf(l_buffer,"\nAllowable Symbols: %d\n",MAX_WRD);   /* WHR */
  302.         fprintf(l_buffer,"Unique    Symbols: %d\n",id_cnt);       /* WHR */
  303.         fprintf(l_buffer,"%c",FF);                   /* WHR */
  304.         fflush(l_buffer);
  305.         fclose(l_buffer);
  306.     }
  307. }/*main.
  308. ----------------------------------------*/
  309.  
  310. void use_err()
  311. {
  312.     printf("\nERROR: Invalid parameter specification\n\n");
  313.     printf("Usage: xc <filename> <flag(s)>\n\n");
  314.     printf("Flags: -e             = Emit printer initialization string\n");
  315.     printf("       -i             = Enable file inclusion\n");
  316.     printf("       -l             = Generate listing only\n");
  317.     printf("       -r             = Cross-reference reserved words\n");
  318.     printf("       -o <filename>  = Write output to named file\n");
  319.     exit(0);
  320. }/*use_err.
  321. -------------------------------------------*/
  322.  
  323.  
  324. void proc_file(filnam)
  325. char    *filnam;
  326.  
  327. {
  328.     FILE  *buffer;       /* allocated buffer pointer */
  329.     /* WHR */
  330.     char  token[MAX_LEN]; /* token buffer */
  331.     int   eof_flg;       /* end-of-file indicator */
  332.     int   tok_len;       /* token length */
  333.     int   incnum;       /* included line number */
  334.     int chk_token(), get_token();
  335.     void nl(), put_token();
  336.  
  337.     (void)strcpy(act_fil,filnam);
  338.     if ((buffer = fopen(filnam,"r")) == NULL)    /*** input file ***/ /* WHR */
  339.     {      
  340.         printf("\nERROR: Unable to open input file: %s\n",filnam);
  341.         exit(0);
  342.     }
  343.  
  344.     eof_flg = FALSE;
  345.  
  346.     do {
  347.         if(get_token(buffer,token,&tok_len,&eof_flg,0))
  348.         {    
  349.             if (debug) printf("\ntoken: %s   length: %d\n",token,&tok_len);
  350.             if (chk_token(token))
  351.             {
  352.                 /* #include processing changed to accept drive:   WHR */
  353.                 if (strcmp(token,"#include") == 0)
  354.                 {     
  355.                     if (get_token(buffer,token,&tok_len,&eof_flg,1))
  356.                     {    
  357.                         if (debug) printf("\ntoken: %s   length: %d\n",
  358.                         token,&tok_len);
  359.                         if (!i_flg) continue;
  360.                         else
  361.                             {       
  362.                             incnum=edtnum;
  363.                             edtnum=0;
  364.                             nl();
  365.                             proc_file(token);
  366.                             edtnum=incnum;
  367.                             (void)strcpy(act_fil,filnam);
  368.                             continue;
  369.                         }
  370.                     }
  371.                 }
  372.                 put_token(token,linum);
  373.             }
  374.         }
  375.     } 
  376.     while (!eof_flg);
  377.  
  378.     filevl -= 1;
  379.     fclose(buffer);
  380.     /***     free(sav_buffer);  */
  381. }/*proc_file.
  382. -------------------------------------------*/
  383.  
  384. int get_token(g_buffer,g_token,g_toklen,g_eoflg,g_flg)
  385. FILE    *g_buffer;
  386. char    *g_token;
  387. int     *g_toklen;
  388. int     *g_eoflg;
  389. int     g_flg;
  390.  
  391. /*
  392.      *     'getoken' returns the next valid identifier or
  393.      *     reserved word from a given file along with the
  394.      *     character length of the token and an end-of-file
  395.      *     indicator
  396.      *
  397.      */
  398.  
  399. {
  400.     int     c, rdchr();
  401.     char    *h_token;
  402.     char    tmpch;
  403.     char    tmpch2;              /* WHR fix for B:filename.ext */
  404.  
  405.     h_token = g_token;
  406.  
  407. gtk:                   /* top of loop, get new token */
  408.     *g_toklen = 0;
  409.     g_token = h_token;
  410.  
  411.     /*
  412.          *    Scan and discard any characters until an alphabetic or
  413.          *    '_' (underscore) character is encountered or an end-of-file
  414.          *    condition occurs
  415.          */
  416.  
  417.     while(  (!isalpha(*g_token = rdchr(g_buffer,g_eoflg,g_flg)))
  418.         &&     !*g_eoflg    &&  *g_token != '_'
  419.         && *g_token != '0' &&  *g_token != '#' );
  420.     if(*g_eoflg) return(FALSE);
  421.  
  422.     *g_toklen += 1;
  423.  
  424.     /*
  425.          *     Scan and collect identified alpanumeric token until
  426.          *     a non-alphanumeric character is encountered or and
  427.          *     end-of-file condition occurs
  428.          */
  429.  
  430.     if(g_flg) {
  431.         tmpch     = '.';
  432.         tmpch2 = ':';              /* WHR fix for B:filename.ext */
  433.     }
  434.     else {
  435.         tmpch     = '_';
  436.         tmpch2 = '_';              /* WHR fix for B:filename.ext */
  437.     }
  438.     while( (isalpha(c=rdchr(g_buffer,g_eoflg,g_flg)) ||
  439.         isdigit(c) || c == '_' || c == tmpch || c == tmpch2)
  440.         && !*g_eoflg)           /* WHR fix for B:filename.ext */
  441.     {      
  442.         if(*g_toklen < MAX_LEN)
  443.         {    
  444.             *++g_token = c;
  445.             *g_toklen += 1;
  446.         }
  447.     }
  448.  
  449.  
  450.     /*
  451.          *        Check to see if a numeric hex or octal constant has
  452.          *        been encountered ... if so dump it and try again
  453.          */
  454.  
  455.  
  456.     if (*h_token == '0') goto gtk;
  457.  
  458.  
  459.     /*
  460.          *        Tack a NULL character onto the end of the token
  461.          */
  462.  
  463.     *++g_token = NULL;
  464.  
  465.     /*
  466.          *        Screen out all #token strings except #include
  467.          */
  468.  
  469.     if (*h_token == '#' && strcmp(h_token,"#include")) goto gtk;
  470.  
  471.     return (TRUE);
  472. }/*get_token.
  473. -----------------------------------------*/
  474.  
  475. int fil_chr(f_buffer,f_eof)
  476. FILE *f_buffer;
  477. int *f_eof;
  478. {
  479.     int fc;
  480.     if ((fc = getc(f_buffer)) == EOF) {
  481.         *f_eof = TRUE;
  482.         fc = NULL;
  483.     }
  484.     return(fc);
  485. }/*fil_chr.
  486. ----------------------------------------*/
  487.  
  488. int rdchr(r_buffer,r_eoflg,rd_flg)
  489. int     *r_eoflg, rd_flg;
  490. FILE    *r_buffer;
  491.  
  492. /*
  493.     'rdchr' returns the next valid character in a file
  494.     and an end-of-file indicator. A valid character is
  495.     defined as any which does not appear in either a
  496.     commented or a quoted string ... 'rdchr' will correctly
  497.     handle comment tokens which appear within a quoted
  498.     string
  499. */
  500.  
  501. {
  502.     int     c;
  503.     int     q_flg;         /* double quoted string flag */
  504.     int     q1_flg;         /* single quoted string flag */
  505.     int     cs_flg;         /* comment start flag */
  506.     int     ce_flg;         /* comment end flag */
  507.     int     c_cnt;         /* comment nesting level */
  508.     int     t_flg;         /* transparency flag */
  509.     void nl();
  510.  
  511.     q_flg = q1_flg = cs_flg = ce_flg = t_flg = FALSE;
  512.     c_cnt  = 0;
  513.  
  514. rch:
  515.  
  516.     /*
  517.          *     Fetch character from file
  518.          */
  519.  
  520.     c = fil_chr(r_buffer,r_eoflg);
  521.  
  522.     if (*r_eoflg) return(c);    /* EOF encountered */
  523.     if (c == '\n')
  524.     {
  525.         ++linum ;
  526.         ++edtnum ;
  527.     }
  528. /*
  529.         nl();
  530.     else
  531.         if (o_flg) fprintf(l_buffer,"%c",c);
  532.         else printf("%c",c);
  533. */
  534.  
  535.     if (rd_flg) return(c);
  536.  
  537.     if (t_flg) {
  538.         t_flg = !t_flg;
  539.         goto rch;
  540.     }
  541.  
  542.     if (c == '\\') {
  543.         t_flg = TRUE;
  544.         goto rch;
  545.     }
  546.     /*
  547.         If the character is not part of a quoted string
  548.         check for and process commented strings...
  549.         nested comments are handled correctly but unbalanced
  550.         comments are not ... the assumption is made that
  551.         the syntax of the program being xref'd is correct
  552.         */
  553.  
  554.     if (!q_flg     &&  !q1_flg) {
  555.         if (c == '*'    &&  c_cnt  &&  !cs_flg) {
  556.             ce_flg = TRUE;
  557.             goto rch;
  558.         }
  559.         if (c == '/'    &&  ce_flg) {
  560.             c_cnt -= 1;
  561.             ce_flg = FALSE;
  562.             goto rch;
  563.         }
  564.         ce_flg = FALSE;
  565.         if (c == '/') {
  566.             cs_flg = TRUE;
  567.             goto rch;
  568.         }
  569.         if (c == '*'    &&  cs_flg) {
  570.             c_cnt += 1;
  571.             cs_flg = FALSE;
  572.             goto rch;
  573.         }
  574.         cs_flg = FALSE;
  575.  
  576.         if (c_cnt) goto rch;
  577.     }
  578.  
  579.     /*
  580.         Check for and process quoted strings
  581.         */
  582.  
  583.     if ( c == '"'  &&    !q1_flg) {    /* toggle quote flag */
  584.         q_flg =  !q_flg;
  585.         if(debug) printf("\nq_flg toggled to: %d\n" ,q_flg);
  586.         goto rch;
  587.     }
  588.     if (q_flg) goto rch;
  589.  
  590.     if (c == '\'') {         /* toggle quote flag */
  591.         q1_flg = !q1_flg;
  592.         if(debug) printf("\nq1_flg toggled to: %d\n" ,q1_flg);
  593.         goto rch;
  594.     }
  595.     if (q1_flg) goto rch;
  596.  
  597.     /*
  598.         Valid character ... return to caller
  599.         */
  600.  
  601.     return (c);
  602. }/*rdchr.
  603. -----------------------------------------------*/
  604.  
  605.  
  606. int chk_token(c_token)
  607. char    *c_token;
  608. {
  609.     char  u_token[MAX_LEN];
  610.     int   i;
  611.  
  612.     {
  613.         if (r_flg) return(TRUE);
  614.         i = 0;
  615.         do { 
  616.             u_token[i] = toupper(c_token[i]);
  617.         } 
  618.         while (c_token[i++] != NULL);
  619.  
  620.         switch(u_token[0]) {
  621.         case 'A': 
  622.             if (strcmp(u_token,"AUTO") == 0) return(FALSE);
  623.             break;
  624.         case 'B': 
  625.             if (strcmp(u_token,"BREAK") == 0) return(FALSE);
  626.             break;
  627.         case 'C': 
  628.             if (strcmp(u_token,"CHAR") == 0) return (FALSE);
  629.             if (strcmp(u_token,"CONTINUE") == 0) return (FALSE);
  630.             if (strcmp(u_token,"CASE") == 0) return (FALSE);
  631.             break;
  632.  
  633.         case 'D': 
  634.             if(strcmp(u_token,"DOUBLE") == 0) return(FALSE);
  635.             if(strcmp(u_token,"DO") == 0) return(FALSE);
  636.             if(strcmp(u_token,"DEFAULT") == 0) return(FALSE);
  637.             break;
  638.         case 'E': 
  639.             if(strcmp(u_token,"EXTERN") == 0) return(FALSE);
  640.             if(strcmp(u_token,"ELSE") == 0) return(FALSE);
  641.             if(strcmp(u_token,"ENTRY") == 0) return(FALSE);
  642.             break;
  643.         case 'F': 
  644.             if(strcmp(u_token,"FLOAT") == 0) return(FALSE);
  645.             if(strcmp(u_token,"FOR") == 0) return(FALSE);
  646.             break;
  647.         case 'G': 
  648.             if(strcmp(u_token,"GOTO") == 0) return(FALSE);
  649.             break;
  650.         case 'I': 
  651.             if(strcmp(u_token,"INT") == 0) return(FALSE);
  652.             if(strcmp(u_token,"IF") == 0) return(FALSE);
  653.             break;
  654.         case 'L': 
  655.             if(strcmp(u_token,"LONG") == 0) return(FALSE);
  656.             break;
  657.         case 'R': 
  658.             if(strcmp(u_token,"RETURN") == 0) return(FALSE);
  659.             if(strcmp(u_token,"REGISTER") == 0) return(FALSE);
  660.             break;
  661.         case 'S': 
  662.             if(strcmp(u_token,"STRUCT") == 0) return(FALSE);
  663.             if(strcmp(u_token,"SHORT") == 0) return(FALSE);
  664.             if(strcmp(u_token,"STATIC") == 0) return(FALSE);
  665.             if(strcmp(u_token,"SIZEOF") == 0) return(FALSE);
  666.             if(strcmp(u_token,"SWITCH") == 0) return(FALSE);
  667.             break;
  668.         case 'T': 
  669.             if(strcmp(u_token,"TYPEDEF") == 0) return(FALSE);
  670.             break;
  671.         case 'U': 
  672.             if(strcmp(u_token,"UNION") == 0) return(FALSE);
  673.             if(strcmp(u_token,"UNSIGNED") == 0) return(FALSE);
  674.             break;
  675.         case 'W': 
  676.             if(strcmp(u_token,"WHILE") == 0) return(FALSE);
  677.             break; 
  678.         }
  679.     }
  680.     return (TRUE);
  681. }/*chk_token.
  682. ---------------------------------------------*/
  683.  
  684.  
  685. /*
  686.    *    Install parsed token and line reference in linked structure
  687.    */
  688.  
  689. void put_token(p_token,p_ref)
  690. char *p_token;
  691. int  p_ref;
  692. {
  693.     int  d, found, hsh_index, i, j;
  694.     struct id_blk *idptr, *allo_id();
  695.     struct rf_blk *allo_rf(), *add_rf();
  696.     void chain_alpha();
  697.  
  698.     if (l_flg) return;
  699.     j=0;
  700.     for (i=0; p_token[i] != NULL; i++)     /* Hashing algorithm is far from */
  701.     {                     /* optimal but is adequate for a */
  702.         j = j * 10 + p_token[i];     /* memory-bound index vector!      */
  703.     }
  704.     hsh_index = abs(j) % MAX_WRD;
  705.  
  706.     found = FALSE;
  707.     d = 1;
  708.     do
  709.         {      
  710.         idptr = id_vector[hsh_index];
  711.         if (idptr == NULL)
  712.         {    
  713.             id_cnt++;
  714.             idptr = id_vector[hsh_index] = allo_id(p_token);
  715.             chain_alpha(idptr,p_token);
  716.             idptr->top_lnk = idptr->lst_lnk = allo_rf(p_ref);
  717.             found = TRUE;
  718.         }
  719.         else
  720.             if (strcmp(p_token,idptr->id_name) == 0)
  721.         {    
  722.             idptr->lst_lnk = add_rf(idptr->lst_lnk,p_ref);
  723.             found = TRUE;
  724.         }
  725.         else
  726.             {    
  727.             hsh_index += d;
  728.             d += 2;
  729.             rhsh_cnt++;
  730.             if (hsh_index >= MAX_WRD)
  731.                 hsh_index -= MAX_WRD;
  732.             if (d == MAX_WRD)
  733.             {    
  734.                 printf("\nERROR: Symbol table overflow\n");
  735.                 exit(0);
  736.             }
  737.         }
  738.     } 
  739.     while (!found);
  740. }/*put_token.
  741. --------------------------------------------*/
  742.  
  743.  
  744. void chain_alpha(ca_ptr,ca_token)
  745. struct id_blk *ca_ptr;
  746. char  *ca_token;
  747. {
  748.     char  c;
  749.     struct id_blk *cur_ptr;
  750.     struct id_blk *lst_ptr;
  751.  
  752.     c = ca_token[0];
  753.     if (c == '_')  c = 0;
  754.     else
  755.         /**  isupper(c) ? c=1+((c-'A')*2) : c=2+((c-'a')*2) ;     error or not??
  756.               **  A good one for the puzzle book! Is the () required around (c=..)?
  757.               **  C86 and Microsoft C both req the ()'s, BDS C did not.
  758.               **  Is it required because = has lower precedence than ?: ????
  759.               **/
  760.         isupper(c) ? (c=1+((c-'A')*2)) : (c=2+((c-'a')*2)) ;
  761.  
  762.     if(alp_vector[c].alp_top == NULL)
  763.     {      
  764.         alp_vector[c].alp_top =
  765.             alp_vector[c].alp_lst = ca_ptr;
  766.         ca_ptr->alp_lnk = NULL;
  767.         return;
  768.     }
  769.  
  770.     /*    check to see if new id_blk should be inserted between
  771.          *    the alp_vector header block and the first id_blk in
  772.          *    the current alpha chain
  773.          */
  774.  
  775.     if(strcmp(alp_vector[c].alp_top->id_name,ca_token) >0)
  776.     {      
  777.         ca_ptr->alp_lnk=alp_vector[c].alp_top;
  778.         alp_vector[c].alp_top=ca_ptr;
  779.         return;
  780.     }
  781.  
  782.     if(strcmp(alp_vector[c].alp_lst->id_name,ca_token) < 0)
  783.     {      
  784.         alp_vector[c].alp_lst->alp_lnk = ca_ptr;
  785.         ca_ptr->alp_lnk = NULL;
  786.         alp_vector[c].alp_lst=ca_ptr;
  787.         return;
  788.     }
  789.  
  790.     cur_ptr = alp_vector[c].alp_top;
  791.     while(strcmp(cur_ptr->id_name,ca_token) < 0)
  792.     {      
  793.         lst_ptr = cur_ptr;
  794.         cur_ptr = lst_ptr->alp_lnk;
  795.     }
  796.  
  797.     lst_ptr->alp_lnk = ca_ptr;
  798.     ca_ptr->alp_lnk = cur_ptr;
  799.     return;
  800. }/*chain_alpha.
  801. -----------------------------------------*/
  802.  
  803. struct id_blk *allo_id(aid_token)
  804. char  *aid_token;
  805. {
  806.     int  ai;
  807.     struct id_blk *aid_ptr;
  808.     char *malloc();                         /* Microsoft C */
  809.  
  810.     /*** if((aid_ptr =  alloc(sizeof(oneid))) == 0) { ***/         /* Microsoft C */
  811.     if((aid_ptr = (struct id_blk *) malloc(sizeof(oneid))) == 0) { /* MS C */
  812.  
  813.         printf("\nERROR: Unable to allocate identifier block\n");
  814.         exit(0);
  815.     }
  816.     ai=0;
  817.     do {
  818.         aid_ptr->id_name[ai] = aid_token[ai];
  819.     } 
  820.     while (aid_token[ai++] != NULL);
  821.     return (aid_ptr);
  822. }/*id_blk.
  823. -----------------------------------------*/
  824.  
  825. struct rf_blk *allo_rf(arf_ref)
  826. int  arf_ref;
  827. {
  828.     int ri;
  829.     struct rf_blk *arf_ptr;
  830.     char *malloc();                       /* Microsoft C */
  831.  
  832.     /** if((arf_ptr = alloc(sizeof(onerf))) == 0) { **/    /* Microsoft C */
  833.     if((arf_ptr = (struct rf_blk *) malloc(sizeof(onerf))) == 0) { /* MS C */
  834.         printf("\nERROR: Unable to allocate reference block\n");
  835.         exit(0);
  836.     }
  837.     arf_ptr->ref_item[0] = arf_ref;
  838.     arf_ptr->ref_cnt = 1;  
  839.     arf_ptr->ref_lnk = NULL;
  840.     for (ri=1;ri<MAX_REF;ri++)
  841.         arf_ptr->ref_item[ri] = NULL;
  842.     return (arf_ptr);
  843. }/*allo_rf.
  844. ------------------------------------------*/
  845.  
  846.  
  847. struct rf_blk *add_rf(adr_ptr,adr_ref)
  848. struct rf_blk *adr_ptr;
  849. int adr_ref;
  850. {
  851.     if(adr_ptr->ref_cnt == MAX_REF)
  852.         return adr_ptr->ref_lnk = allo_rf(adr_ref);
  853.     else {
  854.         adr_ptr->ref_item[adr_ptr->ref_cnt++] = adr_ref;
  855.         return (adr_ptr);
  856.     }
  857. }/*rf_blk.
  858. ------------------------------------------*/
  859.  
  860. void prnt_tbl()
  861. {
  862.     int lin_cnt, pref, prf_cnt, pti;
  863.     struct id_blk *pid_ptr;
  864.     struct rf_blk *ptb_ptr;
  865.     void nl();
  866.  
  867.     prt_ref = TRUE;
  868.  
  869.     for (pti=0;pti<MAX_ALPHA;pti++)
  870.     {      
  871.         if ((pid_ptr = alp_vector[pti].alp_top) != NULL)
  872.         {    
  873.             do
  874.                 {    
  875.                 if(o_flg)                          /* WHR */
  876.                     fprintf(l_buffer,"%-14.13s: ",pid_ptr->id_name);
  877.                 else printf("%-14.13s: ",pid_ptr->id_name);
  878.                 ptb_ptr=pid_ptr->top_lnk;
  879.                 lin_cnt=prf_cnt=0;
  880.                 do
  881.                     {     
  882.                     if(prf_cnt == MAX_REF)
  883.                     {    
  884.                         prf_cnt=0;
  885.                         ptb_ptr = ptb_ptr->ref_lnk;
  886.                     }
  887.                     if(ptb_ptr)
  888.                     {
  889.                         if((pref=ptb_ptr->ref_item[prf_cnt++]) != 0)
  890.                         {
  891.                             if (lin_cnt++ == REFS_PER_LINE)
  892.                             {    
  893.                                 nl();             /* WHR,WCC */
  894.                                 if (o_flg) fprintf(l_buffer,"\t\t");
  895.                                 else printf("\t\t");
  896.                                 lin_cnt = 1;
  897.                             }
  898.                             if(o_flg) fprintf(l_buffer,"%-4d  ",pref);
  899.                             else printf("%-4d  ",pref);
  900.                         }
  901.                     }
  902.                     else pref=0;
  903.                 } 
  904.                 while (pref);
  905.                 nl();
  906.             } 
  907.             while ((pid_ptr=pid_ptr->alp_lnk) != NULL);
  908.         }
  909.     }
  910. }/*prnt_tbl.
  911. ---------------------------------------*/
  912.  
  913. void nl()
  914. {
  915.     if (o_flg) 
  916.         fprintf(l_buffer,"\n");                 
  917.     else
  918.         printf("\n");
  919.  
  920.     if(!prt_ref)
  921.     {    
  922. /*
  923.            if (o_flg) fprintf(l_buffer,"%-4d %4d:\t",
  924.                 ++linum,++edtnum);           
  925.            else printf("%-4d %4d:\t",++linum,++edtnum);'
  926. */
  927.         ++linum ;
  928.         ++edtnum ;
  929.  
  930.         if(o_flg)
  931.             if(linum % 60 == 1) printf("\n<%d>\t",linum);
  932.         else printf(".");
  933.     }
  934.     return;
  935. }/*nl.
  936. -------------------------------------------*/
  937. /*============= end of file xc.c ==========================*/
  938.  
  939.