 @@ -1,1297 +1,1297 @@
-/*	$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.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by Jochen Pohl for
  *	The NetBSD Project.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * 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;
 /* Is set as long as a statement can be reached. Must be set at level 0. */
 int	reached = 1;
 /*
  * Is set as long as NOTREACHED is in effect.
  * Is reset everywhere where reached can become 0.
  */
 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.
+ *
  * The position of the last VARARGS comment is stored in vapos.
  */
 int	nvararg = -1;
 pos_t	vapos;
 /*
  * Both prflstr and scflstrg contain the number of the argument which
  * shall be used to check the types of remaining arguments (for PRINTFLIKE
  * and SCANFLIKE).
+ *
  * printflike_pos and scanflike_pos are the positions of the last PRINTFLIKE
  * or SCANFLIKE comment.
  */
 int	prflstrg = -1;
 int	scflstrg = -1;
 pos_t	printflike_pos;
 pos_t	scanflike_pos;
 /*
  * If both plibflg and llibflg are set, prototypes are written as function
  * definitions to the output file.
  */
 int	plibflg;
 /*
  * Nonzero means that no warnings about constants in conditional
  * context are printed.
  */
 int	constcond_flag;
 /*
  * llibflg is set if a lint library shall be created. The effect of
  * llibflg is that all defined symbols are treated as used.
  * (The LINTLIBRARY comment also resets vflag.)
  */
 int	llibflg;
 /*
  * Nonzero if warnings are suppressed by a LINTED directive
  * LWARN_BAD:	error
  * LWARN_ALL:	warnings on
  * LWARN_NONE:	all warnings ignored
  * 0..n: warning n ignored
  */
 int	lwarn = LWARN_ALL;
 /*
  * Whether bitfield type errors are suppressed by a BITFIELDTYPE
  * directive.
  */
 bool	bitfieldtype_ok;
 /*
  * Nonzero if complaints about use of "long long" are suppressed in
  * the next statement or declaration.
  */
 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);
+}
 /*
  * Prints a warning if a statement cannot be reached.
  */
 void
 check_statement_reachable(void)
+{
 	if (!reached && !rchflg) {
 		/* statement not reached */
 		warning(193);
 		reached = 1;
+	}
+}
 /*
  * Called after a function declaration which introduces a function definition
  * and before an (optional) old style argument declaration list.
+ *
  * Puts all symbols declared in the prototype or in an old style argument
  * list back to the symbol table.
+ *
  * Does the usual checking of storage class, type (return value),
  * redeclaration, etc.
  */
 void
 funcdef(sym_t *fsym)
+{
 	int	n, 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_fpsyms; sym != NULL; sym = sym->s_dlnxt) {
 		if (sym->s_blklev != -1) {
 			lint_assert(sym->s_blklev == 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 = 1;
 	check_type(fsym);
 	/*
 	 * check_type() checks for almost all possible errors, but not for
 	 * incomplete return values (these are allowed in declarations)
 	 */
 	if (fsym->s_type->t_subt->t_tspec != VOID &&
 	    incompl(fsym->s_type->t_subt)) {
 		/* cannot return incomplete type */
 		error(67);
+	}
 	fsym->s_def = DEF;
 	if (fsym->s_scl == TYPEDEF) {
 		fsym->s_scl = EXTERN;
 		/* illegal storage class */
 		error(8);
+	}
 	if (dcs->d_inline)
 		fsym->s_inline = 1;
 	/*
 	 * Arguments in new style function declarations need a name.
 	 * (void is already removed from the list of arguments)
 	 */
 	n = 1;
 	for (arg = fsym->s_type->t_args; arg != NULL; arg = arg->s_next) {
 		if (arg->s_scl == ABSTRACT) {
 			lint_assert(arg->s_name == unnamed);
 			/* formal parameter lacks name: param #%d */
 			error(59, n);
 		} else {
 			lint_assert(arg->s_name != unnamed);
+		}
 		n++;
+	}
 	/*
 	 * We must also remember the position. s_def_pos is overwritten
 	 * if this is an old style definition and we had already a
 	 * prototype.
 	 */
 	dcs->d_fdpos = fsym->s_def_pos;
 	if ((rdsym = dcs->d_rdcsym) != NULL) {
 		if (!check_redeclaration(fsym, (dowarn = 0, &dowarn))) {
 			/*
 			 * Print nothing if the newly defined function
 			 * is defined in old style. A better warning will
 			 * be printed in check_func_lint_directives().
 			 */
 			if (dowarn && !fsym->s_osdef) {
 				/* redeclaration of %s */
 				(*(sflag ? error : warning))(27, fsym->s_name);
 				print_previous_declaration(-1, rdsym);
+			}
 			/* copy usage information */
 			copy_usage_info(fsym, rdsym);
 			/*
 			 * If the old symbol was a prototype and the new
 			 * one is none, overtake the position of the
 			 * declaration of the prototype.
 			 */
 			if (fsym->s_osdef && rdsym->s_type->t_proto)
 				fsym->s_def_pos = rdsym->s_def_pos;
 			/* complete the type */
 			complete_type(fsym, rdsym);
 			/* once a function is inline it remains inline */
 			if (rdsym->s_inline)
 				fsym->s_inline = 1;
+		}
 		/* remove the old symbol from the symbol table */
 		rmsym(rdsym);
+	}
 	if (fsym->s_osdef && !fsym->s_type->t_proto) {
 		if (sflag && hflag && strcmp(fsym->s_name, "main") != 0)
 			/* function definition is not a prototype */
 			warning(286);
+	}
 	if (dcs->d_notyp)
 		/* return value is implicitly declared to be int */
 		fsym->s_rimpl = 1;
 	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;
+}
 void
 named_label(sym_t *sym)
+{
 	if (sym->s_set) {
 		/* label %s redefined */
 		error(194, sym->s_name);
 	} else {
 		mark_as_set(sym);
+	}
 	reached = 1;
+}
 static void
 check_case_label(tnode_t *tn, cstk_t *ci)
+{
 	clst_t	*cl;
 	val_t	*v;
 	val_t	nv;
 	tspec_t	t;
 	if (ci == NULL) {
 		/* case not in switch */
 		error(195);
 		return;
+	}
 	if (tn != NULL && tn->tn_op != CON) {
 		/* non-constant case expression */
 		error(197);
 		return;
+	}
 	if (tn != NULL && !tspec_is_int(tn->tn_type->t_tspec)) {
 		/* non-integral case expression */
 		error(198);
 		return;
+	}
 	lint_assert(ci->c_swtype != NULL);
 	if (reached && !ftflg) {
 		if (hflag)
 			/* fallthrough on case statement */
 			warning(220);
+	}
 	t = tn->tn_type->t_tspec;
 	if (t == LONG || t == ULONG ||
 	    t == QUAD || t == UQUAD) {
 		if (tflag)
 			/* case label must be of type `int' in traditional C */
 			warning(203);
+	}
 	/*
 	 * get the value of the expression and convert it
 	 * to the type of the switch expression
 	 */
 	v = constant(tn, 1);
 	(void) memset(&nv, 0, sizeof nv);
 	cvtcon(CASE, 0, ci->c_swtype, &nv, v);
 	free(v);
 	/* look if we had this value already */
 	for (cl = ci->c_clst; cl != NULL; cl = cl->cl_next) {
 		if (cl->cl_val.v_quad == nv.v_quad)
 			break;
+	}
 	if (cl != NULL && tspec_is_uint(nv.v_tspec)) {
 		/* duplicate case in switch: %lu */
 		error(200, (u_long)nv.v_quad);
 	} else if (cl != NULL) {
 		/* duplicate case in switch: %ld */
 		error(199, (long)nv.v_quad);
 	} else {
 		/*
 		 * append the value to the list of
 		 * case values
 		 */
 		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);
+		}
 		ci->c_default = 1;
+	}
 	reached = 1;
+}
 static tnode_t *
 check_controlling_expression(tnode_t *tn)
+{
 	tspec_t t = tn->tn_type->t_tspec;
 	if (tn != NULL)
 		tn = cconv(tn);
 	if (tn != NULL)
 		tn = promote(NOOP, 0, tn);
 	if (tn != NULL && !tspec_is_scalar(t)) {
 		/* C99 6.5.15p4 for the ?: operator; see typeok:QUEST */
 		/* C99 6.8.4.1p1 for if statements */
 		/* C99 6.8.5p2 for while, do and for loops */
 		/* controlling expressions must have scalar type */
 		error(204);
 		return NULL;
+	}
 	return tn;
+}
 /*
  * T_IF T_LPAREN expr T_RPAREN
  */
 void
 if1(tnode_t *tn)
+{
 	if (tn != NULL)
 		tn = check_controlling_expression(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;
 	type_t	*tp;
 	if (tn != NULL)
 		tn = cconv(tn);
 	if (tn != NULL)
 		tn = promote(NOOP, 0, tn);
 	if (tn != NULL && !tspec_is_int(tn->tn_type->t_tspec)) {
 		/* switch expression must have integral type */
 		error(205);
 		tn = NULL;
+	}
 	if (tn != NULL && tflag) {
 		t = tn->tn_type->t_tspec;
 		if (t == LONG || t == ULONG || t == QUAD || t == UQUAD) {
 			/* switch expr. must be of type `int' in trad. C */
 			warning(271);
+		}
+	}
 	/*
 	 * Remember the type of the expression. Because it's possible
 	 * that (*tp) is allocated on tree memory, the type must be
 	 * duplicated. This is not too complicated because it is
 	 * only an integer type.
 	 */
 	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);
+}
 /*
  * T_WHILE T_LPAREN expr T_RPAREN
  */
 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)
+{
 	mark_as_used(lab, 0, 0);
 	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;
 	} else if (tn == NULL && funcsym->s_type->t_subt->t_tspec != VOID) {
 		/*
 		 * Assume that the function has a return value only if it
 		 * is explicitly declared.
 		 */
 		if (!funcsym->s_rimpl)
 			/* function %s expects to return value */
 			warning(214, funcsym->s_name);
+	}
 	if (tn != NULL) {
 		/* Create a temporary node for the left side */
 		ln = tgetblk(sizeof (tnode_t));
 		ln->tn_op = NAME;
 		ln->tn_type = tduptyp(funcsym->s_type->t_subt);
 		ln->tn_type->t_const = 0;
 		ln->tn_lvalue = 1;
 		ln->tn_sym = funcsym;		/* better than nothing */
 		tn = build(RETURN, ln, tn);
 		if (tn != NULL) {
 			rn = tn->tn_right;
 			while ((op = rn->tn_op) == CVT || op == PLUS)
 				rn = rn->tn_left;
 			if (rn->tn_op == AMPER && rn->tn_left->tn_op == NAME &&
 			    rn->tn_left->tn_sym->s_scl == AUTO) {
 				/* %s returns pointer to automatic object */
 				warning(302, funcsym->s_name);
+			}
+		}
 		expr(tn, 1, 0, 1);
 	} else {
 		check_statement_reachable();
+	}
 	reached = rchflg = 0;
+}
 /*
  * Do some cleanup after a global declaration or definition.
  * Especially remove information about unused lint comments.
  */
 void
 global_clean_up_decl(int silent)
+{
 	pos_t	cpos;
 	cpos = curr_pos;
 	if (nargusg != -1) {
 		if (!silent) {
 			curr_pos = argsused_pos;
 			/* must precede function definition: ** %s ** */
 			warning(282, "ARGSUSED");
+		}
 		nargusg = -1;
+	}
 	if (nvararg != -1) {
 		if (!silent) {
 			curr_pos = vapos;
 			/* must precede function definition: ** %s ** */
 			warning(282, "VARARGS");
+		}
 		nvararg = -1;
+	}
 	if (prflstrg != -1) {
 		if (!silent) {
 			curr_pos = printflike_pos;
 			/* must precede function definition: ** %s ** */
 			warning(282, "PRINTFLIKE");
+		}
 		prflstrg = -1;
+	}
 	if (scflstrg != -1) {
 		if (!silent) {
 			curr_pos = scanflike_pos;
 			/* must precede function definition: ** %s ** */
 			warning(282, "SCANFLIKE");
+		}
 		scflstrg = -1;
+	}
 	curr_pos = cpos;
 	dcs->d_asm = 0;
+}
 /*
  * ARGSUSED comment
+ *
  * Only the first n arguments of the following function are checked
  * for usage. A missing argument is taken to be 0.
  */
 void
 argsused(int n)
+{
 	if (n == -1)
 		n = 0;
 	if (dcs->d_ctx != EXTERN) {
 		/* must be outside function: ** %s ** */
 		warning(280, "ARGSUSED");
 		return;
+	}
 	if (nargusg != -1) {
 		/* duplicate use of ** %s ** */
 		warning(281, "ARGSUSED");
+	}
 	nargusg = n;
 	argsused_pos = curr_pos;
+}
 /*
  * VARARGS comment
+ *
  * Causes lint2 to check only the first n arguments for compatibility
  * with the function definition. A missing argument is taken to be 0.
  */
 void
 varargs(int n)
+{
 	if (n == -1)
 		n = 0;
 	if (dcs->d_ctx != EXTERN) {
 		/* must be outside function: ** %s ** */
 		warning(280, "VARARGS");
 		return;
+	}
 	if (nvararg != -1) {
 		/* duplicate use of ** %s ** */
 		warning(281, "VARARGS");
+	}
 	nvararg = n;
 	vapos = curr_pos;
+}
 /*
  * PRINTFLIKE comment
+ *
  * Check all arguments until the (n-1)-th as usual. The n-th argument is
  * used the check the types of remaining arguments.
  */
 void
 printflike(int n)
+{
 	if (n == -1)
 		n = 0;
 	if (dcs->d_ctx != EXTERN) {
 		/* must be outside function: ** %s ** */
 		warning(280, "PRINTFLIKE");
 		return;
+	}
 	if (prflstrg != -1) {
 		/* duplicate use of ** %s ** */
 		warning(281, "PRINTFLIKE");
+	}
 	prflstrg = n;
 	printflike_pos = curr_pos;
+}
 /*
  * SCANFLIKE comment
+ *
  * Check all arguments until the (n-1)-th as usual. The n-th argument is
  * used the check the types of remaining arguments.
  */
 void
 scanflike(int n)
+{
 	if (n == -1)
 		n = 0;
 	if (dcs->d_ctx != EXTERN) {
 		/* must be outside function: ** %s ** */
 		warning(280, "SCANFLIKE");
 		return;
+	}
 	if (scflstrg != -1) {
 		/* duplicate use of ** %s ** */
 		warning(281, "SCANFLIKE");
+	}
 	scflstrg = n;
 	scanflike_pos = curr_pos;
+}
 /*
  * Set the linenumber for a CONSTCOND comment. At this and the following
  * line no warnings about constants in conditional contexts are printed.
  */
 /* ARGSUSED */
 void
 constcond(int n)
+{
 	constcond_flag = 1;
+}
 /*
  * Suppress printing of "fallthrough on ..." warnings until next
  * statement.
  */
 /* ARGSUSED */
 void
 fallthru(int n)
+{
 	ftflg = 1;
+}
 /*
  * Stop warnings about statements which cannot be reached. Also tells lint
  * that the following statements cannot be reached (e.g. after exit()).
  */
 /* ARGSUSED */
 void
 notreach(int n)
+{
 	reached = 0;
 	rchflg = 1;
+}
 /* ARGSUSED */
 void
 lintlib(int n)
+{
 	if (dcs->d_ctx != EXTERN) {
 		/* must be outside function: ** %s ** */
 		warning(280, "LINTLIBRARY");
 		return;
+	}
 	llibflg = 1;
 	vflag = 0;
+}
 /*
  * Suppress most warnings at the current and the following line.
  */
 /* ARGSUSED */
 void
 linted(int n)
+{
 #ifdef DEBUG
 	printf("%s, %d: lwarn = %d\n", curr_pos.p_file, curr_pos.p_line, n);
 #endif
 	lwarn = n;
+}
 /*
  * Suppress bitfield type errors on the current line.
  */
 /* ARGSUSED */
 void
 bitfieldtype(int n)
+{
 #ifdef DEBUG
 	printf("%s, %d: bitfieldtype_ok = true\n", curr_pos.p_file,
 	    curr_pos.p_line);
 #endif
 	bitfieldtype_ok = true;
+}
 /*
  * PROTOLIB in conjunction with LINTLIBRARY can be used to handle
  * prototypes like function definitions. This is done if the argument
  * to PROTOLIB is nonzero. Otherwise prototypes are handled normally.
  */
 void
 protolib(int n)
+{
 	if (dcs->d_ctx != EXTERN) {
 		/* must be outside function: ** %s ** */
 		warning(280, "PROTOLIB");
 		return;
+	}
 	plibflg = n == 0 ? 0 : 1;
+}
 /*
  * Set quadflg to nonzero which means that the next statement/declaration
  * may use "long long" without an error or warning.
  */
 /* ARGSUSED */
 void
 longlong(int n)
+{
 	quadflg = 1;
+}

 @@ -1,461 +1,461 @@
-/* $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
  *    documentation and/or other materials provided with the distribution.
  * 3. All advertising materials mentioning features or use of this software
  *    must display the following acknowledgement:
  *      This product includes software developed by Jochen Pohl for
  *	The NetBSD Project.
  * 4. The name of the author may not be used to endorse or promote products
  *    derived from this software without specific prior written permission.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  * 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.
  */
 #include "lint.h"
 #include "err-msgs.h"
 #include "op.h"
 /*
  * XXX - Super conservative so that works for most systems, but we should
  * not depend on the host settings but the target settings in determining
  * the alignment. The only valid use for this is in mem1.c; uses in decl.c
  * are bogus.
  */
 #ifndef WORST_ALIGN
 #ifdef _LP64
 # define AVAL	15
 #else
 # define AVAL	7
 #endif
 #define WORST_ALIGN(x) (((x) + AVAL) & ~AVAL)
 #endif
 #define LWARN_BAD	-3
 #define LWARN_ALL	-2
 #define LWARN_NONE	-1
 /*
  * Describes the position of a declaration or anything else.
  */
 typedef struct {
 	int	p_line;
 	const	char *p_file;
 	int	p_uniq;			/* uniquifier */
 } pos_t;
 /* Copies curr_pos, keeping things unique. */
 #define	UNIQUE_CURR_POS(pos)						\
 	do {								\
 		(pos) = curr_pos;					\
 		curr_pos.p_uniq++;					\
 		if (curr_pos.p_file == csrc_pos.p_file)			\
 			csrc_pos.p_uniq++;				\
 	} while (/*CONSTCOND*/0)
 /*
  * Strings cannot be referenced to simply by a pointer to its first
  * char. This is because strings can contain NUL characters other than the
  * trailing NUL.
+ *
  * Strings are stored with a trailing NUL.
  */
 typedef	struct strg {
 	tspec_t	st_tspec;		/* CHAR or WCHAR */
 	size_t	st_len;			/* length without trailing NUL */
 	union {
 		u_char	*_st_cp;
 		wchar_t	*_st_wcp;
 	} st_u;
 } strg_t;
 #define st_cp	st_u._st_cp
 #define	st_wcp	st_u._st_wcp
 /*
  * qualifiers (only for lex/yacc interface)
  */
 typedef enum {
 	CONST, VOLATILE, RESTRICT, THREAD
 } tqual_t;
 /*
  * Integer and floating point values are stored in this structure
  */
 typedef struct {
 	tspec_t	v_tspec;
 	int	v_ansiu;		/* set if an integer constant is
 					   unsigned in ANSI C */
 	union {
 		int64_t	_v_quad;	/* integers */
 		ldbl_t	_v_ldbl;	/* floats */
 	} v_u;
 } val_t;
 #define v_quad	v_u._v_quad
 #define v_ldbl	v_u._v_ldbl
 /*
  * Structures of type str_t uniqely identify structures. This can't
  * be done in structures of type type_t, because these are copied
  * if they must be modified. So it would not be possible to check
  * if two structures are identical by comparing the pointers to
  * the type structures.
+ *
  * The typename is used if the structure is unnamed to identify
  * the structure type in pass 2.
  */
 typedef	struct {
 	u_int	size;		/* size in bit */
 	u_int	align : 15;	/* alignment in bit */
 	bool	sincompl : 1;	/* set if incomplete type */
 	struct	sym *memb;	/* list of members */
 	struct	sym *stag;	/* symbol table entry of tag */
 	struct	sym *stdef;	/* symbol table entry of first typename */
 } str_t;
 /*
  * same as above for enums
  */
 typedef	struct {
 	bool	eincompl : 1;	/* incomplete enum type */
 	struct	sym *elem;	/* list of enumerators */
 	struct	sym *etag;	/* symbol table entry of tag */
 	struct	sym *etdef;	/* symbol table entry of first typename */
 } tenum_t;
 /*
  * Types are represented by concatenation of structures of type type_t
  * via t_subt.
  */
 struct type {
 	tspec_t	t_tspec;	/* type specifier */
 	bool	t_aincompl : 1;	/* incomplete array type */
 	bool	t_const : 1;	/* const modifier */
 	bool	t_volatile : 1;	/* volatile modifier */
 	bool	t_proto : 1;	/* function prototype (t_args valid) */
 	bool	t_vararg : 1;	/* prototype with ... */
 	bool	t_typedef : 1;	/* type defined with typedef */
 	bool	t_bitfield : 1;
 	bool	t_isenum : 1;	/* type is (or was) enum (t_enum valid) */
 	bool	t_packed : 1;
 	union {
 		int	_t_dim;		/* dimension */
 		str_t	*_t_str;	/* struct/union tag */
 		tenum_t	*_t_enum;	/* enum tag */
 		struct	sym *_t_args;	/* arguments (if t_proto) */
 	} t_u;
 	struct {
 		u_int	_t_flen : 8;	/* length of bit-field */
 		u_int	_t_foffs : 24;	/* offset of bit-field */
 	} t_b;
 	struct	type *t_subt;	/* element type (arrays), return value
 				   (functions), or type pointer points to */
 };
 #define	t_dim	t_u._t_dim
 #define	t_str	t_u._t_str
 #define	t_enum	t_u._t_enum
 #define	t_args	t_u._t_args
 #define	t_flen	t_b._t_flen
 #define	t_foffs	t_b._t_foffs
 /*
  * types of symbols
  */
 typedef	enum {
 	FVFT,		/* variables, functions, type names, enums */
 	FMEMBER,	/* members of structs or unions */
 	FTAG,		/* tags */
 	FLABEL		/* labels */
 } symt_t;
 /*
  * storage classes
  */
 typedef enum {
 	NOSCL,
 	EXTERN,		/* external symbols (indep. of decl_t) */
 	STATIC,		/* static symbols (local and global) */
 	AUTO,		/* automatic symbols (except register) */
 	REG,		/* register */
 	TYPEDEF,	/* typedef */
 	STRTAG,
 	UNIONTAG,
 	ENUMTAG,
 	MOS,		/* member of struct */
 	MOU,		/* member of union */
 	ENUMCON,	/* enumerator, enum constant */
 	ABSTRACT,	/* abstract symbol (sizeof, casts, unnamed argument) */
 	ARG,		/* argument */
 	PARG,		/* used in declaration stack during prototype
 			   declaration */
 	INLINE		/* only used by the parser */
 } scl_t;
 /*
  * symbol table entry
  */
 typedef	struct sym {
 	const	char *s_name;
 	const	char *s_rename;	/* renamed symbol's given name */
 	pos_t	s_def_pos;	/* position of last (prototype) definition,
 				   prototype declaration, no-prototype-def.,
 				   tentative definition or declaration,
 				   in this order */
 	pos_t	s_set_pos;	/* position of first initialisation */
 	pos_t	s_use_pos;	/* position of first use */
 	symt_t	s_kind;		/* type of symbol */
 	void   *s_keyword;
 	bool	s_bitfield : 1;
 	bool	s_set : 1;	/* variable set, label defined */
 	bool	s_used : 1;	/* variable/label used */
 	bool	s_arg : 1;	/* symbol is function argument */
 	bool	s_reg : 1;	/* symbol is register variable */
 	bool	s_defarg : 1;	/* undefined symbol in old style function
 				   definition */
 	bool	s_rimpl : 1;	/* return value of function implicit decl. */
 	bool	s_osdef : 1;	/* symbol stems from old style function def. */
 	bool	s_inline : 1;	/* true if this is an inline function */
 	struct	sym *s_ext_sym;	/* for local declared external symbols pointer
 				   to external symbol with same name */
 	def_t	s_def;		/* declared, tentative defined, defined */
 	scl_t	s_scl;		/* storage class */
 	int	s_blklev;	/* level of declaration, -1 if not in symbol
 				   table */
 	type_t	*s_type;
 	val_t	s_value;	/* value (if enum constant) */
 	union {
 		str_t	*_s_st;	/* tag, if it is a struct/union member */
 		tenum_t	*_s_et;	/* tag, if it is an enumerator */
 		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_rlink;	/* pointer to s_link of prev. symbol */
 	struct	sym *s_next;	/* next struct/union member, enumerator,
 				   argument */
 	struct	sym *s_dlnxt;	/* next symbol declared on 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 {
 	const	char *sb_name;		/* name of symbol */
 	size_t	sb_len;			/* length (without '\0') */
 	int	sb_hash;		/* hash value */
 	sym_t	*sb_sym;		/* symbol table entry */
 	struct	sbuf *sb_next;		/* for freelist */
 } sbuf_t;
 /*
  * tree node
  */
 typedef	struct tnode {
 	op_t	tn_op;		/* operator */
 	type_t	*tn_type;	/* type */
 	bool	tn_lvalue : 1;	/* node is lvalue */
 	bool	tn_cast : 1;	/* if tn_op == CVT, it's an explicit cast */
 	bool	tn_parenthesized : 1;
 	union {
 		struct {
 			struct	tnode *_tn_left;	/* (left) operand */
 			struct	tnode *_tn_right;	/* right operand */
 		} tn_s;
 		sym_t	*_tn_sym;	/* symbol if op == NAME */
 		val_t	*_tn_val;	/* value if op == CON */
 		strg_t	*_tn_string;	/* string if op == STRING */
 	} tn_u;
 } tnode_t;
 #define	tn_left	tn_u.tn_s._tn_left
 #define tn_right tn_u.tn_s._tn_right
 #define tn_sym	tn_u._tn_sym
 #define	tn_val	tn_u._tn_val
 #define	tn_string	tn_u._tn_string
 /*
  * For nested declarations a stack exists, which holds all information
  * needed for the current level. dcs points to the top element of this
  * stack.
+ *
  * ctx describes the context of the current declaration. Its value is
  * one of
  *	EXTERN	global declarations
  *	MOS oder MOU declarations of struct or union members
  *	ENUMCON	declarations of enums
  *	ARG	declaration of arguments in old style function definitions
  *	PARG	declaration of arguments in function prototypes
  *	AUTO	declaration of local symbols
  *	ABSTRACT abstract declarations (sizeof, casts)
+ *
  */
 typedef	struct dinfo {
 	tspec_t	d_atyp;		/* VOID, CHAR, INT, or COMPLEX */
 	tspec_t	d_cmod;		/* FLOAT, or DOUBLE */
 	tspec_t	d_smod;		/* SIGNED or UNSIGN */
 	tspec_t	d_lmod;		/* SHORT, LONG or QUAD */
 	scl_t	d_scl;		/* storage class */
 	type_t	*d_type;	/* after deftyp() pointer to the type used
 				   for all declarators */
 	sym_t	*d_rdcsym;	/* redeclared symbol */
 	int	d_offset;	/* offset of next structure member */
 	int	d_stralign;	/* alignment required for current structure */
 	scl_t	d_ctx;		/* context of declaration */
 	bool	d_const : 1;	/* const in declaration specifiers */
 	bool	d_volatile : 1;	/* volatile in declaration specifiers */
 	bool	d_inline : 1;	/* inline in declaration specifiers */
 	bool	d_mscl : 1;	/* multiple storage classes */
 	bool	d_terr : 1;	/* invalid type combination */
 	bool	d_nedecl : 1;	/* if at least one tag is declared */
 	bool	d_vararg : 1;	/* ... in in current function decl. */
 	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_fargs;	/* list of arguments during function def. */
 	pos_t	d_fdpos;	/* 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.
 				   at this level */
 	sym_t	*d_fpsyms;	/* symbols defined in prototype */
 	struct	dinfo *d_next;	/* next level */
 } dinfo_t;
 /*
  * Used to collect information about pointers and qualifiers in
  * declarators.
  */
 typedef	struct pqinf {
 	int	p_pcnt;			/* number of asterisks */
 	bool	p_const : 1;
 	bool	p_volatile : 1;
 	struct	pqinf *p_next;
 } 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 {
 	unsigned int	errs_bits[(ERR_SETSIZE + __NERRBITS-1) / __NERRBITS];
 } err_set;
 #define	ERR_SET(n, p)	\
 	((p)->errs_bits[(n)/__NERRBITS] |= (1 << ((n) % __NERRBITS)))
 #define	ERR_CLR(n, p)	\
 	((p)->errs_bits[(n)/__NERRBITS] &= ~(1 << ((n) % __NERRBITS)))
 #define	ERR_ISSET(n, p)	\
 	((p)->errs_bits[(n)/__NERRBITS] & (1 << ((n) % __NERRBITS)))
 #define	ERR_ZERO(p)	(void)memset((p), 0, sizeof(*(p)))
 #define LERROR(fmt, args...)	lerror(__FILE__, __LINE__, fmt, ##args)
 #define lint_assert(cond)						\
 	do {								\
 		if (!(cond))						\
 			assert_failed(__FILE__, __LINE__, __func__, #cond); \
 	} while (/*CONSTCOND*/0)
 #ifdef BLKDEBUG
 #define ZERO	0xa5
 #else
 #define	ZERO	0
 #endif
 extern err_set	msgset;
 #ifdef DEBUG
 #  include "err-msgs.h"
 /* ARGSUSED */
 static inline void __attribute__((format(printf, 1, 2)))
 check_printf(const char *fmt, ...)
+{
+}
 #  define wrap_check_printf(func, id, args...)				\
 	do {								\
 		check_printf(__CONCAT(MSG_, id), ##args);		\
 		(func)(id, ##args);					\
 	} while (/*CONSTCOND*/0)
 #  define error(id, args...) wrap_check_printf(error, id, ##args)
 #  define warning(id, args...) wrap_check_printf(warning, id, ##args)
 #  define message(id, args...) wrap_check_printf(message, id, ##args)
 #  define gnuism(id, args...) wrap_check_printf(gnuism, id, ##args)
 #  define c99ism(id, args...) wrap_check_printf(c99ism, id, ##args)
 #endif