 @@ -1,14 +1,14 @@
-/* $NetBSD: decl.c,v 1.247 2022/02/27 10:31:58 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.248 2022/02/27 10:44:45 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: decl.c,v 1.247 2022/02/27 10:31:58 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.248 2022/02/27 10:44:45 rillig Exp $");
 #endif
 #include <sys/param.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 const	char *unnamed = "<unnamed>";
 /* shared type structures for arithmetic types and void */
 static	type_t	*typetab;
 @@ -1430,27 +1430,27 @@ add_function(sym_t *decl, sym_t *args)
  * Called for new style function declarations.
  */
 /* ARGSUSED */
 static sym_t *
 new_style_function(sym_t *decl, sym_t *args)
+{
 	sym_t	*arg, *sym;
 	scl_t	sc;
 	/*
 	 * Declarations of structs/unions/enums in param lists are legal,
 	 * but senseless.
 	 */
-	for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_dlnxt) {
+	for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_level_next) {
 		sc = sym->s_scl;
 		if (sc == STRUCT_TAG || sc == UNION_TAG || sc == ENUM_TAG) {
 			/* dubious tag declaration: %s %s */
 			warning(85, storage_class_name(sc), sym->s_name);
+		}
+	}
 	for (arg = args; arg != NULL; arg = arg->s_next) {
 		if (arg->s_type->t_tspec == VOID &&
 		    !(arg == args && arg->s_next == NULL)) {
 			/* void must be sole parameter */
 			error(60);
 			arg->s_type = gettyp(INT);
 @@ -2766,27 +2766,27 @@ declare_local(sym_t *dsym, bool initflg)
 /*
  * Processes (re)declarations of external symbols inside blocks.
  */
 static void
 declare_external_in_block(sym_t *dsym)
+{
 	bool	eqt, dowarn;
 	sym_t	*esym;
 	/* look for a symbol with the same name */
 	esym = dcs->d_redeclared_symbol;
 	while (esym != NULL && esym->s_block_level != 0) {
-		while ((esym = esym->s_link) != NULL) {
+		while ((esym = esym->s_symtab_next) != NULL) {
 			if (esym->s_kind != FVFT)
 				continue;
 			if (strcmp(dsym->s_name, esym->s_name) == 0)
 				break;
+		}
+	}
 	if (esym == NULL)
 		return;
 	if (esym->s_scl != EXTERN && esym->s_scl != STATIC) {
 		/* gcc accepts this without a warning, pcc prints an error. */
 		/* redeclaration of %s */
 		warning(27, dsym->s_name);
 		print_previous_declaration(-1, esym);
 @@ -2974,40 +2974,40 @@ mark_as_used(sym_t *sym, bool fcall, boo
 	/*
 	 * for function calls another record is written
+	 *
 	 * XXX Should symbols used in sizeof() be treated as used or not?
 	 * Probably not, because there is no sense to declare an
 	 * external variable only to get their size.
 	 */
 	if (!fcall && !szof && sym->s_kind == FVFT && sym->s_scl == EXTERN)
 		outusg(sym);
+}
 /*
  * Prints warnings for a list of variables and labels (concatenated
- * with s_dlnxt) if these are not used or only set.
+ * with s_level_next) if these are not used or only set.
  */
 void
 check_usage(dinfo_t *di)
+{
 	sym_t	*sym;
 	int	mklwarn;
 	/* for this warning LINTED has no effect */
 	mklwarn = lwarn;
 	lwarn = LWARN_ALL;
 	debug_step("begin lwarn %d", lwarn);
-	for (sym = di->d_dlsyms; sym != NULL; sym = sym->s_dlnxt)
+	for (sym = di->d_dlsyms; sym != NULL; sym = sym->s_level_next)
 		check_usage_sym(di->d_asm, sym);
 	lwarn = mklwarn;
 	debug_step("end lwarn %d", lwarn);
+}
 /*
  * Prints a warning for a single variable or label if it is not used or
  * only set.
  */
 void
 check_usage_sym(bool novar, sym_t *sym)
+{
 @@ -3160,27 +3160,27 @@ check_tag_usage(sym_t *sym)
  * Performs some tests on global symbols. Detected problems are:
  * - defined variables of incomplete type
  * - constant variables which are not initialized
  * - static symbols which are never used
  */
 void
 check_global_symbols(void)
+{
 	sym_t	*sym;
 	if (block_level != 0 || dcs->d_next != NULL)
 		norecover();
-	for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_dlnxt) {
+	for (sym = dcs->d_dlsyms; sym != NULL; sym = sym->s_level_next) {
 		if (sym->s_block_level == -1)
 			continue;
 		if (sym->s_kind == FVFT) {
 			check_global_variable(sym);
 		} else if (sym->s_kind == FTAG) {
 			check_tag_usage(sym);
 		} else {
 			lint_assert(sym->s_kind == FMEMBER);
+		}
+	}
+}
 static void

 @@ -1,14 +1,14 @@
-/*	$NetBSD: func.c,v 1.127 2022/02/27 08:31:26 rillig Exp $	*/
+/*	$NetBSD: func.c,v 1.128 2022/02/27 10:44:45 rillig Exp $	*/
 /*
  * 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
  *    documentation and/or other materials provided with the distribution.
 @@ -27,27 +27,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: func.c,v 1.127 2022/02/27 08:31:26 rillig Exp $");
+__RCSID("$NetBSD: func.c,v 1.128 2022/02/27 10:44:45 rillig Exp $");
 #endif
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 #include "cgram.h"
 /*
  * Contains a pointer to the symbol table entry of the current function
  * definition.
  */
 sym_t	*funcsym;
 @@ -225,27 +225,28 @@ check_statement_reachable(void)
 void
 funcdef(sym_t *fsym)
+{
 	int	n;
 	bool	dowarn;
 	sym_t	*arg, *sym, *rdsym;
 	funcsym = fsym;
 	/*
 	 * Put all symbols declared in the argument list back to the
 	 * symbol table.
 	 */
-	for (sym = dcs->d_func_proto_syms; sym != NULL; sym = sym->s_dlnxt) {
+	for (sym = dcs->d_func_proto_syms; sym != NULL;
 	    sym = sym->s_level_next) {
 		if (sym->s_block_level != -1) {
 			lint_assert(sym->s_block_level == 1);
 			inssym(1, sym);
+		}
+	}
 	/*
 	 * In old_style_function() we did not know whether it is an old
 	 * style function definition or only an old style declaration,
 	 * if there are no arguments inside the argument list ("f()").
 	 */
 	if (!fsym->s_type->t_proto && fsym->s_args == NULL)
 		fsym->s_osdef = true;

 @@ -1,14 +1,14 @@
-/* $NetBSD: lex.c,v 1.101 2022/02/27 08:31:26 rillig Exp $ */
+/* $NetBSD: lex.c,v 1.102 2022/02/27 10:44:45 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.101 2022/02/27 08:31:26 rillig Exp $");
+__RCSID("$NetBSD: lex.c,v 1.102 2022/02/27 10:44:45 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"
 @@ -256,39 +256,39 @@ static struct keyword {
 /* Symbol table */
 static	sym_t	*symtab[HSHSIZ1];
 /* type of next expected symbol */
 symt_t	symtyp;
 static void
 symtab_add(sym_t *sym)
+{
 	size_t h;
 	h = hash(sym->s_name);
-	if ((sym->s_link = symtab[h]) != NULL)
+	if ((sym->s_symtab_next = symtab[h]) != NULL)
-		symtab[h]->s_rlink = &sym->s_link;
+		symtab[h]->s_symtab_ref = &sym->s_symtab_next;
-	sym->s_rlink = &symtab[h];
+	sym->s_symtab_ref = &symtab[h];
 	symtab[h] = sym;
+}
 static void
 symtab_remove(sym_t *sym)
+{
-	if ((*sym->s_rlink = sym->s_link) != NULL)
+	if ((*sym->s_symtab_ref = sym->s_symtab_next) != NULL)
-		sym->s_link->s_rlink = sym->s_rlink;
+		sym->s_symtab_next->s_symtab_ref = sym->s_symtab_ref;
-	sym->s_link = NULL;
+	sym->s_symtab_next = NULL;
+}
 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 {
 @@ -416,27 +416,27 @@ lex_name(const char *yytext, size_t yyle
 	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_link) {
+	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;
 @@ -1367,27 +1367,27 @@ getsym(sbuf_t *sb)
 		sym->s_block_level = block_level;
 		di = dcs;
+	}
 	UNIQUE_CURR_POS(sym->s_def_pos);
 	if ((sym->s_kind = symtyp) != FLABEL)
 		sym->s_type = gettyp(INT);
 	symtyp = FVFT;
 	symtab_add(sym);
 	*di->d_ldlsym = sym;
-	di->d_ldlsym = &sym->s_dlnxt;
+	di->d_ldlsym = &sym->s_level_next;
 	free(sb);
 	return sym;
+}
 /*
  * Construct a temporary symbol. The symbol name starts with a digit, making
  * the name illegal.
  */
 sym_t *
 mktempsym(type_t *t)
+{
 	static int n = 0;
 @@ -1402,95 +1402,95 @@ mktempsym(type_t *t)
 		scl = block_level > 0 ? AUTO : EXTERN;
 	sym->s_name = s;
 	sym->s_type = t;
 	sym->s_block_level = block_level;
 	sym->s_scl = scl;
 	sym->s_kind = FVFT;
 	sym->s_used = true;
 	sym->s_set = true;
 	symtab_add(sym);
 	*dcs->d_ldlsym = sym;
-	dcs->d_ldlsym = &sym->s_dlnxt;
+	dcs->d_ldlsym = &sym->s_level_next;
 	return sym;
+}
 /* Remove a symbol forever from the symbol table. */
 void
 rmsym(sym_t *sym)
+{
 	debug_step("rmsym '%s' %s '%s'",
 	    sym->s_name, symt_name(sym->s_kind), type_name(sym->s_type));
 	symtab_remove(sym);
 	/* avoid that the symbol will later be put back to the symbol table */
 	sym->s_block_level = -1;
+}
 /*
  * Remove a list of symbols declared at one level from the symbol
  * table.
  */
 void
 rmsyms(sym_t *syms)
+{
 	sym_t	*sym;
-	for (sym = syms; sym != NULL; sym = sym->s_dlnxt) {
+	for (sym = syms; sym != NULL; sym = sym->s_level_next) {
 		if (sym->s_block_level != -1) {
 			debug_step("rmsyms '%s' %s '%s'",
 			    sym->s_name, symt_name(sym->s_kind),
 			    type_name(sym->s_type));
 			symtab_remove(sym);
-			sym->s_rlink = NULL;
+			sym->s_symtab_ref = NULL;
+		}
+	}
+}
 /*
  * Put a symbol into the symbol table.
  */
 void
 inssym(int bl, sym_t *sym)
+{
 	debug_step("inssym '%s' %s '%s'",
 	    sym->s_name, symt_name(sym->s_kind), type_name(sym->s_type));
 	symtab_add(sym);
 	sym->s_block_level = bl;
-	lint_assert(sym->s_link == NULL ||
+	lint_assert(sym->s_symtab_next == NULL ||
-		    sym->s_block_level >= sym->s_link->s_block_level);
+		    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++) {
 		for (sym = symtab[i]; sym != NULL; sym = nsym) {
-			nsym = sym->s_link;
+			nsym = sym->s_symtab_next;
 			if (sym->s_block_level >= 1)
 				symtab_remove(sym);
+		}
+	}
 	for (i = mem_block_level; i > 0; i--)
 		level_free_all(i);
+}
 /*
  * Create a new symbol with the name of an existing symbol.
  */
 sym_t *
 @@ -1500,27 +1500,27 @@ pushdown(const sym_t *sym)
 	debug_step("pushdown '%s' %s '%s'",
 	    sym->s_name, symt_name(sym->s_kind), type_name(sym->s_type));
 	nsym = block_zero_alloc(sizeof(*nsym));
 	lint_assert(sym->s_block_level <= block_level);
 	nsym->s_name = sym->s_name;
 	UNIQUE_CURR_POS(nsym->s_def_pos);
 	nsym->s_kind = sym->s_kind;
 	nsym->s_block_level = block_level;
 	symtab_add(nsym);
 	*dcs->d_ldlsym = nsym;
-	dcs->d_ldlsym = &nsym->s_dlnxt;
+	dcs->d_ldlsym = &nsym->s_level_next;
 	return nsym;
+}
 /*
  * Free any dynamically allocated memory referenced by
  * the value stack or yylval.
  * The type of information in yylval is described by tok.
  */
 void
 freeyyv(void *sp, int tok)
+{
 	if (tok == T_NAME || tok == T_TYPENAME) {

 @@ -1,14 +1,14 @@
-/* $NetBSD: lint1.h,v 1.138 2022/02/27 07:50:09 rillig Exp $ */
+/* $NetBSD: lint1.h,v 1.139 2022/02/27 10:44:45 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
 @@ -263,31 +263,33 @@ typedef	struct sym {
 	int	s_block_level;	/* level of declaration, -1 if not in symbol
 				   table */
 	type_t	*s_type;
 	val_t	s_value;	/* value (if enum or bool constant) */
 	union {
 		/* XXX: what is the difference to s_type->t_str? */
 		struct_or_union	*_s_st;
 		enumeration	*_s_et;
 		tspec_t	_s_tsp;	/* type (only for keywords) */
 		tqual_t	_s_tqu;	/* qualifier (only for keywords) */
 		struct	sym *_s_args; /* arguments in old style function
 					 definitions */
 	} u;
-	struct	sym *s_link;	/* next symbol with same hash value */
+	struct	sym *s_symtab_next;	/* next symbol with same hash value */
-	struct	sym **s_rlink;	/* pointer to s_link of prev. symbol */
+	struct	sym **s_symtab_ref;	/* pointer to s_symtab_next of the
 					 * previous symbol */
 	struct	sym *s_next;	/* next struct/union member, enumerator,
 				   argument */
-	struct	sym *s_dlnxt;	/* next symbol declared on same level */
+	struct	sym *s_level_next;	/* next symbol declared on the same
 					 * level */
 } sym_t;
 #define	s_styp	u._s_st
 #define	s_etyp	u._s_et
 #define	s_tspec	u._s_tsp
 #define	s_tqual	u._s_tqu
 #define	s_args	u._s_args
 /*
  * Used to keep some information about symbols before they are entered
  * into the symbol table.
  */
 typedef	struct sbuf {
 @@ -377,28 +379,28 @@ typedef	struct dinfo {
 	bool	d_invalid_type_combination:1;
 	bool	d_nonempty_decl:1; /* if at least one tag is declared
 				 * ... in the current function decl. */
 	bool	d_vararg:1;
 	bool	d_proto:1;	/* current function decl. is prototype */
 	bool	d_notyp:1;	/* set if no type specifier was present */
 	bool	d_asm:1;	/* set if d_ctx == AUTO and asm() present */
 	bool	d_packed:1;
 	bool	d_used:1;
 	type_t	*d_tagtyp;	/* tag during member declaration */
 	sym_t	*d_func_args;	/* list of arguments during function def. */
 	pos_t	d_func_def_pos;	/* position of function definition */
 	sym_t	*d_dlsyms;	/* first symbol declared at this level */
-	sym_t	**d_ldlsym;	/* points to s_dlnxt in last symbol decl.
+	sym_t	**d_ldlsym;	/* points to s_level_next in the last symbol
-				   at this level */
+				   declaration at this level */
 	sym_t	*d_func_proto_syms; /* symbols defined in prototype */
 	struct	dinfo *d_next;	/* next level */
 } dinfo_t;
 /* One level of pointer indirection in declarators, including qualifiers. */
 typedef	struct qual_ptr {
 	bool	p_const: 1;
 	bool	p_volatile: 1;
 	bool	p_pointer: 1;
 	struct	qual_ptr *p_next;
 } qual_ptr;
 /*

 @@ -1,14 +1,14 @@
-/*	$NetBSD: tree.c,v 1.406 2022/02/27 10:31:58 rillig Exp $	*/
+/*	$NetBSD: tree.c,v 1.407 2022/02/27 10:44:45 rillig Exp $	*/
 /*
  * 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
  *    documentation and/or other materials provided with the distribution.
 @@ -27,27 +27,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: tree.c,v 1.406 2022/02/27 10:31:58 rillig Exp $");
+__RCSID("$NetBSD: tree.c,v 1.407 2022/02/27 10:44:45 rillig Exp $");
 #endif
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 #include "cgram.h"
 static	tnode_t	*build_integer_constant(tspec_t, int64_t);
 @@ -369,48 +369,49 @@ struct_or_union_member(tnode_t *tn, op_t
 	if (op == POINT) {
 		if (t == STRUCT || t == UNION)
 			str = tp->t_str;
 	} else if (op == ARROW && t == PTR) {
 		t = (tp = tp->t_subt)->t_tspec;
 		if (t == STRUCT || t == UNION)
 			str = tp->t_str;
+	}
 	/*
 	 * If this struct/union has a member with the name of msym, return it.
 	 */
 	if (str != NULL) {
-		for (sym = msym; sym != NULL; sym = sym->s_link) {
+		for (sym = msym; sym != NULL; sym = sym->s_symtab_next) {
 			if (sym->s_scl != MOS && sym->s_scl != MOU)
 				continue;
 			if (sym->s_styp != str)
 				continue;
 			if (strcmp(sym->s_name, msym->s_name) != 0)
 				continue;
 			return sym;
+		}
+	}
 	/*
 	 * Set eq to false if there are struct/union members with the same
 	 * name and different types and/or offsets.
 	 */
 	eq = true;
-	for (csym = msym; csym != NULL; csym = csym->s_link) {
+	for (csym = msym; csym != NULL; csym = csym->s_symtab_next) {
 		if (csym->s_scl != MOS && csym->s_scl != MOU)
 			continue;
 		if (strcmp(msym->s_name, csym->s_name) != 0)
 			continue;
-		for (sym = csym->s_link; sym != NULL; sym = sym->s_link) {
+		for (sym = csym->s_symtab_next; sym != NULL;
 		    sym = sym->s_symtab_next) {
 			bool w;
 			if (sym->s_scl != MOS && sym->s_scl != MOU)
 				continue;
 			if (strcmp(csym->s_name, sym->s_name) != 0)
 				continue;
 			if (csym->s_value.v_quad != sym->s_value.v_quad) {
 				eq = false;
 				break;
+			}
 			w = false;
 			eq = eqtype(csym->s_type, sym->s_type,
 			    false, false, &w) && !w;