commands/flex-2.5.4/sym.c

   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$ */
  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         }