Annotation of src/usr.bin/lex/sym.c, Revision 1.1.1.1
1.1 deraadt 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: /a/cvsroot/src/usr.bin/lex/sym.c,v 1.7 1995/05/05 05:35:42 jtc 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]) != 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: }
![[BACK]](/icons/back.gif){kind=icon}
Return to sym.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / lex