home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 22 gnu / 22-gnu.zip / flex254.zip / sym.c < prev    next >
C/C++ Source or Header  |  1997-07-26  |  6KB  |  263 lines
  1. /* sym - symbol table routines */
  2.  
  3. /*-
  4.  * Copyright (c) 1990 The Regents of the University of California.
  5.  * All rights reserved.
  6.  *
  7.  * This code is derived from software contributed to Berkeley by
  8.  * Vern Paxson.
  9.  * 
  10.  * The United States Government has rights in this work pursuant
  11.  * to contract no. DE-AC03-76SF00098 between the United States
  12.  * Department of Energy and the University of California.
  13.  *
  14.  * Redistribution and use in source and binary forms with or without
  15.  * modification are permitted provided that: (1) source distributions retain
  16.  * this entire copyright notice and comment, and (2) distributions including
  17.  * binaries display the following acknowledgement:  ``This product includes
  18.  * software developed by the University of California, Berkeley and its
  19.  * contributors'' in the documentation or other materials provided with the
  20.  * distribution and in all advertising materials mentioning features or use
  21.  * of this software.  Neither the name of the University nor the names of
  22.  * its contributors may be used to endorse or promote products derived from
  23.  * this software without specific prior written permission.
  24.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  25.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  26.  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  27.  */
  28.  
  29. /* $Header: /home/daffy/u0/vern/flex/RCS/sym.c,v 2.19 95/03/04 16:11:04 vern Exp $ */
  30.  
  31. #include "flexdef.h"
  32.  
  33.  
  34. /* declare functions that have forward references */
  35.  
  36. int hashfunct PROTO((register char[], int));
  37.  
  38.  
  39. struct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE];
  40. struct hash_entry *sctbl[START_COND_HASH_SIZE];
  41. struct hash_entry *ccltab[CCL_HASH_SIZE];
  42.  
  43. struct hash_entry *findsym();
  44.  
  45.  
  46. /* addsym - add symbol and definitions to symbol table
  47.  *
  48.  * -1 is returned if the symbol already exists, and the change not made.
  49.  */
  50.  
  51. int addsym( sym, str_def, int_def, table, table_size )
  52. register char sym[];
  53. char *str_def;
  54. int int_def;
  55. hash_table table;
  56. int table_size;
  57.     {
  58.     int hash_val = hashfunct( sym, table_size );
  59.     register struct hash_entry *sym_entry = table[hash_val];
  60.     register struct hash_entry *new_entry;
  61.     register struct hash_entry *successor;
  62.  
  63.     while ( sym_entry )
  64.         {
  65.         if ( ! strcmp( sym, sym_entry->name ) )
  66.             { /* entry already exists */
  67.             return -1;
  68.             }
  69.  
  70.         sym_entry = sym_entry->next;
  71.         }
  72.  
  73.     /* create new entry */
  74.     new_entry = (struct hash_entry *)
  75.         flex_alloc( sizeof( struct hash_entry ) );
  76.  
  77.     if ( new_entry == NULL )
  78.         flexfatal( _( "symbol table memory allocation failed" ) );
  79.  
  80.     if ( (successor = table[hash_val]) != 0 )
  81.         {
  82.         new_entry->next = successor;
  83.         successor->prev = new_entry;
  84.         }
  85.     else
  86.         new_entry->next = NULL;
  87.  
  88.     new_entry->prev = NULL;
  89.     new_entry->name = sym;
  90.     new_entry->str_val = str_def;
  91.     new_entry->int_val = int_def;
  92.  
  93.     table[hash_val] = new_entry;
  94.  
  95.     return 0;
  96.     }
  97.  
  98.  
  99. /* cclinstal - save the text of a character class */
  100.  
  101. void cclinstal( ccltxt, cclnum )
  102. Char ccltxt[];
  103. int cclnum;
  104.     {
  105.     /* We don't bother checking the return status because we are not
  106.      * called unless the symbol is new.
  107.      */
  108.     Char *copy_unsigned_string();
  109.  
  110.     (void) addsym( (char *) copy_unsigned_string( ccltxt ),
  111.             (char *) 0, cclnum,
  112.             ccltab, CCL_HASH_SIZE );
  113.     }
  114.  
  115.  
  116. /* ccllookup - lookup the number associated with character class text
  117.  *
  118.  * Returns 0 if there's no CCL associated with the text.
  119.  */
  120.  
  121. int ccllookup( ccltxt )
  122. Char ccltxt[];
  123.     {
  124.     return findsym( (char *) ccltxt, ccltab, CCL_HASH_SIZE )->int_val;
  125.     }
  126.  
  127.  
  128. /* findsym - find symbol in symbol table */
  129.  
  130. struct hash_entry *findsym( sym, table, table_size )
  131. register char sym[];
  132. hash_table table;
  133. int table_size;
  134.     {
  135.     static struct hash_entry empty_entry =
  136.         {
  137.         (struct hash_entry *) 0, (struct hash_entry *) 0,
  138.         (char *) 0, (char *) 0, 0,
  139.         } ;
  140.     register struct hash_entry *sym_entry =
  141.         table[hashfunct( sym, table_size )];
  142.  
  143.     while ( sym_entry )
  144.         {
  145.         if ( ! strcmp( sym, sym_entry->name ) )
  146.             return sym_entry;
  147.         sym_entry = sym_entry->next;
  148.         }
  149.  
  150.     return &empty_entry;
  151.     }
  152.  
  153.  
  154. /* hashfunct - compute the hash value for "str" and hash size "hash_size" */
  155.  
  156. int hashfunct( str, hash_size )
  157. register char str[];
  158. int hash_size;
  159.     {
  160.     register int hashval;
  161.     register int locstr;
  162.  
  163.     hashval = 0;
  164.     locstr = 0;
  165.  
  166.     while ( str[locstr] )
  167.         {
  168.         hashval = (hashval << 1) + (unsigned char) str[locstr++];
  169.         hashval %= hash_size;
  170.         }
  171.  
  172.     return hashval;
  173.     }
  174.  
  175.  
  176. /* ndinstal - install a name definition */
  177.  
  178. void ndinstal( name, definition )
  179. char name[];
  180. Char definition[];
  181.     {
  182.     char *copy_string();
  183.     Char *copy_unsigned_string();
  184.  
  185.     if ( addsym( copy_string( name ),
  186.             (char *) copy_unsigned_string( definition ), 0,
  187.             ndtbl, NAME_TABLE_HASH_SIZE ) )
  188.         synerr( _( "name defined twice" ) );
  189.     }
  190.  
  191.  
  192. /* ndlookup - lookup a name definition
  193.  *
  194.  * Returns a nil pointer if the name definition does not exist.
  195.  */
  196.  
  197. Char *ndlookup( nd )
  198. char nd[];
  199.     {
  200.     return (Char *) findsym( nd, ndtbl, NAME_TABLE_HASH_SIZE )->str_val;
  201.     }
  202.  
  203.  
  204. /* scextend - increase the maximum number of start conditions */
  205.  
  206. void scextend()
  207.     {
  208.     current_max_scs += MAX_SCS_INCREMENT;
  209.  
  210.     ++num_reallocs;
  211.  
  212.     scset = reallocate_integer_array( scset, current_max_scs );
  213.     scbol = reallocate_integer_array( scbol, current_max_scs );
  214.     scxclu = reallocate_integer_array( scxclu, current_max_scs );
  215.     sceof = reallocate_integer_array( sceof, current_max_scs );
  216.     scname = reallocate_char_ptr_array( scname, current_max_scs );
  217.     }
  218.  
  219.  
  220. /* scinstal - make a start condition
  221.  *
  222.  * NOTE
  223.  *    The start condition is "exclusive" if xcluflg is true.
  224.  */
  225.  
  226. void scinstal( str, xcluflg )
  227. char str[];
  228. int xcluflg;
  229.     {
  230.     char *copy_string();
  231.  
  232.     /* Generate start condition definition, for use in BEGIN et al. */
  233.     action_define( str, lastsc );
  234.  
  235.     if ( ++lastsc >= current_max_scs )
  236.         scextend();
  237.  
  238.     scname[lastsc] = copy_string( str );
  239.  
  240.     if ( addsym( scname[lastsc], (char *) 0, lastsc,
  241.             sctbl, START_COND_HASH_SIZE ) )
  242.         format_pinpoint_message(
  243.                 _( "start condition %s declared twice" ),
  244.                     str );
  245.  
  246.     scset[lastsc] = mkstate( SYM_EPSILON );
  247.     scbol[lastsc] = mkstate( SYM_EPSILON );
  248.     scxclu[lastsc] = xcluflg;
  249.     sceof[lastsc] = false;
  250.     }
  251.  
  252.  
  253. /* sclookup - lookup the number associated with a start condition
  254.  *
  255.  * Returns 0 if no such start condition.
  256.  */
  257.  
  258. int sclookup( str )
  259. char str[];
  260.     {
  261.     return findsym( str, sctbl, START_COND_HASH_SIZE )->int_val;
  262.     }
  263.