home *** CD-ROM | disk | FTP | other *** search
/ The C Users' Group Library 1994 August / wc-cdrom-cusersgrouplibrary-1994-08.iso / vol_200 / 213_01 / xcr.c < prev    next >
Text File  |  1979-12-31  |  23KB  |  1,057 lines
  1. /* XCR.C    VERS:- 01.00  DATE:- 09/26/86  TIME:- 09:37:34 PM */
  2. /*
  3. %CC1 $1.C -O -X -E4000
  4. %CLINK $1 -S -E4000
  5. %DELETE $1.CRL 
  6. */
  7. /* 
  8. Description:
  9.  
  10. Cross-reference utility, from cug distribution disk.
  11.  
  12. Minor modification:
  13.     added check on characters of output per line (char_count),
  14.         to obtain correct pagination.
  15.  
  16. By J.A. Rupley, Tucson, Arizona
  17. Coded for BDS C compiler, version 1.50a
  18. */
  19. /* HEADER: CUG120.25;
  20.    TITLE: XC;
  21.    VERSION: 1.0;
  22.    DATE: 00/00/1982;
  23.    DESCRIPTION: "A cross-reference utility for C-programs.
  24.     It has the ability to handle nested include files to
  25.     a depth of 8.";
  26.    KEYWORDS: C programming,concordance generator;
  27.    SYSTEM: CP/M;
  28.    FILENAME: XC.C;
  29.    CRC: 3D48;
  30.    AUTHORS: Phillip N. Hisley;
  31.    COMPILERS: BDS C;
  32. */
  33. /***********************************************************/
  34. /*                               */
  35. /*    XC  -  A 'C' Concordance Utility                     */
  36. /*                               */
  37. /*    Version 1.0   January, 1982               */
  38. /*                               */
  39. /*    Copyright (c) 1982 by Philip N. Hisley               */
  40. /*                               */
  41. /*    Released for non-commercial distribution only        */
  42. /*                               */
  43. /*    Abstract:                           */
  44. /*                                   */
  45. /*    'XC' is a cross-reference utility for 'C' programs.  */
  46. /*    Its has the ability to handle nested include files   */
  47. /*    to a depth of 8 levels and properly processes nested */
  48. /*    comments as supported by BDS C. Option flags support */
  49. /*    the following features:                   */
  50. /*                               */
  51. /*    - Routing of list output to disk               */
  52. /*    - Cross-referencing of reserved words           */
  53. /*    - Processing of nested include files           */
  54. /*    - Generation of listing only               */
  55. /*                               */
  56. /*    Usage: xc <filename> <flag(s)>               */
  57. /*                               */
  58. /*    Flags: -i            = Enable file inclusion         */
  59. /*           -l               = Generate listing only         */
  60. /*           -r            = Cross-ref reserved words      */
  61. /*           -o <filename> = Write output to named file    */
  62. /*                               */
  63. /*                               */
  64. /*    -------------------------------------------------    */
  65. /*                               */
  66. /*    Compiliation Instructions - BDS C V1.42           */
  67. /*                               */
  68. /*    XC.C utilizes the dynamic storage allocation         */
  69. /*    scheme provided by BDS C .. this option must be      */
  70. /*    enabled per the instructions in BDSCIO.H           */
  71. /*                                   */
  72. /*    The -o and the -e options are used to maximize        */
  73. /*    the execution speed of XC.               */
  74. /*                               */
  75. /*    cc1 xc.c -o -e3560                       */
  76. /*    clink xc -s -e3560                          */
  77. /*                               */
  78. /*    Note: The location of the externals (-e3560)       */
  79. /*        is valid for version 1.0 of XC.C .. any       */
  80. /*          changes to XC.C which increase the size        */
  81. /*          of the generated code will require that        */
  82. /*          -e <xxxx> be resized .. also use of a       */
  83. /*          version of BDS C other than V1.42 may          */
  84. /*          alter the location of the external data        */
  85. /*        .. handle with care!               */
  86. /*                               */
  87. /*        Resizing Procedure:                   */
  88. /*                                   */
  89. /*          1. Compile/link XC with -o option:           */
  90. /*                                      */
  91. /*           cc1 XC.C -o                   */
  92. /*           clink XC -s                   */
  93. /*                                   */
  94. /*           The link map will indicate the address       */
  95. /*           at which external data starts .. in the       */
  96. /*           case of XC V1.0/BDS C V1.42 this becomes    */
  97. /*           3821h                       */
  98. /*                               */
  99. /*        2. Re-compile/link XC with the -o option       */
  100. /*             and the -e option using the external       */
  101. /*             data address obtained from step 1.       */
  102. /*                               */
  103. /*           cc1 XC.C -o -e3821               */
  104. /*           clink XC -s -e3821               */
  105. /*                                 */
  106. /*        3. Use of the -e option in step 2 will cause   */
  107. /*           the size of the generated code to become    */
  108. /*           smaller .. re-compile/link adjusting the    */
  109. /*             external data address to just above the     */
  110. /*             end of the code.                   */
  111. /*                               */
  112. /*             cc1 XC.C -o -e3560               */
  113. /*             clink XC -s -e3560               */
  114. /*                               */
  115. /*    -------------------------------------------------    */
  116. /*                               */
  117. /*    Please report bugs/fixes/enhancements to:            */
  118. /*                               */
  119. /*            Philip N. Hisley                   */
  120. /*          548H Jamestown Court               */
  121. /*          Edgewood, Maryland 21040               */
  122. /*          (301) 679-4606                   */
  123. /*                                   */
  124. /*                                                      */
  125. /***********************************************************/
  126.  
  127. #include "bdscio.h"
  128.  
  129. #define  LINELENGTH 63
  130. #define  MAX_REF    5        /* maximum refs per ref-block */
  131. #define  MAX_LEN    20        /* maximum identifier length  */
  132. #define  MAX_WRD   749        /* maximum number of identifiers */
  133. #define  MAX_ALPHA  53          /* maximum alpha chain heads */
  134. #define  REFS_PER_LINE  8    /* maximum refs per line */
  135. #define    LINES_PER_PAGE 60
  136. #define FF 0x0C            /* formfeed */
  137.  
  138. struct id_blk
  139. {
  140.     char id_name[MAX_LEN];
  141.     struct id_blk *alpha_lnk;
  142.     struct rf_blk *top_lnk;
  143.     struct rf_blk *lst_lnk;
  144. }
  145. oneid;
  146.  
  147. struct rf_blk
  148. {
  149.     int ref_item[MAX_REF];
  150.     int ref_cnt;
  151. }
  152. onerf;
  153.  
  154. struct id_blk *id_vector[MAX_WRD];
  155.  
  156. struct alpha_hdr
  157. {
  158.     struct id_blk *alpha_top;
  159.     struct id_blk *alpha_lst;
  160. }
  161. ;
  162.  
  163. struct alpha_hdr alpha_vector[MAX_ALPHA];
  164.  
  165. int char_count;
  166. int linum;        /* line number */
  167. int edtnum;        /* edit line number */
  168. int fil_cnt;        /* active file index */
  169. int wrd_cnt;        /* token count */
  170. int pagno;        /* page number */
  171. int id_cnt;        /* number of unique identifiers */
  172. int rhsh_cnt;        /* number of conflict hits */
  173. int filevl;        /* file level  */
  174. int paglin;        /* page line counter */
  175. int prt_ref;
  176. char act_fil[MAX_LEN];
  177. char lst_fil[MAX_LEN];
  178. char gbl_fil[MAX_LEN];
  179. char l_buffer[BUFSIZ];
  180. int i_flg, o_flg, r_flg, l_flg;
  181.  
  182. main(argc, argv)
  183. int argc;
  184. char **argv;
  185.  
  186. {
  187.     char *arg;
  188.  
  189.     if (argc < 2)
  190.         use_err();
  191.     i_flg = r_flg = o_flg = l_flg = FALSE;
  192.     strcpy(gbl_fil, *++argv);
  193.     --argc;
  194.     if (gbl_fil[0] == '-')
  195.         use_err();
  196.     while (--argc != 0)
  197.     {
  198.         if (*(arg = *++argv) == '-')
  199.         {
  200.             switch (*++arg)
  201.             {
  202.             case 'I' :
  203.                 i_flg++;
  204.                 break;
  205.             case 'R' :
  206.                 r_flg++;
  207.                 break;
  208.             case 'L' :
  209.                 l_flg++;
  210.                 break;
  211.             case 'O' :
  212.                 {
  213.                     o_flg++;
  214.                     if (--argc == 0)
  215.                         use_err();
  216.                     strcpy(lst_fil, *++argv);
  217.                     if (lst_fil[0] == '-')
  218.                         use_err();
  219.                     break;
  220.                 }
  221.             default :
  222.                 use_err();
  223.             }
  224.         }
  225.         else
  226.             use_err();
  227.     }
  228.  
  229.     if (o_flg)
  230.     {
  231.         if (fcreat(lst_fil, l_buffer) == ERROR)
  232.         {
  233.             printf("ERROR: Unable to create list file - %s\n", lst_fil);
  234.             exit(0);
  235.         }
  236.         printf("XC ... 'C' Concordance Utility  v1.0\n\n");
  237.     }
  238.  
  239.     _allocp = NULL;        /* initialize memory allocation pointer */
  240.     prt_ref = FALSE;
  241.     for (linum = 0; linum < MAX_WRD; linum++)
  242.     {
  243.         id_vector[linum] = NULL;
  244.     }
  245.     for (linum = 0; linum < MAX_ALPHA; linum++)
  246.     {
  247.         alpha_vector[linum].alpha_top =
  248.             alpha_vector[linum].alpha_lst = NULL;
  249.     }
  250.     fil_cnt = wrd_cnt = linum = 0;
  251.     char_count = 1;
  252.     filevl = paglin = pagno = edtnum = 0;
  253.     id_cnt = rhsh_cnt = 0;
  254.     proc_file(gbl_fil);
  255.     if (!l_flg)
  256.     {
  257.         prnt_tbl();
  258.         printf("\nAllowable Symbols: %d\n", MAX_WRD);
  259.         printf("Unique    Symbols: %d\n", id_cnt);
  260.     }
  261.     if (o_flg)
  262.     {
  263.         nl();
  264.         if (fprintf(l_buffer, "%c", CPMEOF) == ERROR)
  265.             lst_err();
  266.         fflush(l_buffer);
  267.         fclose(l_buffer);
  268.     }
  269. }
  270.  
  271. strcmp(s, t)
  272. char s[], t[];
  273. {
  274.     int i;
  275.     i = 0;
  276.     while (s[i] == t[i])
  277.         if (s[i++] == '\0')
  278.             return (0);
  279.     return (s[i] - t[i]);
  280. }
  281.  
  282. char *strcpy(s1, s2)
  283. char *s1, *s2;
  284. {
  285.     char *temp;
  286.     temp = s1;
  287.     while (*s1++ = *s2++)
  288.         ;
  289.     return (temp);
  290. }
  291.  
  292. lst_err()
  293.  
  294. {
  295.     printf("\nERROR: Write error on list output file - %s\n",
  296.     lst_fil);
  297.     exit(0);
  298. }
  299.  
  300. use_err()
  301.  
  302. {
  303.     printf("\nERROR: Invalid parameter specification\n\n");
  304.     printf("Usage: xc <filename> <flag(s)>\n\n");
  305.     printf("Flags: -i            = Enable file inclusion\n");
  306.     printf("       -l         = Generate listing only\n");
  307.     printf("       -r            = Cross-reference reserved words\n");
  308.     printf("       -o <filename> = Write output to named file\n");
  309.     exit(0);
  310. }
  311.  
  312. proc_file(filnam)
  313.  
  314. char *filnam;
  315.  
  316. {
  317.     char *buffer;        /* allocated buffer pointer */
  318.     char *sav_buffer;        /* saved alloc buffer pointer */
  319.     char token[MAX_LEN];        /* token buffer */
  320.     int eof_flg;        /* end-of-file indicator */
  321.     int tok_len;        /* token length */
  322.     int incnum;        /* included line number */
  323.     strcpy(act_fil, filnam);
  324.     if ((sav_buffer = buffer = alloc(BUFSIZ)) == 0)
  325.     {
  326.         printf("\nERROR: Unable to allocate file buffer for %s\n", filnam);
  327.         exit(0);
  328.     }
  329.     if (fopen(filnam, buffer) == ERROR)
  330.     {
  331.         printf("\nERROR: Unable to open input file: %s\n", filnam);
  332.         exit(0);
  333.     }
  334.     if (filevl++ == 0)
  335.         prt_hdr();
  336.     eof_flg = FALSE;
  337.     do
  338.         {
  339.         if (get_token(buffer, token, &tok_len, &eof_flg, 0))
  340.             if (chk_token(token))
  341.             {
  342.                 if (strcmp(token, "#include") == 0)
  343.                     if (get_token(buffer, token, &tok_len, &eof_flg, 1))
  344.                         if (!i_flg)
  345.                             continue;
  346.                 else
  347.                     {
  348.                     incnum = edtnum;
  349.                     edtnum = 0;
  350.                     nl();
  351.                     proc_file(token);
  352.                     edtnum = incnum;
  353.                     strcpy(act_fil, filnam);
  354.                     continue;
  355.                 }
  356.                 put_token(token, linum);
  357.             }
  358.     }
  359.     while (!eof_flg)
  360.         ;
  361.  
  362.     filevl -= 1;
  363.     fclose(buffer);
  364.     free(sav_buffer);
  365. }
  366.  
  367. get_token(g_buffer, g_token, g_toklen, g_eoflg, g_flg)
  368.  
  369. char *g_buffer;
  370. char *g_token;
  371. int *g_toklen;
  372. int *g_eoflg;
  373. int g_flg;
  374.  
  375. /*
  376.     'getoken' returns the next valid identifier or
  377.     reserved word from a given file along with the
  378.     character length of the token and an end-of-file
  379.     indicator
  380. */
  381.  
  382. {
  383.     int c;
  384.     char *h_token;
  385.     char tmpchr;
  386.  
  387.     h_token = g_token;
  388.  
  389. gtk :
  390.     *g_toklen = 0;
  391.     g_token = h_token;
  392.  
  393.     /*
  394.             Scan and discard any characters until an alphabetic or
  395.             '_' (underscore) character is encountered or an end-of-file
  396.             condition occurs
  397.             */
  398.  
  399.     while ((!isalpha(*g_token = rdchr(g_buffer, g_eoflg, g_flg))) && !*g_eoflg
  400.         && *g_token != '_' && *g_token != '0' && *g_token != '#');
  401.     if (*g_eoflg)
  402.         return (FALSE);
  403.     *g_toklen += 1;
  404.  
  405.     /*
  406.             Scan and collect identified alpanumeric token until
  407.             a non-alphanumeric character is encountered or and
  408.             end-of-file condition occurs
  409.             */
  410.  
  411.     if (g_flg)
  412.         tmpchr = '.';
  413.     else
  414.         tmpchr = '_';
  415.     while ((isalpha(c = rdchr(g_buffer, g_eoflg, g_flg)) ||
  416.         isdigit(c) || c == '_' || c == tmpchr) && !*g_eoflg)
  417.     {
  418.         if (*g_toklen < MAX_LEN)
  419.         {
  420.             *++g_token = c;
  421.             *g_toklen += 1;
  422.         }
  423.     }
  424.  
  425.     /*
  426.             Check to see if a numeric hex or octal constant has
  427.             been encountered ... if so dump it and try again
  428.             */
  429.  
  430.     if (*h_token == '0')
  431.         goto gtk;
  432.  
  433.  
  434.     /*
  435.             Tack a NULL character onto the end of the token
  436.             */
  437.  
  438.     *++g_token = NULL;
  439.  
  440.     /*
  441.             Screen out all #token strings except #include
  442.             */
  443.  
  444.     if (*h_token == '#' && strcmp(h_token, "#include"))
  445.         goto gtk;
  446.  
  447.     return (TRUE);
  448. }
  449.  
  450. fil_chr(f_buffer, f_eof)
  451. char *f_buffer;
  452. int *f_eof;
  453. {
  454.     int fc;
  455.     fc = getc(f_buffer);
  456.     if (fc == ERROR)
  457.     {
  458.         printf("\nERROR: Error while processing input file - %s\n",
  459.         act_fil);
  460.         exit(0);
  461.     }
  462.     if (fc == CPMEOF || fc == EOF)
  463.     {
  464.         *f_eof = TRUE;
  465.         fc = NULL;
  466.     }
  467.     return (fc);
  468. }
  469.  
  470.  
  471. rdchr(r_buffer, r_eoflg, rd_flg)
  472.  
  473. int *r_eoflg;
  474. char *r_buffer;
  475. int rd_flg;
  476.  
  477. /*
  478.       'rdchr' returns the next valid character in a file
  479.     and an end-of-file indicator. A valid character is
  480.     defined as any which does not appear in either a
  481.     commented or a quoted string ... 'rdchr' will correctly
  482.     handle comment tokens which appear within a quoted
  483.     string
  484. */
  485.  
  486. {
  487.     int c;
  488.     int q_flg;        /* double quoted string flag */
  489.     int q1_flg;        /* single quoted string flag */
  490.     int cs_flg;        /* comment start flag */
  491.     int ce_flg;        /* comment end flag */
  492.     int c_cnt;        /* comment nesting level */
  493.     int t_flg;        /* transparency flag */
  494.  
  495.     q_flg = FALSE;
  496.     q1_flg = FALSE;
  497.     cs_flg = FALSE;
  498.     ce_flg = FALSE;
  499.     t_flg = FALSE;
  500.     c_cnt = 0;
  501.  
  502. rch :
  503.  
  504.     /*
  505.             Fetch character from file
  506.             */
  507.  
  508.     c = fil_chr(r_buffer, r_eoflg);
  509.     if (*r_eoflg)
  510.         return (c);        /* EOF encountered */
  511.     if (c == '\n')
  512.         nl();
  513.     else
  514.     {
  515.         /*tab "expansion", less one for immediate next incrementation*/
  516.         if (c == '\t')
  517.             char_count += (7 - ((char_count - 1) & 7));
  518.         if (char_count++ >= LINELENGTH)
  519.         {
  520.             char_count = 1;
  521.             paglin++;
  522.             if (o_flg)
  523.             {
  524.                 if (fprintf(l_buffer, "\n") == ERROR)
  525.                     lst_err();
  526.             }
  527.             else
  528.                 printf("\n");
  529.         }
  530.         if (o_flg)
  531.         {
  532.             if (fprintf(l_buffer, "%c", c) == ERROR)
  533.                 lst_err();
  534.         }
  535.         else
  536.             printf("%c", c);
  537.     }
  538.  
  539.     if (rd_flg)
  540.         return (c);
  541.  
  542.     if (t_flg)
  543.     {
  544.         t_flg = !t_flg;
  545.         goto rch;
  546.     }
  547.  
  548.     if (c == '\\')
  549.     {
  550.         t_flg = TRUE;
  551.         goto rch;
  552.     }
  553.     /* 
  554.             If the character is not part of a quoted string
  555.             check for and process commented strings...
  556.             nested comments are handled correctly but unbalanced
  557.             comments are not ... the assumption is made that
  558.             the syntax of the program being xref'd is correct
  559.             */
  560.  
  561.     if (!q_flg && !q1_flg)
  562.     {
  563.         if (c == '*' && c_cnt && !cs_flg)
  564.         {
  565.             ce_flg = TRUE;
  566.             goto rch;
  567.         }
  568.         if (c == '/' && ce_flg)
  569.         {
  570.             c_cnt -= 1;
  571.             ce_flg = FALSE;
  572.             goto rch;
  573.         }
  574.         ce_flg = FALSE;
  575.         if (c == '/')
  576.         {
  577.             cs_flg = TRUE;
  578.             goto rch;
  579.         }
  580.         if (c == '*' && cs_flg)
  581.         {
  582.             c_cnt += 1;
  583.             cs_flg = FALSE;
  584.             goto rch;
  585.         }
  586.         cs_flg = FALSE;
  587.         if (c_cnt)
  588.             goto rch;
  589.     }
  590.  
  591.     /*
  592.             Check for and process quoted strings
  593.             */
  594.  
  595.     if (c == '"' && !q1_flg)
  596.     {
  597.         q_flg = !q_flg;        /* toggle quote flag */
  598.         goto rch;
  599.     }
  600.     if (q_flg)
  601.         goto rch;
  602.  
  603.     if (c == '\'')
  604.     {
  605.         q1_flg = !q1_flg;        /* toggle quote flag */
  606.         goto rch;
  607.     }
  608.     if (q1_flg)
  609.         goto rch;
  610.  
  611.     /*
  612.             Valid character ... return to caller
  613.             */
  614.  
  615.     return (c);
  616. }
  617.  
  618. chk_token(c_token)
  619. char *c_token;
  620.  
  621. {
  622.     char u_token[MAX_LEN];
  623.     int i;
  624.  
  625.     {
  626.         if (r_flg)
  627.             return (TRUE);
  628.         i = 0;
  629.         do
  630.             {
  631.             u_token[i] = toupper(c_token[i]);
  632.         }
  633.         while (c_token[i++] != NULL)
  634.             ;
  635.  
  636.         switch (u_token[0])
  637.         {
  638.         case 'A' :
  639.             if (strcmp(u_token, "AUTO") == 0)
  640.                 return (FALSE);
  641.             break;
  642.         case 'B' :
  643.             if (strcmp(u_token, "BREAK") == 0)
  644.                 return (FALSE);
  645.             break;
  646.         case 'C' :
  647.             if (strcmp(u_token, "CHAR") == 0)
  648.                 return (FALSE);
  649.             if (strcmp(u_token, "CONTINUE") == 0)
  650.                 return (FALSE);
  651.             if (strcmp(u_token, "CASE") == 0)
  652.                 return (FALSE);
  653.             break;
  654.         case 'D' :
  655.             if (strcmp(u_token, "DOUBLE") == 0)
  656.                 return (FALSE);
  657.             if (strcmp(u_token, "DO") == 0)
  658.                 return (FALSE);
  659.             if (strcmp(u_token, "DEFAULT") == 0)
  660.                 return (FALSE);
  661.             break;
  662.         case 'E' :
  663.             if (strcmp(u_token, "EXTERN") == 0)
  664.                 return (FALSE);
  665.             if (strcmp(u_token, "ELSE") == 0)
  666.                 return (FALSE);
  667.             if (strcmp(u_token, "ENTRY") == 0)
  668.                 return (FALSE);
  669.             break;
  670.         case 'F' :
  671.             if (strcmp(u_token, "FLOAT") == 0)
  672.                 return (FALSE);
  673.             if (strcmp(u_token, "FOR") == 0)
  674.                 return (FALSE);
  675.             break;
  676.         case 'G' :
  677.             if (strcmp(u_token, "GOTO") == 0)
  678.                 return (FALSE);
  679.             break;
  680.         case 'I' :
  681.             if (strcmp(u_token, "INT") == 0)
  682.                 return (FALSE);
  683.             if (strcmp(u_token, "IF") == 0)
  684.                 return (FALSE);
  685.             break;
  686.         case 'L' :
  687.             if (strcmp(u_token, "LONG") == 0)
  688.                 return (FALSE);
  689.             break;
  690.         case 'R' :
  691.             if (strcmp(u_token, "RETURN") == 0)
  692.                 return (FALSE);
  693.             if (strcmp(u_token, "REGISTER") == 0)
  694.                 return (FALSE);
  695.             break;
  696.         case 'S' :
  697.             if (strcmp(u_token, "STRUCT") == 0)
  698.                 return (FALSE);
  699.             if (strcmp(u_token, "SHORT") == 0)
  700.                 return (FALSE);
  701.             if (strcmp(u_token, "STATIC") == 0)
  702.                 return (FALSE);
  703.             if (strcmp(u_token, "SIZEOF") == 0)
  704.                 return (FALSE);
  705.             if (strcmp(u_token, "SWITCH") == 0)
  706.                 return (FALSE);
  707.             break;
  708.         case 'T' :
  709.             if (strcmp(u_token, "TYPEDEF") == 0)
  710.                 return (FALSE);
  711.             break;
  712.         case 'U' :
  713.             if (strcmp(u_token, "UNION") == 0)
  714.                 return (FALSE);
  715.             if (strcmp(u_token, "UNSIGNED") == 0)
  716.                 return (FALSE);
  717.             break;
  718.         case 'W' :
  719.             if (strcmp(u_token, "WHILE") == 0)
  720.                 return (FALSE);
  721.             break;
  722.         }
  723.     }
  724.     return (TRUE);
  725. }
  726.  
  727. /*
  728.    Install parsed token and line reference in linked structure
  729. */
  730.  
  731. put_token(p_token, p_ref)
  732.  
  733. char *p_token;
  734. int p_ref;
  735.  
  736. {
  737.     int hsh_index;
  738.     int i;
  739.     int j;
  740.     int d;
  741.     int found;
  742.     struct id_blk *idptr;
  743.     struct rf_blk *rfptr;
  744.     struct id_blk *alloc_id();
  745.     struct rf_blk *alloc_rf();
  746.     struct rf_blk *add_rf();
  747.  
  748.     if (l_flg)
  749.         return;
  750.     j = 0;
  751.     for (i = 0; p_token[i] != NULL; i++)        /* Hashing algorithm is far from */
  752.     {
  753.         /* optimal but is adequate for a */
  754.         j = j * 10 + p_token[i];        /* memory-bound index vector!    */
  755.     }
  756.     hsh_index = abs(j) % MAX_WRD;
  757.     found = FALSE;
  758.     d = 1;
  759.     do
  760.         {
  761.         idptr = id_vector[hsh_index];
  762.         if (idptr == NULL)
  763.         {
  764.             id_cnt++;
  765.             idptr = id_vector[hsh_index] = alloc_id(p_token);
  766.             chain_alpha(idptr, p_token);
  767.             idptr->top_lnk = idptr->lst_lnk = alloc_rf(p_ref);
  768.             found = TRUE;
  769.         }
  770.         else
  771.             if (strcmp(p_token, idptr->id_name) == 0)
  772.         {
  773.             idptr->lst_lnk = add_rf(idptr->lst_lnk, p_ref);
  774.             found = TRUE;
  775.         }
  776.         else
  777.             {
  778.             hsh_index += d;
  779.             d += 2;
  780.             rhsh_cnt++;
  781.             if (hsh_index >= MAX_WRD)
  782.                 hsh_index -= MAX_WRD;
  783.             if (d == MAX_WRD)
  784.             {
  785.                 printf("\nERROR: Symbol table overflow\n");
  786.                 exit(0);
  787.             }
  788.         }
  789.     }
  790.     while (!found)
  791.         ;
  792. }
  793.  
  794. chain_alpha(ca_ptr, ca_token)
  795.  
  796. struct id_blk *ca_ptr;
  797. char *ca_token;
  798.  
  799. {
  800.     char c;
  801.     int f;
  802.     struct id_blk *cur_ptr;
  803.     struct id_blk *lst_ptr;
  804.  
  805.     c = ca_token[0];
  806.     if (c == '_')
  807.         c = 0;
  808.     else
  809.         isupper(c) ? c = 1 + ((c - 'A') * 2) : c = 2 + ((c - 'a') * 2);
  810.  
  811.     if (alpha_vector[c].alpha_top == NULL)
  812.     {
  813.         alpha_vector[c].alpha_top =
  814.             alpha_vector[c].alpha_lst = ca_ptr;
  815.         ca_ptr->alpha_lnk = NULL;
  816.         return;
  817.     }
  818.  
  819.     /* check to see if new id_blk should be inserted between
  820.             the alpha_vector header block and the first id_blk in
  821.             the current alpha chain
  822.             */
  823.  
  824.     if (strcmp(alpha_vector[c].alpha_top->id_name, ca_token) > 0)
  825.     {
  826.         ca_ptr->alpha_lnk = alpha_vector[c].alpha_top;
  827.         alpha_vector[c].alpha_top = ca_ptr;
  828.         return;
  829.     }
  830.  
  831.     if (strcmp(alpha_vector[c].alpha_lst->id_name, ca_token) < 0)
  832.     {
  833.         alpha_vector[c].alpha_lst->alpha_lnk = ca_ptr;
  834.         ca_ptr->alpha_lnk = NULL;
  835.         alpha_vector[c].alpha_lst = ca_ptr;
  836.         return;
  837.     }
  838.  
  839.     cur_ptr = alpha_vector[c].alpha_top;
  840.     while (strcmp(cur_ptr->id_name, ca_token) < 0)
  841.     {
  842.         lst_ptr = cur_ptr;
  843.         cur_ptr = lst_ptr->alpha_lnk;
  844.     }
  845.  
  846.     lst_ptr->alpha_lnk = ca_ptr;
  847.     ca_ptr->alpha_lnk = cur_ptr;
  848.     return;
  849. }
  850.  
  851. struct id_blk *alloc_id(aid_token)
  852. char *aid_token;
  853.  
  854. {
  855.     int ai;
  856.     struct id_blk *aid_ptr;
  857.  
  858.     if ((aid_ptr = alloc(sizeof(oneid))) == 0)
  859.     {
  860.         printf("\nERROR: Unable to allocate identifier block\n");
  861.         exit(0);
  862.     }
  863.     ai = 0;
  864.     do
  865.         {
  866.         aid_ptr->id_name[ai] = aid_token[ai];
  867.     }
  868.     while (aid_token[ai++] != NULL)
  869.         ;
  870.     return (aid_ptr);
  871. }
  872.  
  873. struct rf_blk *alloc_rf(arf_ref)
  874.  
  875. int arf_ref;
  876.  
  877. {
  878.     int ri;
  879.     struct rf_blk *arf_ptr;
  880.  
  881.     if ((arf_ptr = alloc(sizeof(onerf))) == 0)
  882.     {
  883.         printf("\nERROR: Unable to allocate reference block\n");
  884.         exit(0);
  885.     }
  886.     arf_ptr->ref_item[0] = arf_ref;
  887.     arf_ptr->ref_cnt = 1;
  888.     for (ri = 1; ri < MAX_REF; ri++)
  889.         arf_ptr->ref_item[ri] = NULL;
  890.     return (arf_ptr);
  891. }
  892.  
  893. struct rf_blk *add_rf(adr_ptr, adr_ref)
  894.  
  895. struct rf_blk *adr_ptr;
  896. int adr_ref;
  897.  
  898. {
  899.     struct rf_blk *tmp_ptr;
  900.  
  901.     tmp_ptr = adr_ptr;
  902.     if (adr_ptr->ref_cnt == MAX_REF)
  903.     {
  904.         tmp_ptr = adr_ptr->ref_cnt = alloc_rf(adr_ref);
  905.     }
  906.     else
  907.         {
  908.         adr_ptr->ref_item[adr_ptr->ref_cnt++] = adr_ref;
  909.     }
  910.     return (tmp_ptr);
  911. }
  912.  
  913. prnt_tbl()
  914. {
  915.     int prf_cnt;
  916.     int pti;
  917.     int pref;
  918.     int lin_cnt;
  919.     struct id_blk *pid_ptr;
  920.     struct rf_blk *ptb_ptr;
  921.  
  922.     prt_ref = TRUE;
  923.     prt_hdr();
  924.     for (pti = 0; pti < MAX_ALPHA; pti++)
  925.     {
  926.         if ((pid_ptr = alpha_vector[pti].alpha_top) != NULL)
  927.         {
  928.             do
  929.                 {
  930.                 if (o_flg)
  931.                 {
  932.                     if (fprintf(l_buffer, "%-14.13s: ", pid_ptr->id_name) == ERROR)
  933.                         lst_err();
  934.                 }
  935.                 else
  936.                     printf("%-14.13s: ", pid_ptr->id_name);
  937.                 ptb_ptr = pid_ptr->top_lnk;
  938.                 lin_cnt = prf_cnt = 0;
  939.                 do
  940.                     {
  941.                     if (prf_cnt == MAX_REF)
  942.                     {
  943.                         prf_cnt = 0;
  944.                         ptb_ptr = ptb_ptr->ref_cnt;
  945.                     }
  946.                     if (ptb_ptr > MAX_REF)
  947.                     {
  948.                         if ((pref = ptb_ptr->ref_item[prf_cnt++]) != 0)
  949.                         {
  950.                             if (o_flg)
  951.                             {
  952.                                 if (fprintf(l_buffer, "%d\t", pref) == ERROR)
  953.                                     lst_err();
  954.                             }
  955.                             else
  956.                                 printf("%d\t", pref);
  957.                             if (++lin_cnt == REFS_PER_LINE)
  958.                             {
  959.                                 nl();
  960.                                 if (o_flg)
  961.                                 {
  962.                                     if (fprintf(l_buffer, "\t\t") == ERROR)
  963.                                         lst_err();
  964.                                 }
  965.                                 else
  966.                                     printf("\t\t");
  967.                                 lin_cnt = 0;
  968.                             }
  969.                         }
  970.                     }
  971.                     else
  972.                         pref = 0;
  973.                 }
  974.                 while (pref)
  975.                     ;
  976.                 if (lin_cnt = 0)
  977.                     nl();
  978.                 else
  979.                 {
  980.                     nl();
  981.                     nl();
  982.                 }
  983.             }
  984.             while ((pid_ptr = pid_ptr->alpha_lnk) != NULL)
  985.                 ;
  986.         }
  987.     }
  988. }
  989.  
  990. prt_hdr()
  991.  
  992. {
  993.     if (pagno++ != 0)
  994.         if (o_flg)
  995.         {
  996.             if (fprintf(l_buffer, "%c", FF) == ERROR)
  997.                 lst_err();
  998.         }
  999.     else
  1000.         printf("%c", FF);
  1001.     if (o_flg)
  1002.     {
  1003.         if (fprintf(l_buffer,
  1004.         "XC ... 'C' Concordance Utility : %s\t\t\t\t Page %d",
  1005.         gbl_fil, pagno) == ERROR) lst_err();
  1006.     }
  1007.     else
  1008.         printf("XC ... 'C' Concordance Utility : %s\t\t\t\t Page %d",
  1009.         gbl_fil, pagno);
  1010.     if (o_flg)
  1011.     {
  1012.         if (fprintf(l_buffer, "\n\n") == ERROR)
  1013.             lst_err();
  1014.     }
  1015.     else
  1016.         printf("\n\n");
  1017.     nl();
  1018.     paglin = 3;
  1019.     return;
  1020. }
  1021.  
  1022. nl()
  1023.  
  1024. {
  1025.     char_count = 1;
  1026.     if (o_flg)
  1027.     {
  1028.         if (fprintf(l_buffer, "\n") == ERROR)
  1029.             lst_err();
  1030.     }
  1031.     else
  1032.         printf("\n");
  1033.     if (++paglin >= LINES_PER_PAGE)
  1034.     {
  1035.         paglin = 0;
  1036.         prt_hdr();
  1037.     }
  1038.     else
  1039.         if (!prt_ref)
  1040.     {
  1041.         if (o_flg)
  1042.         {
  1043.             if (fprintf(l_buffer, "%-4.4d.%4.4d:\t", ++linum, ++edtnum) == ERROR)
  1044.                 lst_err();
  1045.         }
  1046.         else
  1047.             printf("%-4.4d.%4.4d:\t", ++linum, ++edtnum);
  1048.         if (o_flg)
  1049.             if (linum % 60 == 1)
  1050.                 printf("\n<%d>\t", linum);
  1051.         else
  1052.             printf(".");
  1053.     }
  1054.     return;
  1055. }
  1056.  
  1057.