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
addsym(sym,str_def,int_def,table,table_size)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
cclinstal(ccltxt,cclnum)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
ccllookup(ccltxt)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
findsym(sym,table,table_size)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
hashfunct(str,hash_size)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
ndinstal(name,definition)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
ndlookup(nd)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
scextend()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
scinstal(str,xcluflg)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
sclookup(str)258 int sclookup( str )
259 char str[];
260 {
261 return findsym( str, sctbl, START_COND_HASH_SIZE )->int_val;
262 }
263