home *** CD-ROM | disk | FTP | other *** search
/ Fresh Fish 4 / FreshFish_May-June1994.bin / bbs / gnu / flex-2.4.6-src.lha / src / amiga / flex-2.4.6 / sym.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-01-05  |  6.1 KB  |  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 are permitted provided
  15.  * that: (1) source distributions retain this entire copyright notice and
  16.  * comment, and (2) distributions including binaries display the following
  17.  * acknowledgement:  ``This product includes software developed by the
  18.  * University of California, Berkeley and its contributors'' in the
  19.  * documentation or other materials provided with the distribution and in
  20.  * all advertising materials mentioning features or use of this software.
  21.  * Neither the name of the University nor the names of its contributors may
  22.  * be used to endorse or promote products derived from this software without
  23.  * 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: sym.c,v 1.2 94/01/04 14:33:06 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]) )
  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.     actvsc = reallocate_integer_array( actvsc, current_max_scs );
  218.     }
  219.  
  220.  
  221. /* scinstal - make a start condition
  222.  *
  223.  * NOTE
  224.  *    The start condition is "exclusive" if xcluflg is true.
  225.  */
  226.  
  227. void scinstal( str, xcluflg )
  228. char str[];
  229. int xcluflg;
  230.     {
  231.     char *copy_string();
  232.  
  233.     /* Generate start condition definition, for use in BEGIN et al. */
  234.     printf( "#define %s %d\n", str, lastsc );
  235.  
  236.     if ( ++lastsc >= current_max_scs )
  237.         scextend();
  238.  
  239.     scname[lastsc] = copy_string( str );
  240.  
  241.     if ( addsym( scname[lastsc], (char *) 0, lastsc,
  242.             sctbl, START_COND_HASH_SIZE ) )
  243.         format_pinpoint_message( "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.