usr.bin/lex/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 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: /home/daffy/u0/vern/flex/RCS/sym.c,v 2.19 95/03/04 16:11:04 vern Exp $ */
  30 /* $FreeBSD: src/usr.bin/lex/sym.c,v 1.5 1999/10/27 07:56:47 obrien Exp $ */
  31
  32 #include "flexdef.h"
  33
  34
  35 /* declare functions that have forward references */
  36
  37 int hashfunct PROTO((char[], int));
  38
  39
  40 struct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE];
  41 struct hash_entry *sctbl[START_COND_HASH_SIZE];
  42 struct hash_entry *ccltab[CCL_HASH_SIZE];
  43
  44 struct hash_entry *findsym();
  45
  46
  47 /* addsym - add symbol and definitions to symbol table
  48  *
  49  * -1 is returned if the symbol already exists, and the change not made.
  50  */
  51
  52 int addsym(char *sym, char *str_def, int int_def, hash_table table,
  53            int table_size)
  54         {
  55         int hash_val = hashfunct( sym, table_size );
  56         struct hash_entry *sym_entry = table[hash_val];
  57         struct hash_entry *new_entry;
  58         struct hash_entry *successor;
  59
  60         while ( sym_entry )
  61                 {
  62                 if ( ! strcmp( sym, sym_entry->name ) )
  63                         { /* entry already exists */
  64                         return -1;
  65                         }
  66
  67                 sym_entry = sym_entry->next;
  68                 }
  69
  70         /* create new entry */
  71         new_entry = (struct hash_entry *)
  72                 flex_alloc( sizeof( struct hash_entry ) );
  73
  74         if ( new_entry == NULL )
  75                 flexfatal( _( "symbol table memory allocation failed" ) );
  76
  77         if ( (successor = table[hash_val]) != NULL )
  78                 {
  79                 new_entry->next = successor;
  80                 successor->prev = new_entry;
  81                 }
  82         else
  83                 new_entry->next = NULL;
  84
  85         new_entry->prev = NULL;
  86         new_entry->name = sym;
  87         new_entry->str_val = str_def;
  88         new_entry->int_val = int_def;
  89
  90         table[hash_val] = new_entry;
  91
  92         return 0;
  93         }
  94
  95
  96 /* cclinstal - save the text of a character class */
  97
  98 void cclinstal(Char *ccltxt, int cclnum)
  99         {
 100         /* We don't bother checking the return status because we are not
 101          * called unless the symbol is new.
 102          */
 103         Char *copy_unsigned_string();
 104
 105         (void) addsym( (char *) copy_unsigned_string( ccltxt ),
 106                         NULL, cclnum,
 107                         ccltab, CCL_HASH_SIZE );
 108         }
 109
 110
 111 /* ccllookup - lookup the number associated with character class text
 112  *
 113  * Returns 0 if there's no CCL associated with the text.
 114  */
 115
 116 int ccllookup(Char *ccltxt)
 117         {
 118         return findsym( (char *) ccltxt, ccltab, CCL_HASH_SIZE )->int_val;
 119         }
 120
 121
 122 /* findsym - find symbol in symbol table */
 123
 124 struct hash_entry *findsym(char *sym, hash_table table, int table_size)
 125         {
 126         static struct hash_entry empty_entry =
 127                 {
 128                 NULL, NULL,
 129                 NULL, NULL, 0,
 130                 } ;
 131         struct hash_entry *sym_entry =
 132                 table[hashfunct( sym, table_size )];
 133
 134         while ( sym_entry )
 135                 {
 136                 if ( ! strcmp( sym, sym_entry->name ) )
 137                         return sym_entry;
 138                 sym_entry = sym_entry->next;
 139                 }
 140
 141         return &empty_entry;
 142         }
 143
 144
 145 /* hashfunct - compute the hash value for "str" and hash size "hash_size" */
 146
 147 int hashfunct(char *str, int hash_size)
 148         {
 149         int hashval;
 150         int locstr;
 151
 152         hashval = 0;
 153         locstr = 0;
 154
 155         while ( str[locstr] )
 156                 {
 157                 hashval = (hashval << 1) + (unsigned char) str[locstr++];
 158                 hashval %= hash_size;
 159                 }
 160
 161         return hashval;
 162         }
 163
 164
 165 /* ndinstal - install a name definition */
 166
 167 void ndinstal(char *name, Char *definition)
 168         {
 169         char *copy_string();
 170         Char *copy_unsigned_string();
 171
 172         if ( addsym( copy_string( name ),
 173                         (char *) copy_unsigned_string( definition ), 0,
 174                         ndtbl, NAME_TABLE_HASH_SIZE ) )
 175                 synerr( _( "name defined twice" ) );
 176         }
 177
 178
 179 /* ndlookup - lookup a name definition
 180  *
 181  * Returns a nil pointer if the name definition does not exist.
 182  */
 183
 184 Char *ndlookup(char *nd)
 185         {
 186         return (Char *) findsym( nd, ndtbl, NAME_TABLE_HASH_SIZE )->str_val;
 187         }
 188
 189
 190 /* scextend - increase the maximum number of start conditions */
 191
 192 void scextend(void)
 193         {
 194         current_max_scs += MAX_SCS_INCREMENT;
 195
 196         ++num_reallocs;
 197
 198         scset = reallocate_integer_array( scset, current_max_scs );
 199         scbol = reallocate_integer_array( scbol, current_max_scs );
 200         scxclu = reallocate_integer_array( scxclu, current_max_scs );
 201         sceof = reallocate_integer_array( sceof, current_max_scs );
 202         scname = reallocate_char_ptr_array( scname, current_max_scs );
 203         }
 204
 205
 206 /* scinstal - make a start condition
 207  *
 208  * NOTE
 209  *    The start condition is "exclusive" if xcluflg is true.
 210  */
 211
 212 void scinstal(char *str, int xcluflg)
 213         {
 214         char *copy_string();
 215
 216         /* Generate start condition definition, for use in BEGIN et al. */
 217         action_define( str, lastsc );
 218
 219         if ( ++lastsc >= current_max_scs )
 220                 scextend();
 221
 222         scname[lastsc] = copy_string( str );
 223
 224         if ( addsym( scname[lastsc], NULL, lastsc,
 225                         sctbl, START_COND_HASH_SIZE ) )
 226                 format_pinpoint_message(
 227                                 _( "start condition %s declared twice" ),
 228                                         str );
 229
 230         scset[lastsc] = mkstate( SYM_EPSILON );
 231         scbol[lastsc] = mkstate( SYM_EPSILON );
 232         scxclu[lastsc] = xcluflg;
 233         sceof[lastsc] = false;
 234         }
 235
 236
 237 /* sclookup - lookup the number associated with a start condition
 238  *
 239  * Returns 0 if no such start condition.
 240  */
 241
 242 int sclookup(char *str)
 243         {
 244         return findsym( str, sctbl, START_COND_HASH_SIZE )->int_val;
 245         }