 @@ -1,14 +1,14 @@
-/* $NetBSD: lex.c,v 1.103 2022/02/27 18:29:14 rillig Exp $ */
+/* $NetBSD: lex.c,v 1.104 2022/02/27 22:26:12 rillig Exp $ */
 /*
  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
  * Copyright (c) 1994, 1995 Jochen Pohl
  * All Rights Reserved.
+ *
  * 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
 @@ -28,27 +28,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID) && !defined(lint)
-__RCSID("$NetBSD: lex.c,v 1.103 2022/02/27 18:29:14 rillig Exp $");
+__RCSID("$NetBSD: lex.c,v 1.104 2022/02/27 22:26:12 rillig Exp $");
 #endif
 #include <ctype.h>
 #include <errno.h>
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 #include "cgram.h"
 @@ -58,28 +58,26 @@ __RCSID("$NetBSD: lex.c,v 1.103 2022/02/
 /* Current position (it's also updated when an included file is parsed) */
 pos_t	curr_pos = { "", 1, 0 };
 /*
  * Current position in C source (not updated when an included file is
  * parsed).
  */
 pos_t	csrc_pos = { "", 1, 0 };
 bool in_gcc_attribute;
 bool in_system_header;
 static	int	inpc(void);
 static	unsigned int hash(const char *);
 static	sym_t *	search(sbuf_t *);
 static	int	keyw(sym_t *);
 static	int	get_escaped_char(int);
 void
 lex_next_line(void)
+{
 	curr_pos.p_line++;
 	curr_pos.p_uniq = 0;
 	debug_step("parsing %s:%d", curr_pos.p_file, curr_pos.p_line);
 	if (curr_pos.p_file == csrc_pos.p_file) {
 		csrc_pos.p_line++;
 		csrc_pos.p_uniq = 0;
+	}
 @@ -250,47 +248,95 @@ static struct keyword {
 #undef kwdef_type
 #undef kwdef_tqual
 #undef kwdef_keyword
 #undef kwdef_gcc_attr
 };
 /* Symbol table */
 static	sym_t	*symtab[HSHSIZ1];
 /* type of next expected symbol */
 symt_t	symtyp;
 static unsigned int
 hash(const char *s)
+{
 	unsigned int v;
 	const char *p;
 	v = 0;
 	for (p = s; *p != '\0'; p++) {
 		v = (v << 4) + (unsigned char)*p;
 		v ^= v >> 28;
+	}
 	return v % HSHSIZ1;
+}
 static void
 symtab_add(sym_t *sym)
+{
-	size_t h;
+	unsigned int h;
 	h = hash(sym->s_name);
 	if ((sym->s_symtab_next = symtab[h]) != NULL)
 		symtab[h]->s_symtab_ref = &sym->s_symtab_next;
 	sym->s_symtab_ref = &symtab[h];
 	symtab[h] = sym;
+}
 static sym_t *
 symtab_search(sbuf_t *sb)
+{
 	unsigned int h = hash(sb->sb_name);
 	for (sym_t *sym = symtab[h]; sym != NULL; sym = sym->s_symtab_next) {
 		if (strcmp(sym->s_name, sb->sb_name) != 0)
 			continue;
 		const struct keyword *kw = sym->s_keyword;
 		if (kw != NULL && !kw->kw_attr)
 			return sym;
 		if (kw != NULL && in_gcc_attribute)
 			return sym;
 		if (kw == NULL && !in_gcc_attribute && sym->s_kind == symtyp)
 			return sym;
+	}
 	return NULL;
+}
 static void
 symtab_remove(sym_t *sym)
+{
 	if ((*sym->s_symtab_ref = sym->s_symtab_next) != NULL)
 		sym->s_symtab_next->s_symtab_ref = sym->s_symtab_ref;
 	sym->s_symtab_next = NULL;
+}
 static void
 symtab_remove_locals(void)
+{
 	for (size_t i = 0; i < HSHSIZ1; i++) {
 		for (sym_t *sym = symtab[i]; sym != NULL; ) {
 			sym_t *next = sym->s_symtab_next;
 			if (sym->s_block_level >= 1)
 				symtab_remove(sym);
 			sym = next;
+		}
+	}
+}
 static void
 add_keyword(const struct keyword *kw, bool leading, bool trailing)
+{
 	sym_t *sym;
 	char buf[256];
 	const char *name;
 	if (!leading && !trailing) {
 		name = kw->kw_name;
 	} else {
 		(void)snprintf(buf, sizeof(buf), "%s%s%s",
 		    leading ? "__" : "", kw->kw_name, trailing ? "__" : "");
 @@ -346,112 +392,74 @@ inpc(void)
+{
 	int	c;
 	if ((c = lex_input()) == EOF)
 		return c;
 	c &= CHAR_MASK;
 	if (c == '\0')
 		return EOF;	/* lex returns 0 on EOF. */
 	if (c == '\n')
 		lex_next_line();
 	return c;
+}
 static unsigned int
 hash(const char *s)
 	unsigned int v;
 	const char *p;
 	v = 0;
 	for (p = s; *p != '\0'; p++) {
 		v = (v << 4) + (unsigned char)*p;
 		v ^= v >> 28;
 	return v % HSHSIZ1;
 /*
  * Lex has found a letter followed by zero or more letters or digits.
  * It looks for a symbol in the symbol table with the same name. This
  * symbol must either be a keyword or a symbol of the type required by
  * symtyp (label, member, tag, ...).
+ *
  * If it is a keyword, the token is returned. In some cases it is described
  * more deeply by data written to yylval.
+ *
  * If it is a symbol, T_NAME is returned and the name is stored in yylval.
  * If there is already a symbol of the same name and type in the symbol
  * table, yylval.y_name->sb_sym points there.
  */
 extern int
 lex_name(const char *yytext, size_t yyleng)
+{
 	char	*s;
 	sbuf_t	*sb;
 	sym_t	*sym;
 	int	tok;
 	sb = xmalloc(sizeof(*sb));
 	sb->sb_name = yytext;
 	sb->sb_len = yyleng;
-	if ((sym = search(sb)) != NULL && sym->s_keyword != NULL) {
+	if ((sym = symtab_search(sb)) != NULL && sym->s_keyword != NULL) {
 		free(sb);
 		return keyw(sym);
+	}
 	sb->sb_sym = sym;
 	if (sym != NULL) {
 		lint_assert(block_level >= sym->s_block_level);
 		sb->sb_name = sym->s_name;
 		sb->sb_len = strlen(sym->s_name);
 		tok = sym->s_scl == TYPEDEF ? T_TYPENAME : T_NAME;
 	} else {
 		s = block_zero_alloc(yyleng + 1);
 		(void)memcpy(s, yytext, yyleng + 1);
 		sb->sb_name = s;
 		sb->sb_len = yyleng;
 		tok = T_NAME;
+	}
 	yylval.y_name = sb;
 	return tok;
+}
 static sym_t *
 search(sbuf_t *sb)
 	unsigned int h;
 	sym_t *sym;
 	const struct keyword *kw;
 	h = hash(sb->sb_name);
 	for (sym = symtab[h]; sym != NULL; sym = sym->s_symtab_next) {
 		if (strcmp(sym->s_name, sb->sb_name) != 0)
 			continue;
 		kw = sym->s_keyword;
 		if (kw != NULL && !kw->kw_attr)
 			return sym;
 		if (kw != NULL && in_gcc_attribute)
 			return sym;
 		if (kw == NULL && !in_gcc_attribute && sym->s_kind == symtyp)
 			return sym;
 	return NULL;
 static int
 keyw(sym_t *sym)
+{
 	int	t;
 	if ((t = (int)sym->s_value.v_quad) == T_SCLASS) {
 		yylval.y_scl = sym->s_scl;
 	} else if (t == T_TYPE || t == T_STRUCT_OR_UNION) {
 		yylval.y_tspec = sym->s_tspec;
 	} else if (t == T_QUAL) {
 		yylval.y_tqual = sym->s_tqual;
+	}
 	return t;
 @@ -1328,27 +1336,27 @@ getsym(sbuf_t *sb)
 	char	*s;
 	sym_t	*sym;
 	sym = sb->sb_sym;
 	/*
 	 * During member declaration it is possible that name() looked
 	 * for symbols of type FVFT, although it should have looked for
 	 * symbols of type FTAG. Same can happen for labels. Both cases
 	 * are compensated here.
 	 */
 	if (symtyp == FMEMBER || symtyp == FLABEL) {
 		if (sym == NULL || sym->s_kind == FVFT)
-			sym = search(sb);
+			sym = symtab_search(sb);
+	}
 	if (sym != NULL) {
 		lint_assert(sym->s_kind == symtyp);
 		symtyp = FVFT;
 		free(sb);
 		return sym;
+	}
 	/* create a new symbol table entry */
 	/* labels must always be allocated at level 1 (outermost block) */
 	if (symtyp == FLABEL) {
 @@ -1465,38 +1473,30 @@ inssym(int bl, sym_t *sym)
 		    sym->s_block_level >= sym->s_symtab_next->s_block_level);
+}
 /*
  * Called at level 0 after syntax errors.
+ *
  * Removes all symbols which are not declared at level 0 from the
  * symbol table. Also frees all memory which is not associated with
  * level 0.
  */
 void
 cleanup(void)
+{
 	sym_t	*sym, *nsym;
 	size_t	i;
-	for (i = 0; i < HSHSIZ1; i++) {
+	symtab_remove_locals();
 		for (sym = symtab[i]; sym != NULL; sym = nsym) {
 			nsym = sym->s_symtab_next;
 			if (sym->s_block_level >= 1)
 				symtab_remove(sym);
-	for (i = mem_block_level; i > 0; i--)
+	for (size_t i = mem_block_level; i > 0; i--)
 		level_free_all(i);
+}
 /*
  * Create a new symbol with the name of an existing symbol.
  */
 sym_t *
 pushdown(const sym_t *sym)
+{
 	sym_t	*nsym;
 	debug_step("pushdown '%s' %s '%s'",
 	    sym->s_name, symt_name(sym->s_kind), type_name(sym->s_type));