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: /projects/cvsroot/src/router/flex/sym.c,v 1.1.1.1 2001/04/08 23:53:37 mhuang Exp $ */
30
31#include "flexdef.h"
32
33
34/* declare functions that have forward references */
35
36int hashfunct PROTO((register char[], int));
37
38
39struct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE];
40struct hash_entry *sctbl[START_COND_HASH_SIZE];
41struct hash_entry *ccltab[CCL_HASH_SIZE];
42
43struct 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
51int addsym( sym, str_def, int_def, table, table_size )
52register char sym[];
53char *str_def;
54int int_def;
55hash_table table;
56int 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
101void cclinstal( ccltxt, cclnum )
102Char ccltxt[];
103int 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
121int ccllookup( ccltxt )
122Char ccltxt[];
123	{
124	return findsym( (char *) ccltxt, ccltab, CCL_HASH_SIZE )->int_val;
125	}
126
127
128/* findsym - find symbol in symbol table */
129
130struct hash_entry *findsym( sym, table, table_size )
131register char sym[];
132hash_table table;
133int 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
156int hashfunct( str, hash_size )
157register char str[];
158int 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
178void ndinstal( name, definition )
179char name[];
180Char 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
197Char *ndlookup( nd )
198char 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
206void 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
226void scinstal( str, xcluflg )
227char str[];
228int 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
258int sclookup( str )
259char str[];
260	{
261	return findsym( str, sctbl, START_COND_HASH_SIZE )->int_val;
262	}
263