Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/lex/sym.c	Lines:	46	59	78.0 %
Date:	2017-11-13	Branches:	15	20	75.0 %


/*	$OpenBSD: sym.c,v 1.9 2015/11/19 23:34:56 mmcc Exp $	*/

/* sym - symbol table routines */

/*  Copyright (c) 1990 The Regents of the University of California. */
/*  All rights reserved. */

/*  This code is derived from software contributed to Berkeley by */
/*  Vern Paxson. */

/*  The United States Government has rights in this work pursuant */
/*  to contract no. DE-AC03-76SF00098 between the United States */
/*  Department of Energy and the University of California. */

/*  This file is part of flex. */

/*  Redistribution and use in source and binary forms, with or without */
/*  modification, are permitted provided that the following conditions */
/*  are met: */

/*  1. Redistributions of source code must retain the above copyright */
/*     notice, this list of conditions and the following disclaimer. */
/*  2. Redistributions in binary form must reproduce the above copyright */
/*     notice, this list of conditions and the following disclaimer in the */
/*     documentation and/or other materials provided with the distribution. */

/*  Neither the name of the University nor the names of its contributors */
/*  may be used to endorse or promote products derived from this software */
/*  without specific prior written permission. */

/*  THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
/*  IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
/*  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
/*  PURPOSE. */

#include "flexdef.h"

/* Variables for symbol tables:
 * sctbl - start-condition symbol table
 * ndtbl - name-definition symbol table
 * ccltab - character class text symbol table
 */

struct hash_entry {
	struct hash_entry *prev, *next;
	char   *name;
	char   *str_val;
	int     int_val;
};

typedef struct hash_entry **hash_table;

#define NAME_TABLE_HASH_SIZE 101
#define START_COND_HASH_SIZE 101
#define CCL_HASH_SIZE 101

static struct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE];
static struct hash_entry *sctbl[START_COND_HASH_SIZE];
static struct hash_entry *ccltab[CCL_HASH_SIZE];


/* declare functions that have forward references */

static int addsym PROTO ((char[], char *, int, hash_table, int));
static struct hash_entry *findsym PROTO ((const char *sym,
					  hash_table table,

					  int table_size));
static int hashfunct PROTO ((const char *, int));


/* addsym - add symbol and definitions to symbol table
 *
 * -1 is returned if the symbol already exists, and the change not made.
 */

static int addsym (sym, str_def, int_def, table, table_size)
     char sym[];
     char   *str_def;
     int     int_def;
     hash_table table;
     int     table_size;
{
	int     hash_val = hashfunct (sym, table_size);
	struct hash_entry *sym_entry = table[hash_val];
	struct hash_entry *new_entry;
	struct hash_entry *successor;

	while (sym_entry) {
		if (!strcmp (sym, sym_entry->name)) {	/* entry already exists */
			return -1;
		}

		sym_entry = sym_entry->next;
	}

	/* create new entry */
	new_entry = (struct hash_entry *)
		malloc (sizeof (struct hash_entry));

	if (new_entry == NULL)
		flexfatal (_("symbol table memory allocation failed"));

	if ((successor = table[hash_val]) != 0) {
		new_entry->next = successor;
		successor->prev = new_entry;
	}
	else
		new_entry->next = NULL;

	new_entry->prev = NULL;
	new_entry->name = sym;
	new_entry->str_val = str_def;
	new_entry->int_val = int_def;

	table[hash_val] = new_entry;

	return 0;
}


/* cclinstal - save the text of a character class */

void    cclinstal (ccltxt, cclnum)
     u_char    ccltxt[];
     int     cclnum;
{
	/* We don't bother checking the return status because we are not
	 * called unless the symbol is new.
	 */

	(void) addsym ((char *) copy_unsigned_string (ccltxt),
		       (char *) 0, cclnum, ccltab, CCL_HASH_SIZE);
}


/* ccllookup - lookup the number associated with character class text
 *
 * Returns 0 if there's no CCL associated with the text.
 */

int     ccllookup (ccltxt)
     u_char    ccltxt[];
{
	return findsym ((char *) ccltxt, ccltab, CCL_HASH_SIZE)->int_val;
}


/* findsym - find symbol in symbol table */

static struct hash_entry *findsym (sym, table, table_size)
     const char *sym;
     hash_table table;
     int     table_size;
{
	static struct hash_entry empty_entry = {
		(struct hash_entry *) 0, (struct hash_entry *) 0,
		(char *) 0, (char *) 0, 0,
	};
	struct hash_entry *sym_entry =

		table[hashfunct (sym, table_size)];

	while (sym_entry) {
		if (!strcmp (sym, sym_entry->name))
			return sym_entry;
		sym_entry = sym_entry->next;
	}

	return &empty_entry;
}

/* hashfunct - compute the hash value for "str" and hash size "hash_size" */

static int hashfunct (str, hash_size)
     const char *str;
     int     hash_size;
{
	int hashval;
	int locstr;

	hashval = 0;
	locstr = 0;

	while (str[locstr]) {
		hashval = (hashval << 1) + (unsigned char) str[locstr++];
		hashval %= hash_size;
	}

	return hashval;
}


/* ndinstal - install a name definition */

void    ndinstal (name, definition)
     const char *name;
     u_char    definition[];
{

	if (addsym (copy_string (name),
		    (char *) copy_unsigned_string (definition), 0,
		    ndtbl, NAME_TABLE_HASH_SIZE))
			synerr (_("name defined twice"));
}


/* ndlookup - lookup a name definition
 *
 * Returns a nil pointer if the name definition does not exist.
 */

u_char   *ndlookup (nd)
     const char *nd;
{
	return (u_char *) findsym (nd, ndtbl, NAME_TABLE_HASH_SIZE)->str_val;
}


/* scextend - increase the maximum number of start conditions */

void    scextend ()
{
	current_max_scs += MAX_SCS_INCREMENT;

	++num_reallocs;

	scset = reallocate_integer_array (scset, current_max_scs);
	scbol = reallocate_integer_array (scbol, current_max_scs);
	scxclu = reallocate_integer_array (scxclu, current_max_scs);
	sceof = reallocate_integer_array (sceof, current_max_scs);
	scname = reallocate_char_ptr_array (scname, current_max_scs);
}


/* scinstal - make a start condition
 *
 * NOTE
 *    The start condition is "exclusive" if xcluflg is true.
 */

void    scinstal (str, xcluflg)
     const char *str;
     int     xcluflg;
{

	if (++lastsc >= current_max_scs)
		scextend ();

	scname[lastsc] = copy_string (str);

	if (addsym (scname[lastsc], (char *) 0, lastsc,
		    sctbl, START_COND_HASH_SIZE))
			format_pinpoint_message (_
						 ("start condition %s declared twice"),
str);

	scset[lastsc] = mkstate (SYM_EPSILON);
	scbol[lastsc] = mkstate (SYM_EPSILON);
	scxclu[lastsc] = xcluflg;
	sceof[lastsc] = false;
}


/* sclookup - lookup the number associated with a start condition
 *
 * Returns 0 if no such start condition.
 */

int     sclookup (str)
     const char *str;
{
	return findsym (str, sctbl, START_COND_HASH_SIZE)->int_val;
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: sym.c,v 1.9 2015/11/19 23:34:56 mmcc Exp $ */
2
3			/* sym - symbol table routines */
4
5			/* Copyright (c) 1990 The Regents of the University of California. */
6			/* All rights reserved. */
7
8			/* This code is derived from software contributed to Berkeley by */
9			/* Vern Paxson. */
10
11			/* The United States Government has rights in this work pursuant */
12			/* to contract no. DE-AC03-76SF00098 between the United States */
13			/* Department of Energy and the University of California. */
14
15			/* This file is part of flex. */
16
17			/* Redistribution and use in source and binary forms, with or without */
18			/* modification, are permitted provided that the following conditions */
19			/* are met: */
20
21			/* 1. Redistributions of source code must retain the above copyright */
22			/* notice, this list of conditions and the following disclaimer. */
23			/* 2. Redistributions in binary form must reproduce the above copyright */
24			/* notice, this list of conditions and the following disclaimer in the */
25			/* documentation and/or other materials provided with the distribution. */
26
27			/* Neither the name of the University nor the names of its contributors */
28			/* may be used to endorse or promote products derived from this software */
29			/* without specific prior written permission. */
30
31			/* THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR */
32			/* IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED */
33			/* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR */
34			/* PURPOSE. */
35
36			#include "flexdef.h"
37
38			/* Variables for symbol tables:
39			* sctbl - start-condition symbol table
40			* ndtbl - name-definition symbol table
41			* ccltab - character class text symbol table
42			*/
43
44			struct hash_entry {
45			struct hash_entry prev, next;
46			char *name;
47			char *str_val;
48			int int_val;
49			};
50
51			typedef struct hash_entry **hash_table;
52
53			#define NAME_TABLE_HASH_SIZE 101
54			#define START_COND_HASH_SIZE 101
55			#define CCL_HASH_SIZE 101
56
57			static struct hash_entry *ndtbl[NAME_TABLE_HASH_SIZE];
58			static struct hash_entry *sctbl[START_COND_HASH_SIZE];
59			static struct hash_entry *ccltab[CCL_HASH_SIZE];
60
61
62			/* declare functions that have forward references */
63
64			static int addsym PROTO ((char[], char *, int, hash_table, int));
65			static struct hash_entry findsym PROTO ((const char sym,
66			hash_table table,
67
68			int table_size));
69			static int hashfunct PROTO ((const char *, int));
70
71
72			/* addsym - add symbol and definitions to symbol table
73			*
74			* -1 is returned if the symbol already exists, and the change not made.
75			*/
76
77			static int addsym (sym, str_def, int_def, table, table_size)
78			char sym[];
79			char *str_def;
80			int int_def;
81			hash_table table;
82			int table_size;
83			{
84		5892	int hash_val = hashfunct (sym, table_size);
85		2946	struct hash_entry *sym_entry = table[hash_val];
86			struct hash_entry *new_entry;
87			struct hash_entry *successor;
88
89	✓✓	6540	while (sym_entry) {
90	✓✓	2768	if (!strcmp (sym, sym_entry->name)) { /* entry already exists */
91		2444	return -1;
92			}
93
94		324	sym_entry = sym_entry->next;
95			}
96
97			/* create new entry */
98		502	new_entry = (struct hash_entry *)
99		502	malloc (sizeof (struct hash_entry));
100
101	✗✓	502	if (new_entry == NULL)
102			flexfatal (_("symbol table memory allocation failed"));
103
104	✓✓	502	if ((successor = table[hash_val]) != 0) {
105		198	new_entry->next = successor;
106		198	successor->prev = new_entry;
107		198	}
108			else
109		304	new_entry->next = NULL;
110
111		502	new_entry->prev = NULL;
112		502	new_entry->name = sym;
113		502	new_entry->str_val = str_def;
114		502	new_entry->int_val = int_def;
115
116		502	table[hash_val] = new_entry;
117
118		502	return 0;
119		2946	}
120
121
122			/* cclinstal - save the text of a character class */
123
124			void cclinstal (ccltxt, cclnum)
125			u_char ccltxt[];
126			int cclnum;
127			{
128			/* We don't bother checking the return status because we are not
129			* called unless the symbol is new.
130			*/
131
132		4956	(void) addsym ((char *) copy_unsigned_string (ccltxt),
133			(char *) 0, cclnum, ccltab, CCL_HASH_SIZE);
134		2478	}
135
136
137			/* ccllookup - lookup the number associated with character class text
138			*
139			* Returns 0 if there's no CCL associated with the text.
140			*/
141
142			int ccllookup (ccltxt)
143			u_char ccltxt[];
144			{
145			return findsym ((char *) ccltxt, ccltab, CCL_HASH_SIZE)->int_val;
146			}
147
148
149			/* findsym - find symbol in symbol table */
150
151			static struct hash_entry *findsym (sym, table, table_size)
152			const char *sym;
153			hash_table table;
154			int table_size;
155			{
156			static struct hash_entry empty_entry = {
157			(struct hash_entry ) 0, (struct hash_entry ) 0,
158			(char ) 0, (char ) 0, 0,
159			};
160			struct hash_entry *sym_entry =
161
162		1880	table[hashfunct (sym, table_size)];
163
164	✓✗	2108	while (sym_entry) {
165	✓✓	1054	if (!strcmp (sym, sym_entry->name))
166		940	return sym_entry;
167		114	sym_entry = sym_entry->next;
168			}
169
170			return &empty_entry;
171		940	}
172
173			/* hashfunct - compute the hash value for "str" and hash size "hash_size" */
174
175			static int hashfunct (str, hash_size)
176			const char *str;
177			int hash_size;
178			{
179			int hashval;
180			int locstr;
181
182			hashval = 0;
183			locstr = 0;
184
185	✓✓	68122	while (str[locstr]) {
186		28232	hashval = (hashval << 1) + (unsigned char) str[locstr++];
187		28232	hashval %= hash_size;
188			}
189
190		3886	return hashval;
191			}
192
193
194			/* ndinstal - install a name definition */
195
196			void ndinstal (name, definition)
197			const char *name;
198			u_char definition[];
199			{
200
201	✗✓	1278	if (addsym (copy_string (name),
202		426	(char *) copy_unsigned_string (definition), 0,
203			ndtbl, NAME_TABLE_HASH_SIZE))
204			synerr (_("name defined twice"));
205		426	}
206
207
208			/* ndlookup - lookup a name definition
209			*
210			* Returns a nil pointer if the name definition does not exist.
211			*/
212
213			u_char *ndlookup (nd)
214			const char *nd;
215			{
216		1720	return (u_char *) findsym (nd, ndtbl, NAME_TABLE_HASH_SIZE)->str_val;
217			}
218
219
220			/* scextend - increase the maximum number of start conditions */
221
222			void scextend ()
223			{
224			current_max_scs += MAX_SCS_INCREMENT;
225
226			++num_reallocs;
227
228			scset = reallocate_integer_array (scset, current_max_scs);
229			scbol = reallocate_integer_array (scbol, current_max_scs);
230			scxclu = reallocate_integer_array (scxclu, current_max_scs);
231			sceof = reallocate_integer_array (sceof, current_max_scs);
232			scname = reallocate_char_ptr_array (scname, current_max_scs);
233			}
234
235
236			/* scinstal - make a start condition
237			*
238			* NOTE
239			* The start condition is "exclusive" if xcluflg is true.
240			*/
241
242			void scinstal (str, xcluflg)
243			const char *str;
244			int xcluflg;
245			{
246
247	✗✓	84	if (++lastsc >= current_max_scs)
248			scextend ();
249
250		42	scname[lastsc] = copy_string (str);
251
252	✗✓	42	if (addsym (scname[lastsc], (char *) 0, lastsc,
253			sctbl, START_COND_HASH_SIZE))
254			format_pinpoint_message (_
255			("start condition %s declared twice"),
256			str);
257
258		42	scset[lastsc] = mkstate (SYM_EPSILON);
259		42	scbol[lastsc] = mkstate (SYM_EPSILON);
260		42	scxclu[lastsc] = xcluflg;
261		42	sceof[lastsc] = false;
262		42	}
263
264
265			/* sclookup - lookup the number associated with a start condition
266			*
267			* Returns 0 if no such start condition.
268			*/
269
270			int sclookup (str)
271			const char *str;
272			{
273		160	return findsym (str, sctbl, START_COND_HASH_SIZE)->int_val;
274			}