 @@ -1,14 +1,14 @@
-/*	$NetBSD: func.c,v 1.47 2021/01/02 18:44:58 rillig Exp $	*/
+/*	$NetBSD: func.c,v 1.48 2021/01/03 20:04:08 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.47 2021/01/02 18:44:58 rillig Exp $");
+__RCSID("$NetBSD: func.c,v 1.48 2021/01/03 20:04:08 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;
 @@ -65,28 +65,28 @@ int	rchflg;
  * In conjunction with reached ontrols printing of "fallthrough on ..."
  * warnings.
  * Reset by each statement and set by FALLTHROUGH, switch (switch1())
  * and case (label()).
+ *
  * Control statements if, for, while and switch do not reset ftflg because
  * this must be done by the controlled statement. At least for if this is
  * important because ** FALLTHROUGH ** after "if (expr) stmnt" is evaluated
  * before the following token, wich causes reduction of above.
  * This means that ** FALLTHROUGH ** after "if ..." would always be ignored.
  */
 int	ftflg;
-/* Top element of stack for control statements */
+/* The innermost control statement */
-cstk_t	*cstk;
+cstk_t	*cstmt;
 /*
  * Number of arguments which will be checked for usage in following
  * function definition. -1 stands for all arguments.
+ *
  * The position of the last ARGSUSED comment is stored in argsused_pos.
  */
 int	nargusg = -1;
 pos_t	argsused_pos;
 /*
  * Number of arguments of the following function definition whose types
  * shall be checked by lint2. -1 stands for all arguments.
 @@ -149,43 +149,43 @@ bool	bitfieldtype_ok;
  */
 int	quadflg;
 /*
  * Puts a new element at the top of the stack used for control statements.
  */
 void
 pushctrl(int env)
+{
 	cstk_t	*ci;
 	ci = xcalloc(1, sizeof (cstk_t));
 	ci->c_env = env;
-	ci->c_next = cstk;
+	ci->c_surrounding = cstmt;
-	cstk = ci;
+	cstmt = ci;
+}
 /*
  * Removes the top element of the stack used for control statements.
  */
 void
 popctrl(int env)
+{
 	cstk_t	*ci;
 	clst_t	*cl;
-	lint_assert(cstk != NULL);
+	lint_assert(cstmt != NULL);
-	lint_assert(cstk->c_env == env);
+	lint_assert(cstmt->c_env == env);
-	cstk = (ci = cstk)->c_next;
+	cstmt = (ci = cstmt)->c_surrounding;
 	while ((cl = ci->c_clst) != NULL) {
 		ci->c_clst = cl->cl_next;
 		free(cl);
+	}
 	if (ci->c_swtype != NULL)
 		free(ci->c_swtype);
 	free(ci);
+}
 /*
 @@ -337,63 +337,63 @@ funcdef(sym_t *fsym)
 	reached = 1;
+}
 /*
  * Called at the end of a function definition.
  */
 void
 funcend(void)
+{
 	sym_t	*arg;
 	int	n;
 	if (reached) {
-		cstk->c_noretval = 1;
+		cstmt->c_noretval = 1;
 		if (funcsym->s_type->t_subt->t_tspec != VOID &&
 		    !funcsym->s_rimpl) {
 			/* func. %s falls off bottom without returning value */
 			warning(217, funcsym->s_name);
+		}
+	}
 	/*
 	 * This warning is printed only if the return value was implicitly
 	 * declared to be int. Otherwise the wrong return statement
 	 * has already printed a warning.
 	 */
-	if (cstk->c_noretval && cstk->c_retval && funcsym->s_rimpl)
+	if (cstmt->c_noretval && cstmt->c_retval && funcsym->s_rimpl)
 		/* function %s has return (e); and return; */
 		warning(216, funcsym->s_name);
 	/* Print warnings for unused arguments */
 	arg = dcs->d_fargs;
 	n = 0;
 	while (arg != NULL && (nargusg == -1 || n < nargusg)) {
 		check_usage_sym(dcs->d_asm, arg);
 		arg = arg->s_next;
 		n++;
+	}
 	nargusg = -1;
 	/*
 	 * write the information about the function definition to the
 	 * output file
 	 * inline functions explicitly declared extern are written as
 	 * declarations only.
 	 */
 	if (dcs->d_scl == EXTERN && funcsym->s_inline) {
 		outsym(funcsym, funcsym->s_scl, DECL);
 	} else {
-		outfdef(funcsym, &dcs->d_fdpos, cstk->c_retval,
+		outfdef(funcsym, &dcs->d_fdpos, cstmt->c_retval,
 			funcsym->s_osdef, dcs->d_fargs);
+	}
 	/*
 	 * remove all symbols declared during argument declaration from
 	 * the symbol table
 	 */
 	lint_assert(dcs->d_next == NULL);
 	lint_assert(dcs->d_ctx == EXTERN);
 	rmsyms(dcs->d_fpsyms);
 	/* must be set on level 0 */
 	reached = 1;
 @@ -483,43 +483,43 @@ check_case_label(tnode_t *tn, cstk_t *ci
 		cl = xcalloc(1, sizeof (clst_t));
 		cl->cl_val = nv;
 		cl->cl_next = ci->c_clst;
 		ci->c_clst = cl;
+	}
+}
 void
 case_label(tnode_t *tn)
+{
 	cstk_t	*ci;
 	/* find the stack entry for the innermost switch statement */
-	for (ci = cstk; ci != NULL && !ci->c_switch; ci = ci->c_next)
+	for (ci = cstmt; ci != NULL && !ci->c_switch; ci = ci->c_surrounding)
 		continue;
 	check_case_label(tn, ci);
 	tfreeblk();
 	reached = 1;
+}
 void
 default_label(void)
+{
 	cstk_t	*ci;
 	/* find the stack entry for the innermost switch statement */
-	for (ci = cstk; ci != NULL && !ci->c_switch; ci = ci->c_next)
+	for (ci = cstmt; ci != NULL && !ci->c_switch; ci = ci->c_surrounding)
 		continue;
 	if (ci == NULL) {
 		/* default outside switch */
 		error(201);
 	} else if (ci->c_default) {
 		/* duplicate default in switch */
 		error(202);
 	} else {
 		if (reached && !ftflg) {
 			if (hflag)
 				/* fallthrough on default statement */
 				warning(284);
 @@ -564,40 +564,40 @@ if1(tnode_t *tn)
 	if (tn != NULL)
 		expr(tn, 0, 1, 0);
 	pushctrl(T_IF);
+}
 /*
  * if_without_else
  * if_without_else T_ELSE
  */
 void
 if2(void)
+{
-	cstk->c_rchif = reached ? 1 : 0;
+	cstmt->c_rchif = reached ? 1 : 0;
 	reached = 1;
+}
 /*
  * if_without_else
  * if_without_else T_ELSE stmnt
  */
 void
 if3(int els)
+{
 	if (els) {
-		reached |= cstk->c_rchif;
+		reached |= cstmt->c_rchif;
 	} else {
 		reached = 1;
+	}
 	popctrl(T_IF);
+}
 /*
  * T_SWITCH T_LPAREN expr T_RPAREN
  */
 void
 switch1(tnode_t *tn)
+{
 	tspec_t	t;
 @@ -628,73 +628,73 @@ switch1(tnode_t *tn)
 	 */
 	tp = xcalloc(1, sizeof (type_t));
 	if (tn != NULL) {
 		tp->t_tspec = tn->tn_type->t_tspec;
 		if ((tp->t_isenum = tn->tn_type->t_isenum) != 0)
 			tp->t_enum = tn->tn_type->t_enum;
 	} else {
 		tp->t_tspec = INT;
+	}
 	expr(tn, 1, 0, 1);
 	pushctrl(T_SWITCH);
-	cstk->c_switch = 1;
+	cstmt->c_switch = 1;
-	cstk->c_swtype = tp;
+	cstmt->c_swtype = tp;
 	reached = rchflg = 0;
 	ftflg = 1;
+}
 /*
  * switch_expr stmnt
  */
 void
 switch2(void)
+{
 	int	nenum = 0, nclab = 0;
 	sym_t	*esym;
 	clst_t	*cl;
-	lint_assert(cstk->c_swtype != NULL);
+	lint_assert(cstmt->c_swtype != NULL);
 	/*
 	 * If the switch expression was of type enumeration, count the case
 	 * labels and the number of enumerators. If both counts are not
 	 * equal print a warning.
 	 */
-	if (cstk->c_swtype->t_isenum) {
+	if (cstmt->c_swtype->t_isenum) {
 		nenum = nclab = 0;
-		lint_assert(cstk->c_swtype->t_enum != NULL);
+		lint_assert(cstmt->c_swtype->t_enum != NULL);
-		for (esym = cstk->c_swtype->t_enum->elem;
+		for (esym = cstmt->c_swtype->t_enum->elem;
 		     esym != NULL; esym = esym->s_next) {
 			nenum++;
+		}
-		for (cl = cstk->c_clst; cl != NULL; cl = cl->cl_next)
+		for (cl = cstmt->c_clst; cl != NULL; cl = cl->cl_next)
 			nclab++;
-		if (hflag && eflag && nenum != nclab && !cstk->c_default) {
+		if (hflag && eflag && nenum != nclab && !cstmt->c_default) {
 			/* enumeration value(s) not handled in switch */
 			warning(206);
+		}
+	}
-	if (cstk->c_break) {
+	if (cstmt->c_break) {
 		/*
 		 * end of switch alway reached (c_break is only set if the
 		 * break statement can be reached).
 		 */
 		reached = 1;
-	} else if (!cstk->c_default &&
+	} else if (!cstmt->c_default &&
-		   (!hflag || !cstk->c_swtype->t_isenum || nenum != nclab)) {
+		   (!hflag || !cstmt->c_swtype->t_isenum || nenum != nclab)) {
 		/*
 		 * there are possible values which are not handled in
 		 * switch
 		 */
 		reached = 1;
 	}	/*
 		 * otherwise the end of the switch expression is reached
 		 * if the end of the last statement inside it is reached.
 		 */
 	popctrl(T_SWITCH);
+}
 @@ -705,207 +705,207 @@ void
 while1(tnode_t *tn)
+{
 	if (!reached) {
 		/* loop not entered at top */
 		warning(207);
 		reached = 1;
+	}
 	if (tn != NULL)
 		tn = check_controlling_expression(tn);
 	pushctrl(T_WHILE);
-	cstk->c_loop = 1;
+	cstmt->c_loop = 1;
 	if (tn != NULL && tn->tn_op == CON) {
 		if (tspec_is_int(tn->tn_type->t_tspec)) {
-			cstk->c_infinite = tn->tn_val->v_quad != 0;
+			cstmt->c_infinite = tn->tn_val->v_quad != 0;
 		} else {
-			cstk->c_infinite = tn->tn_val->v_ldbl != 0.0;
+			cstmt->c_infinite = tn->tn_val->v_ldbl != 0.0;
+		}
+	}
 	expr(tn, 0, 1, 1);
+}
 /*
  * while_expr stmnt
  * while_expr error
  */
 void
 while2(void)
+{
 	/*
 	 * The end of the loop can be reached if it is no endless loop
 	 * or there was a break statement which was reached.
 	 */
-	reached = !cstk->c_infinite || cstk->c_break;
+	reached = !cstmt->c_infinite || cstmt->c_break;
 	rchflg = 0;
 	popctrl(T_WHILE);
+}
 /*
  * T_DO
  */
 void
 do1(void)
+{
 	if (!reached) {
 		/* loop not entered at top */
 		warning(207);
 		reached = 1;
+	}
 	pushctrl(T_DO);
-	cstk->c_loop = 1;
+	cstmt->c_loop = 1;
+}
 /*
  * do stmnt do_while_expr
  * do error
  */
 void
 do2(tnode_t *tn)
+{
 	/*
 	 * If there was a continue statement, the expression controlling the
 	 * loop is reached.
 	 */
-	if (cstk->c_cont)
+	if (cstmt->c_cont)
 		reached = 1;
 	if (tn != NULL)
 		tn = check_controlling_expression(tn);
 	if (tn != NULL && tn->tn_op == CON) {
 		if (tspec_is_int(tn->tn_type->t_tspec)) {
-			cstk->c_infinite = tn->tn_val->v_quad != 0;
+			cstmt->c_infinite = tn->tn_val->v_quad != 0;
 		} else {
-			cstk->c_infinite = tn->tn_val->v_ldbl != 0.0;
+			cstmt->c_infinite = tn->tn_val->v_ldbl != 0.0;
+		}
-		if (!cstk->c_infinite && cstk->c_cont)
+		if (!cstmt->c_infinite && cstmt->c_cont)
 			/* continue in 'do ... while (0)' loop */
 			error(323);
+	}
 	expr(tn, 0, 1, 1);
 	/*
 	 * The end of the loop is only reached if it is no endless loop
 	 * or there was a break statement which could be reached.
 	 */
-	reached = !cstk->c_infinite || cstk->c_break;
+	reached = !cstmt->c_infinite || cstmt->c_break;
 	rchflg = 0;
 	popctrl(T_DO);
+}
 /*
  * T_FOR T_LPAREN opt_expr T_SEMI opt_expr T_SEMI opt_expr T_RPAREN
  */
 void
 for1(tnode_t *tn1, tnode_t *tn2, tnode_t *tn3)
+{
 	/*
 	 * If there is no initialisation expression it is possible that
 	 * it is intended not to enter the loop at top.
 	 */
 	if (tn1 != NULL && !reached) {
 		/* loop not entered at top */
 		warning(207);
 		reached = 1;
+	}
 	pushctrl(T_FOR);
-	cstk->c_loop = 1;
+	cstmt->c_loop = 1;
 	/*
 	 * Store the tree memory for the reinitialisation expression.
 	 * Also remember this expression itself. We must check it at
 	 * the end of the loop to get "used but not set" warnings correct.
 	 */
-	cstk->c_fexprm = tsave();
+	cstmt->c_fexprm = tsave();
-	cstk->c_f3expr = tn3;
+	cstmt->c_f3expr = tn3;
-	cstk->c_fpos = curr_pos;
+	cstmt->c_fpos = curr_pos;
-	cstk->c_cfpos = csrc_pos;
+	cstmt->c_cfpos = csrc_pos;
 	if (tn1 != NULL)
 		expr(tn1, 0, 0, 1);
 	if (tn2 != NULL)
 		tn2 = check_controlling_expression(tn2);
 	if (tn2 != NULL)
 		expr(tn2, 0, 1, 1);
 	if (tn2 == NULL) {
-		cstk->c_infinite = 1;
+		cstmt->c_infinite = 1;
 	} else if (tn2->tn_op == CON) {
 		if (tspec_is_int(tn2->tn_type->t_tspec)) {
-			cstk->c_infinite = tn2->tn_val->v_quad != 0;
+			cstmt->c_infinite = tn2->tn_val->v_quad != 0;
 		} else {
-			cstk->c_infinite = tn2->tn_val->v_ldbl != 0.0;
+			cstmt->c_infinite = tn2->tn_val->v_ldbl != 0.0;
+		}
+	}
 	/* Checking the reinitialisation expression is done in for2() */
 	reached = 1;
+}
 /*
  * for_exprs stmnt
  * for_exprs error
  */
 void
 for2(void)
+{
 	pos_t	cpos, cspos;
 	tnode_t	*tn3;
-	if (cstk->c_cont)
+	if (cstmt->c_cont)
 		reached = 1;
 	cpos = curr_pos;
 	cspos = csrc_pos;
 	/* Restore the tree memory for the reinitialisation expression */
-	trestor(cstk->c_fexprm);
+	trestor(cstmt->c_fexprm);
-	tn3 = cstk->c_f3expr;
+	tn3 = cstmt->c_f3expr;
-	curr_pos = cstk->c_fpos;
+	curr_pos = cstmt->c_fpos;
-	csrc_pos = cstk->c_cfpos;
+	csrc_pos = cstmt->c_cfpos;
 	/* simply "statement not reached" would be confusing */
 	if (!reached && !rchflg) {
 		/* end-of-loop code not reached */
 		warning(223);
 		reached = 1;
+	}
 	if (tn3 != NULL) {
 		expr(tn3, 0, 0, 1);
 	} else {
 		tfreeblk();
+	}
 	curr_pos = cpos;
 	csrc_pos = cspos;
 	/* An endless loop without break will never terminate */
-	reached = cstk->c_break || !cstk->c_infinite;
+	reached = cstmt->c_break || !cstmt->c_infinite;
 	rchflg = 0;
 	popctrl(T_FOR);
+}
 /*
  * T_GOTO identifier T_SEMI
  * T_GOTO error T_SEMI
  */
 void
 dogoto(sym_t *lab)
+{
 @@ -914,79 +914,79 @@ dogoto(sym_t *lab)
 	check_statement_reachable();
 	reached = rchflg = 0;
+}
 /*
  * T_BREAK T_SEMI
  */
 void
 dobreak(void)
+{
 	cstk_t	*ci;
-	ci = cstk;
+	ci = cstmt;
 	while (ci != NULL && !ci->c_loop && !ci->c_switch)
-		ci = ci->c_next;
+		ci = ci->c_surrounding;
 	if (ci == NULL) {
 		/* break outside loop or switch */
 		error(208);
 	} else {
 		if (reached)
 			ci->c_break = 1;
+	}
 	if (bflag)
 		check_statement_reachable();
 	reached = rchflg = 0;
+}
 /*
  * T_CONTINUE T_SEMI
  */
 void
 docont(void)
+{
 	cstk_t	*ci;
-	for (ci = cstk; ci != NULL && !ci->c_loop; ci = ci->c_next)
+	for (ci = cstmt; ci != NULL && !ci->c_loop; ci = ci->c_surrounding)
 		continue;
 	if (ci == NULL) {
 		/* continue outside loop */
 		error(209);
 	} else {
 		ci->c_cont = 1;
+	}
 	check_statement_reachable();
 	reached = rchflg = 0;
+}
 /*
  * T_RETURN T_SEMI
  * T_RETURN expr T_SEMI
  */
 void
 doreturn(tnode_t *tn)
+{
 	tnode_t	*ln, *rn;
 	cstk_t	*ci;
 	op_t	op;
-	for (ci = cstk; ci->c_next != NULL; ci = ci->c_next)
+	for (ci = cstmt; ci->c_surrounding != NULL; ci = ci->c_surrounding)
 		continue;
 	if (tn != NULL) {
 		ci->c_retval = 1;
 	} else {
 		ci->c_noretval = 1;
+	}
 	if (tn != NULL && funcsym->s_type->t_subt->t_tspec == VOID) {
 		/* void function %s cannot return value */
 		error(213, funcsym->s_name);
 		tfreeblk();
 		tn = NULL;

 @@ -1,14 +1,14 @@
-/* $NetBSD: lint1.h,v 1.51 2021/01/03 19:15:36 rillig Exp $ */
+/* $NetBSD: lint1.h,v 1.52 2021/01/03 20:04:08 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
 @@ -367,46 +367,46 @@ typedef	struct pqinf {
 } pqinf_t;
 /*
  * Case values are stored in a list of type clst_t.
  */
 typedef	struct clst {
 	val_t	cl_val;
 	struct	clst *cl_next;
 } clst_t;
 /*
  * Used to keep information about nested control statements.
  */
-typedef struct cstk {
+typedef struct control_statement {
 	int	c_env;			/* type of statement (T_IF, ...) */
 	bool	c_loop : 1;		/* continue && break are valid */
 	bool	c_switch : 1;		/* case && break are valid */
 	bool	c_break : 1;		/* loop/switch has break */
 	bool	c_cont : 1;		/* loop has continue */
 	bool	c_default : 1;		/* switch has default */
 	bool	c_infinite : 1;		/* break condition always false
 					   (for (;;), while (1)) */
 	bool	c_rchif : 1;		/* end of if-branch reached */
 	bool	c_noretval : 1;		/* had "return;" */
 	bool	c_retval : 1;		/* had "return (e);" */
 	type_t	*c_swtype;		/* type of switch expression */
 	clst_t	*c_clst;		/* list of case values */
 	struct	mbl *c_fexprm;		/* saved memory for end of loop
 					   expression in for() */
 	tnode_t	*c_f3expr;		/* end of loop expr in for() */
 	pos_t	c_fpos;			/* position of end of loop expr */
 	pos_t	c_cfpos;	        /* same for csrc_pos */
-	struct	cstk *c_next;		/* outer control statement */
+	struct	control_statement *c_surrounding;
 } cstk_t;
 typedef struct {
 	size_t lo;
 	size_t hi;
 } range_t;
 #include "externs1.h"
 #define	ERR_SETSIZE	1024
 #define __NERRBITS (sizeof(unsigned int))
 typedef	struct err_set {