 @@ -1,1377 +1,1377 @@
-/*	$NetBSD: func.c,v 1.114 2021/07/20 19:35:53 rillig Exp $	*/
+/*	$NetBSD: func.c,v 1.115 2021/07/23 17:06:37 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.114 2021/07/20 19:35:53 rillig Exp $");
+__RCSID("$NetBSD: func.c,v 1.115 2021/07/23 17:06:37 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. */
 bool	reached = true;
 /*
  * Is true by default, can be cleared by NOTREACHED.
  * Is reset to true whenever 'reached' changes.
  */
 bool	warn_about_unreachable;
 /*
  * In conjunction with 'reached', controls 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 seen_fallthrough
  * because this must be done by the controlled statement. At least for if this
  * is important because ** FALLTHROUGH ** after "if (expr) statement" is
  * evaluated before the following token, which causes reduction of above.
  * This means that ** FALLTHROUGH ** after "if ..." would always be ignored.
  */
 bool	seen_fallthrough;
 /* The innermost control statement */
-cstk_t	*cstmt;
+control_statement *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 printflike_argnum and scanflike_argnum contain the 1-based number
  * of the string 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	printflike_argnum = -1;
 int	scanflike_argnum = -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.
  */
 bool	plibflg;
 /*
  * True means that no warnings about constants in conditional
  * context are printed.
  */
 bool	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.)
  */
 bool	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;
 /*
  * Whether complaints about use of "long long" are suppressed in
  * the next statement or declaration.
  */
 bool	quadflg;
 /*
  * Puts a new element at the top of the stack used for control statements.
  */
 void
 begin_control_statement(control_statement_kind kind)
+{
-	cstk_t	*ci;
+	control_statement *cs;
-	ci = xcalloc(1, sizeof(*ci));
+	cs = xcalloc(1, sizeof(*cs));
-	ci->c_kind = kind;
+	cs->c_kind = kind;
-	ci->c_surrounding = cstmt;
+	cs->c_surrounding = cstmt;
-	cstmt = ci;
+	cstmt = cs;
+}
 /*
  * Removes the top element of the stack used for control statements.
  */
 void
 end_control_statement(control_statement_kind kind)
+{
-	cstk_t	*ci;
+	control_statement *cs;
 	case_label_t *cl, *next;
 	lint_assert(cstmt != NULL);
 	while (cstmt->c_kind != kind)
 		cstmt = cstmt->c_surrounding;
-	ci = cstmt;
+	cs = cstmt;
-	cstmt = ci->c_surrounding;
+	cstmt = cs->c_surrounding;
-	for (cl = ci->c_case_labels; cl != NULL; cl = next) {
+	for (cl = cs->c_case_labels; cl != NULL; cl = next) {
 		next = cl->cl_next;
 		free(cl);
+	}
-	free(ci->c_switch_type);
+	free(cs->c_switch_type);
-	free(ci);
+	free(cs);
+}
 static void
 set_reached(bool new_reached)
+{
 #ifdef DEBUG
 	printf("%s:%d: %s -> %s\n", curr_pos.p_file, curr_pos.p_line,
 	    reached ? "reachable" : "unreachable",
 	    new_reached ? "reachable" : "unreachable");
 #endif
 	reached = new_reached;
 	warn_about_unreachable = true;
+}
 /*
  * Prints a warning if a statement cannot be reached.
  */
 void
 check_statement_reachable(void)
+{
 	if (!reached && warn_about_unreachable) {
 		/* statement not reached */
 		warning(193);
 		warn_about_unreachable = false;
+	}
+}
 /*
  * 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;
 	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) {
 		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;
 	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 &&
 	    is_incomplete(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 = true;
 	/*
 	 * 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_func_def_pos = fsym->s_def_pos;
 	if ((rdsym = dcs->d_redeclared_symbol) != NULL) {
 		if (!check_redeclaration(fsym, (dowarn = false, &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) {
 				if (sflag)
 					/* redeclaration of %s */
 					error(27, fsym->s_name);
 				else
 					/* redeclaration of %s */
 					warning(27, fsym->s_name);
 				print_previous_declaration(-1, rdsym);
+			}
 			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_type(fsym, rdsym);
 			if (rdsym->s_inline)
 				fsym->s_inline = true;
+		}
 		/* 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)
 		fsym->s_return_type_implicit_int = true;
 	set_reached(true);
+}
 static void
 check_missing_return_value(void)
+{
 	if (funcsym->s_type->t_subt->t_tspec == VOID)
 		return;
 	if (funcsym->s_return_type_implicit_int)
 		return;
 	/* C99 5.1.2.2.3 "Program termination" p1 */
 	if (Sflag && strcmp(funcsym->s_name, "main") == 0)
 		return;
 	/* function %s falls off bottom without returning value */
 	warning(217, funcsym->s_name);
+}
 /*
  * Called at the end of a function definition.
  */
 void
 funcend(void)
+{
 	sym_t	*arg;
 	int	n;
 	if (reached) {
 		cstmt->c_had_return_noval = true;
 		check_missing_return_value();
+	}
 	/*
 	 * 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 (cstmt->c_had_return_noval && cstmt->c_had_return_value &&
 	    funcsym->s_return_type_implicit_int)
 		/* function %s has return (e); and return; */
 		warning(216, funcsym->s_name);
 	/* Print warnings for unused arguments */
 	arg = dcs->d_func_args;
 	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_func_def_pos,
 		    cstmt->c_had_return_value, funcsym->s_osdef,
 		    dcs->d_func_args);
+	}
 	/* clean up after syntax errors, see test stmt_for.c. */
 	while (dcs->d_next != NULL)
 		dcs = dcs->d_next;
 	/*
 	 * 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_func_proto_syms);
 	/* must be set on level 0 */
 	set_reached(true);
+}
 void
 named_label(sym_t *sym)
+{
 	if (sym->s_set) {
 		/* label %s redefined */
 		error(194, sym->s_name);
 	} else {
 		mark_as_set(sym);
+	}
 	set_reached(true);
+}
 static void
 check_case_label_bitand(const tnode_t *case_expr, const tnode_t *switch_expr)
+{
 	uint64_t case_value, mask;
 	if (switch_expr->tn_op != BITAND ||
 	    switch_expr->tn_right->tn_op != CON)
 		return;
 	lint_assert(case_expr->tn_op == CON);
 	case_value = case_expr->tn_val->v_quad;
 	mask = switch_expr->tn_right->tn_val->v_quad;
 	if ((case_value & ~mask) != 0) {
 		/* statement not reached */
 		warning(193);
+	}
+}
 static void
-check_case_label_enum(const tnode_t *tn, const cstk_t *ci)
+check_case_label_enum(const tnode_t *tn, const control_statement *cs)
+{
 	/* similar to typeok_enum in tree.c */
-	if (!(tn->tn_type->t_is_enum || ci->c_switch_type->t_is_enum))
+	if (!(tn->tn_type->t_is_enum || cs->c_switch_type->t_is_enum))
 		return;
-	if (tn->tn_type->t_is_enum && ci->c_switch_type->t_is_enum &&
+	if (tn->tn_type->t_is_enum && cs->c_switch_type->t_is_enum &&
-	    tn->tn_type->t_enum == ci->c_switch_type->t_enum)
+	    tn->tn_type->t_enum == cs->c_switch_type->t_enum)
 		return;
 #if 0 /* not yet ready, see msg_130.c */
 	/* enum type mismatch: '%s' '%s' '%s' */
-	warning(130, type_name(ci->c_switch_type), op_name(EQ),
+	warning(130, type_name(cs->c_switch_type), op_name(EQ),
 	    type_name(tn->tn_type));
 #endif
+}
 static void
-check_case_label(tnode_t *tn, cstk_t *ci)
+check_case_label(tnode_t *tn, control_statement *cs)
+{
 	case_label_t *cl;
 	val_t	*v;
 	val_t	nv;
 	tspec_t	t;
-	if (ci == NULL) {
+	if (cs == 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 && !is_integer(tn->tn_type->t_tspec)) {
 		/* non-integral case expression */
 		error(198);
 		return;
+	}
-	check_case_label_bitand(tn, ci->c_switch_expr);
+	check_case_label_bitand(tn, cs->c_switch_expr);
-	check_case_label_enum(tn, ci);
+	check_case_label_enum(tn, cs);
-	lint_assert(ci->c_switch_type != NULL);
+	lint_assert(cs->c_switch_type != NULL);
 	if (reached && !seen_fallthrough) {
 		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, true);
 	(void)memset(&nv, 0, sizeof(nv));
-	convert_constant(CASE, 0, ci->c_switch_type, &nv, v);
+	convert_constant(CASE, 0, cs->c_switch_type, &nv, v);
 	free(v);
 	/* look if we had this value already */
-	for (cl = ci->c_case_labels; cl != NULL; cl = cl->cl_next) {
+	for (cl = cs->c_case_labels; cl != NULL; cl = cl->cl_next) {
 		if (cl->cl_val.v_quad == nv.v_quad)
 			break;
+	}
 	if (cl != NULL && is_uinteger(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 {
 		check_getopt_case_label(nv.v_quad);
 		/* append the value to the list of case values */
 		cl = xcalloc(1, sizeof(*cl));
 		cl->cl_val = nv;
-		cl->cl_next = ci->c_case_labels;
+		cl->cl_next = cs->c_case_labels;
-		ci->c_case_labels = cl;
+		cs->c_case_labels = cl;
+	}
+}
 void
 case_label(tnode_t *tn)
+{
-	cstk_t	*ci;
+	control_statement *cs;
 	/* find the innermost switch statement */
-	for (ci = cstmt; ci != NULL && !ci->c_switch; ci = ci->c_surrounding)
+	for (cs = cstmt; cs != NULL && !cs->c_switch; cs = cs->c_surrounding)
 		continue;
-	check_case_label(tn, ci);
+	check_case_label(tn, cs);
 	expr_free_all();
 	set_reached(true);
+}
 void
 default_label(void)
+{
-	cstk_t	*ci;
+	control_statement *cs;
 	/* find the innermost switch statement */
-	for (ci = cstmt; ci != NULL && !ci->c_switch; ci = ci->c_surrounding)
+	for (cs = cstmt; cs != NULL && !cs->c_switch; cs = cs->c_surrounding)
 		continue;
-	if (ci == NULL) {
+	if (cs == NULL) {
 		/* default outside switch */
 		error(201);
-	} else if (ci->c_default) {
+	} else if (cs->c_default) {
 		/* duplicate default in switch */
 		error(202);
 	} else {
 		if (reached && !seen_fallthrough) {
 			if (hflag)
 				/* fallthrough on default statement */
 				warning(284);
+		}
-		ci->c_default = true;
+		cs->c_default = true;
+	}
 	set_reached(true);
+}
 static tnode_t *
 check_controlling_expression(tnode_t *tn)
+{
 	if (tn != NULL)
 		tn = cconv(tn);
 	if (tn != NULL)
 		tn = promote(NOOP, false, tn);
 	if (tn != NULL && !is_scalar(tn->tn_type->t_tspec)) {
 		/* 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;
+	}
 	if (tn != NULL && Tflag && !is_typeok_bool_operand(tn)) {
 		/* controlling expression must be bool, not '%s' */
 		error(333, tspec_name(tn->tn_type->t_tspec));
+	}
 	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, false, true, false, false);
 	begin_control_statement(CS_IF);
 	if (tn != NULL && tn->tn_op == CON && !tn->tn_system_dependent) {
 		/* XXX: what if inside 'if (0)'? */
 		set_reached(constant_is_nonzero(tn));
 		/* XXX: what about always_else? */
 		cstmt->c_always_then = reached;
+	}
+}
 /*
  * if_without_else
  * if_without_else T_ELSE
  */
 void
 if2(void)
+{
 	cstmt->c_reached_end_of_then = reached;
 	/* XXX: what if inside 'if (0)'? */
 	set_reached(!cstmt->c_always_then);
+}
 /*
  * if_without_else
  * if_without_else T_ELSE statement
  */
 void
 if3(bool els)
+{
 	if (cstmt->c_reached_end_of_then)
 		set_reached(true);
 	else if (cstmt->c_always_then)
 		set_reached(false);
 	else if (!els)
 		set_reached(true);
 	end_control_statement(CS_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, false, tn);
 	if (tn != NULL && !is_integer(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(*tp));
 	if (tn != NULL) {
 		tp->t_tspec = tn->tn_type->t_tspec;
 		if ((tp->t_is_enum = tn->tn_type->t_is_enum) != false)
 			tp->t_enum = tn->tn_type->t_enum;
 	} else {
 		tp->t_tspec = INT;
+	}
 	/* leak the memory, for check_case_label_bitand */
 	expr_save_memory();
 	check_getopt_begin_switch();
 	expr(tn, true, false, false, false);
 	begin_control_statement(CS_SWITCH);
 	cstmt->c_switch = true;
 	cstmt->c_switch_type = tp;
 	cstmt->c_switch_expr = tn;
 	set_reached(false);
 	seen_fallthrough = true;
+}
 /*
  * switch_expr statement
  */
 void
 switch2(void)
+{
 	int	nenum = 0, nclab = 0;
 	sym_t	*esym;
 	case_label_t *cl;
 	lint_assert(cstmt->c_switch_type != NULL);
 	if (cstmt->c_switch_type->t_is_enum) {
 		/*
 		 * Warn if the number of case labels is different from the
 		 * number of enumerators.
 		 */
 		nenum = nclab = 0;
 		lint_assert(cstmt->c_switch_type->t_enum != NULL);
 		for (esym = cstmt->c_switch_type->t_enum->en_first_enumerator;
 		     esym != NULL; esym = esym->s_next) {
 			nenum++;
+		}
 		for (cl = cstmt->c_case_labels; cl != NULL; cl = cl->cl_next)
 			nclab++;
 		if (hflag && eflag && nenum != nclab && !cstmt->c_default) {
 			/* enumeration value(s) not handled in switch */
 			warning(206);
+		}
+	}
 	check_getopt_end_switch();
 	if (cstmt->c_break) {
 		/*
 		 * The end of the switch statement is always reached since
 		 * c_break is only set if a break statement can actually
 		 * be reached.
 		 */
 		set_reached(true);
 	} else if (cstmt->c_default ||
 		   (hflag && cstmt->c_switch_type->t_is_enum &&
 		    nenum == nclab)) {
 		/*
 		 * The end of the switch statement is reached if the end
 		 * of the last statement inside it is reached.
 		 */
 	} else {
 		/*
 		 * There are possible values that are not handled in the
 		 * switch statement.
 		 */
 		set_reached(true);
+	}
 	end_control_statement(CS_SWITCH);
+}
 /*
  * T_WHILE T_LPAREN expr T_RPAREN
  */
 void
 while1(tnode_t *tn)
+{
 	bool body_reached;
 	if (!reached) {
 		/* loop not entered at top */
 		warning(207);
 		/* FIXME: that's plain wrong. */
 		set_reached(true);
+	}
 	if (tn != NULL)
 		tn = check_controlling_expression(tn);
 	begin_control_statement(CS_WHILE);
 	cstmt->c_loop = true;
 	cstmt->c_maybe_endless = is_nonzero(tn);
 	body_reached = !is_zero(tn);
 	check_getopt_begin_while(tn);
 	expr(tn, false, true, true, false);
 	set_reached(body_reached);
+}
 /*
  * while_expr statement
  * 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.
 	 */
 	set_reached(!cstmt->c_maybe_endless || cstmt->c_break);
 	check_getopt_end_while();
 	end_control_statement(CS_WHILE);
+}
 /*
  * T_DO
  */
 void
 do1(void)
+{
 	if (!reached) {
 		/* loop not entered at top */
 		warning(207);
 		set_reached(true);
+	}
 	begin_control_statement(CS_DO_WHILE);
 	cstmt->c_loop = true;
+}
 /*
  * do statement do_while_expr
  * do error
  */
 void
 do2(tnode_t *tn)
+{
 	/*
 	 * If there was a continue statement, the expression controlling the
 	 * loop is reached.
 	 */
 	if (cstmt->c_continue)
 		set_reached(true);
 	if (tn != NULL)
 		tn = check_controlling_expression(tn);
 	if (tn != NULL && tn->tn_op == CON) {
 		cstmt->c_maybe_endless = constant_is_nonzero(tn);
 		if (!cstmt->c_maybe_endless && cstmt->c_continue)
 			/* continue in 'do ... while (0)' loop */
 			error(323);
+	}
 	expr(tn, false, true, true, true);
 	if (cstmt->c_maybe_endless)
 		set_reached(false);
 	if (cstmt->c_break)
 		set_reached(true);
 	end_control_statement(CS_DO_WHILE);
+}
 /*
  * 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 initialization 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);
 		set_reached(true);
+	}
 	begin_control_statement(CS_FOR);
 	cstmt->c_loop = true;
 	/*
 	 * Store the tree memory for the reinitialization expression.
 	 * Also remember this expression itself. We must check it at
 	 * the end of the loop to get "used but not set" warnings correct.
 	 */
 	cstmt->c_for_expr3_mem = expr_save_memory();
 	cstmt->c_for_expr3 = tn3;
 	cstmt->c_for_expr3_pos = curr_pos;
 	cstmt->c_for_expr3_csrc_pos = csrc_pos;
 	if (tn1 != NULL)
 		expr(tn1, false, false, true, false);
 	if (tn2 != NULL)
 		tn2 = check_controlling_expression(tn2);
 	if (tn2 != NULL)
 		expr(tn2, false, true, true, false);
 	cstmt->c_maybe_endless = tn2 == NULL || is_nonzero(tn2);
 	/* Checking the reinitialization expression is done in for2() */
 	set_reached(!is_zero(tn2));
+}
 /*
  * for_exprs statement
  * for_exprs error
  */
 void
 for2(void)
+{
 	pos_t	cpos, cspos;
 	tnode_t	*tn3;
 	if (cstmt->c_continue)
 		set_reached(true);
 	cpos = curr_pos;
 	cspos = csrc_pos;
 	/* Restore the tree memory for the reinitialization expression */
 	expr_restore_memory(cstmt->c_for_expr3_mem);
 	tn3 = cstmt->c_for_expr3;
 	curr_pos = cstmt->c_for_expr3_pos;
 	csrc_pos = cstmt->c_for_expr3_csrc_pos;
 	/* simply "statement not reached" would be confusing */
 	if (!reached && warn_about_unreachable) {
 		/* end-of-loop code not reached */
 		warning(223);
 		set_reached(true);
+	}
 	if (tn3 != NULL) {
 		expr(tn3, false, false, true, false);
 	} else {
 		expr_free_all();
+	}
 	curr_pos = cpos;
 	csrc_pos = cspos;
 	/* An endless loop without break will never terminate */
 	/* TODO: What if the loop contains a 'return'? */
 	set_reached(cstmt->c_break || !cstmt->c_maybe_endless);
 	end_control_statement(CS_FOR);
+}
 /*
  * T_GOTO identifier T_SEMI
  */
 void
 do_goto(sym_t *lab)
+{
 	mark_as_used(lab, false, false);
 	check_statement_reachable();
 	set_reached(false);
+}
 /*
  * T_BREAK T_SEMI
  */
 void
 do_break(void)
+{
-	cstk_t	*ci;
+	control_statement *cs;
-	ci = cstmt;
+	cs = cstmt;
-	while (ci != NULL && !ci->c_loop && !ci->c_switch)
+	while (cs != NULL && !cs->c_loop && !cs->c_switch)
-		ci = ci->c_surrounding;
+		cs = cs->c_surrounding;
-	if (ci == NULL) {
+	if (cs == NULL) {
 		/* break outside loop or switch */
 		error(208);
 	} else {
 		if (reached)
-			ci->c_break = true;
+			cs->c_break = true;
+	}
 	if (bflag)
 		check_statement_reachable();
 	set_reached(false);
+}
 /*
  * T_CONTINUE T_SEMI
  */
 void
 do_continue(void)
+{
-	cstk_t	*ci;
+	control_statement *cs;
-	for (ci = cstmt; ci != NULL && !ci->c_loop; ci = ci->c_surrounding)
+	for (cs = cstmt; cs != NULL && !cs->c_loop; cs = cs->c_surrounding)
 		continue;
-	if (ci == NULL) {
+	if (cs == NULL) {
 		/* continue outside loop */
 		error(209);
 	} else {
 		/* TODO: only if reachable, for symmetry with c_break */
-		ci->c_continue = true;
+		cs->c_continue = true;
+	}
 	check_statement_reachable();
 	set_reached(false);
+}
 /*
  * T_RETURN T_SEMI
  * T_RETURN expr T_SEMI
  */
 void
 do_return(tnode_t *tn)
+{
 	tnode_t	*ln, *rn;
-	cstk_t	*ci;
+	control_statement *cs;
 	op_t	op;
-	ci = cstmt;
+	cs = cstmt;
-	if (ci == NULL) {
+	if (cs == NULL) {
 		/* syntax error '%s' */
 		error(249, "return outside function");
 		return;
+	}
-	for (; ci->c_surrounding != NULL; ci = ci->c_surrounding)
+	for (; cs->c_surrounding != NULL; cs = cs->c_surrounding)
 		continue;
 	if (tn != NULL)
-		ci->c_had_return_value = true;
+		cs->c_had_return_value = true;
 	else
-		ci->c_had_return_noval = true;
+		cs->c_had_return_noval = true;
 	if (tn != NULL && funcsym->s_type->t_subt->t_tspec == VOID) {
 		/* void function %s cannot return value */
 		error(213, funcsym->s_name);
 		expr_free_all();
 		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_return_type_implicit_int)
 			/* function %s expects to return value */
 			warning(214, funcsym->s_name);
+	}
 	if (tn != NULL) {
 		/* Create a temporary node for the left side */
 		ln = expr_zalloc(sizeof(*ln));
 		ln->tn_op = NAME;
 		ln->tn_type = expr_dup_type(funcsym->s_type->t_subt);
 		ln->tn_type->t_const = false;
 		ln->tn_lvalue = true;
 		ln->tn_sym = funcsym;		/* better than nothing */
 		tn = build_binary(ln, RETURN, tn);
 		if (tn != NULL) {
 			rn = tn->tn_right;
 			while ((op = rn->tn_op) == CVT || op == PLUS)
 				rn = rn->tn_left;
 			if (rn->tn_op == ADDR && 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, true, false, true, false);
 	} else {
 		check_statement_reachable();
+	}
 	set_reached(false);
+}
 /*
  * Do some cleanup after a global declaration or definition.
  * Especially remove information about unused lint comments.
  */
 void
 global_clean_up_decl(bool silent)
+{
 	if (nargusg != -1) {
 		if (!silent) {
 			/* must precede function definition: ** %s ** */
 			warning_at(282, &argsused_pos, "ARGSUSED");
+		}
 		nargusg = -1;
+	}
 	if (nvararg != -1) {
 		if (!silent) {
 			/* must precede function definition: ** %s ** */
 			warning_at(282, &vapos, "VARARGS");
+		}
 		nvararg = -1;
+	}
 	if (printflike_argnum != -1) {
 		if (!silent) {
 			/* must precede function definition: ** %s ** */
 			warning_at(282, &printflike_pos, "PRINTFLIKE");
+		}
 		printflike_argnum = -1;
+	}
 	if (scanflike_argnum != -1) {
 		if (!silent) {
 			/* must precede function definition: ** %s ** */
 			warning_at(282, &scanflike_pos, "SCANFLIKE");
+		}
 		scanflike_argnum = -1;
+	}
 	dcs->d_asm = false;
 	/*
 	 * Needed for BSD yacc in case of parse errors; GNU Bison 3.0.4 is
 	 * fine.  See gcc_attribute.c, function_with_unknown_attribute.
 	 */
 	attron = false;
+}
 /*
  * 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 (printflike_argnum != -1) {
 		/* duplicate use of ** %s ** */
 		warning(281, "PRINTFLIKE");
+	}
 	printflike_argnum = 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 (scanflike_argnum != -1) {
 		/* duplicate use of ** %s ** */
 		warning(281, "SCANFLIKE");
+	}
 	scanflike_argnum = n;
 	scanflike_pos = curr_pos;
+}
 /*
  * Set the line number 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 = true;
+}
 /*
  * Suppress printing of "fallthrough on ..." warnings until next
  * statement.
  */
 /* ARGSUSED */
 void
 fallthru(int n)
+{
 	seen_fallthrough = true;
+}
 /*
  * Stop warnings about statements which cannot be reached. Also tells lint
  * that the following statements cannot be reached (e.g. after exit()).
  */
 /* ARGSUSED */
 void
 not_reached(int n)
+{
 	set_reached(false);
 	warn_about_unreachable = false;
+}
 /* ARGSUSED */
 void
 lintlib(int n)
+{
 	if (dcs->d_ctx != EXTERN) {
 		/* must be outside function: ** %s ** */
 		warning(280, "LINTLIBRARY");
 		return;
+	}
 	llibflg = true;
 	vflag = false;
+}
 /*
  * 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;
+}
 /* The next statement/declaration may use "long long" without a diagnostic. */
 /* ARGSUSED */
 void
 longlong(int n)
+{
 	quadflg = true;
+}

 @@ -1,583 +1,583 @@
-/* $NetBSD: lint1.h,v 1.117 2021/07/23 16:48:48 rillig Exp $ */
+/* $NetBSD: lint1.h,v 1.118 2021/07/23 17:06:37 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.
+ *
  * FIXME: Just a single file:lineno pair is not enough to accurately describe
  *  the position of a symbol.  The whole inclusion path at that point must be
  *  stored as well.  This makes a difference for symbols from included
  *  headers, see print_stack_trace.
  */
 typedef struct {
 	const	char *p_file;
 	int	p_line;
 	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 (false)
 /*
  * 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;
 /* An integer or floating-point value. */
 typedef struct {
 	tspec_t	v_tspec;
 	/*
 	 * Set if an integer constant is unsigned only in C90 and later, but
 	 * not in traditional C.
+	 *
 	 * See the operators table in ops.def, columns "l r".
 	 */
 	bool	v_unsigned_since_c90;
 	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 struct_or_union uniquely 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	sou_size_in_bits;
 	u_int	sou_align_in_bits : 15;
 	bool	sou_incomplete : 1;
 	struct	sym *sou_first_member;
 	struct	sym *sou_tag;
 	struct	sym *sou_first_typedef;
 } struct_or_union;
 /*
  * same as above for enums
  */
 typedef	struct {
 	bool	en_incomplete : 1;
 	struct	sym *en_first_enumerator;
 	struct	sym *en_tag;
 	struct	sym *en_first_typedef;
 } enumeration;
 /*
  * The type of an expression or object. Complex types are formed via t_subt
  * (for arrays, pointers and functions), as well as t_str.
  */
 struct lint1_type {
 	tspec_t	t_tspec;	/* type specifier */
 	bool	t_incomplete_array : 1;
 	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;
 	/*
 	 * Either the type is currently an enum (having t_tspec ENUM), or
 	 * it is an integer type (typically INT) that has been implicitly
 	 * converted from an enum type.  In both cases, t_enum is valid.
+	 *
 	 * The information about a former enum type is retained to allow
 	 * type checks in expressions such as ((var1 & 0x0001) == var2), to
 	 * detect when var1 and var2 are from incompatible enum types.
 	 */
 	bool	t_is_enum : 1;
 	bool	t_packed : 1;
 	union {
 		int	_t_dim;		/* dimension (if ARRAY) */
 		struct_or_union	*_t_str;
 		enumeration	*_t_enum;
 		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	lint1_type *t_subt; /* element type (if ARRAY),
 				 * return value (if FUNC),
 				 * target type (if PTR) */
 };
 #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 and related things
  */
 typedef enum {
 	NOSCL,
 	EXTERN,		/* external symbols (independent of decl_t) */
 	STATIC,		/* static symbols (local and global) */
 	AUTO,		/* automatic symbols (except register) */
 	REG,		/* register */
 	TYPEDEF,	/* typedef */
 	STRUCT_TAG,
 	UNION_TAG,
 	ENUM_TAG,
 	MOS,		/* member of struct */
 	MOU,		/* member of union */
 	CTCONST,	/* enumerator, enum constant or bool constant */
 	ABSTRACT,	/* abstract symbol (sizeof, casts, unnamed argument) */
 	ARG,		/* argument */
 	PROTO_ARG,	/* 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 initialization */
 	pos_t	s_use_pos;	/* position of first use */
 	symt_t	s_kind;		/* type of symbol */
 	const struct kwtab *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_return_type_implicit_int : 1;
 	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_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 {
 		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_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;
 	bool	tn_relaxed : 1;	/* in strict bool mode, allow mixture between
 				 * bool and scalar, for backwards
 				 * compatibility
 				 */
 	bool	tn_system_dependent : 1; /* depends on sizeof or offsetof */
 	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
 struct generic_association {
 	type_t *ga_arg;		/* NULL means default or error */
 	tnode_t *ga_result;	/* NULL means error */
 	struct generic_association *ga_prev;
 };
 /*
  * For nested declarations a stack exists, which holds all information
  * needed for the current level. dcs points to the innermost element of this
  * stack.
+ *
  * d_ctx describes the context of the current declaration. Its value is
  * one of
  *	EXTERN		global declarations
  *	MOS or MOU	declarations of struct or union members
  *	CTCONST		declarations of enums or boolean constants
  *	ARG		declaration of arguments in old-style function
  *			definitions
  *	PROTO_ARG	declaration of arguments in function prototypes
  *	AUTO		declaration of local symbols
  *	ABSTRACT	abstract declarations (sizeof, casts)
+ *
  */
 typedef	struct dinfo {
 	tspec_t	d_abstract_type;/* VOID, BOOL, CHAR, INT or COMPLEX */
 	tspec_t	d_complex_mod;	/* FLOAT or DOUBLE */
 	tspec_t	d_sign_mod;	/* SIGNED or UNSIGN */
 	tspec_t	d_rank_mod;	/* SHORT, LONG or QUAD */
 	scl_t	d_scl;		/* storage class */
 	type_t	*d_type;	/* after end_type() pointer to the type used
 				   for all declarators */
 	sym_t	*d_redeclared_symbol;
 	u_int	d_offset;	/* offset of next structure member */
 	u_int	d_sou_align_in_bits; /* 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_multiple_storage_classes : 1; /* reported in end_type */
 	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.
 				   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;
 /*
  * The values of the 'case' labels, linked via cl_next in reverse order of
  * appearance in the code, that is from bottom to top.
  */
 typedef	struct case_label {
 	val_t	cl_val;
 	struct case_label *cl_next;
 } case_label_t;
 typedef enum {
 	CS_DO_WHILE,
 	CS_FOR,
 	CS_FUNCTION_BODY,
 	CS_IF,
 	CS_SWITCH,
 	CS_WHILE
 } control_statement_kind;
 /*
  * Used to keep information about nested control statements.
  */
 typedef struct control_statement {
 	control_statement_kind c_kind;	/* to ensure proper nesting */
 	bool	c_loop : 1;		/* 'continue' and 'break' are valid */
 	bool	c_switch : 1;		/* 'case' and 'break' are valid */
 	bool	c_break : 1;		/* the loop/switch has a reachable
 					 * 'break' statement */
 	bool	c_continue : 1;		/* the loop has a reachable 'continue'
 					 * statement */
 	bool	c_default : 1;		/* the switch has a 'default' label */
 	bool	c_maybe_endless : 1;	/* the controlling expression is
 					 * always true (as in 'for (;;)' or
 					 * 'while (1)'), there may be break
 					 * statements though */
 	bool	c_always_then : 1;
 	bool	c_reached_end_of_then : 1;
 	bool	c_had_return_noval : 1;	/* had "return;" */
 	bool	c_had_return_value : 1;	/* had "return expr;" */
 	type_t	*c_switch_type;		/* type of switch expression */
 	tnode_t	*c_switch_expr;
 	case_label_t *c_case_labels;	/* list of case values */
 	struct	memory_block *c_for_expr3_mem; /* saved memory for end of loop
 					 * expression in for() */
 	tnode_t	*c_for_expr3;		/* end of loop expr in for() */
 	pos_t	c_for_expr3_pos;	/* position of end of loop expr */
 	pos_t	c_for_expr3_csrc_pos;	/* same for csrc_pos */
-	struct	control_statement *c_surrounding;
+	struct control_statement *c_surrounding;
-} cstk_t;
+} control_statement;
 typedef struct {
 	size_t lo;			/* inclusive */
 	size_t hi;			/* inclusive */
 } 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))) != 0)
 #define	ERR_ZERO(p)	(void)memset((p), 0, sizeof(*(p)))
 #define INTERNAL_ERROR(fmt, args...) \
 	internal_error(__FILE__, __LINE__, fmt, ##args)
 #define lint_assert(cond)						\
 	do {								\
 		if (!(cond))						\
 			assert_failed(__FILE__, __LINE__, __func__, #cond); \
 	} while (false)
 #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_at(func, msgid, pos, args...)		\
 	do {								\
 		check_printf(__CONCAT(MSG_, msgid), ##args);		\
 		(func)(msgid, pos, ##args);				\
 	} while (false)
 #  define error_at(msgid, pos, args...) \
 	wrap_check_printf_at(error_at, msgid, pos, ##args)
 #  define warning_at(msgid, pos, args...) \
 	wrap_check_printf_at(warning_at, msgid, pos, ##args)
 #  define message_at(msgid, pos, args...) \
 	wrap_check_printf_at(message_at, msgid, pos, ##args)
 #  define wrap_check_printf(func, msgid, args...)			\
 	do {								\
 		check_printf(__CONCAT(MSG_, msgid), ##args);		\
 		(func)(msgid, ##args);					\
 	} while (false)
 #  define error(msgid, args...) wrap_check_printf(error, msgid, ##args)
 #  define warning(msgid, args...) wrap_check_printf(warning, msgid, ##args)
 #  define message(msgid, args...) wrap_check_printf(message, msgid, ##args)
 #  define gnuism(msgid, args...) wrap_check_printf(gnuism, msgid, ##args)
 #  define c99ism(msgid, args...) wrap_check_printf(c99ism, msgid, ##args)
 #  define c11ism(msgid, args...) wrap_check_printf(c11ism, msgid, ##args)
 #endif
 static inline bool
 is_nonzero_val(const val_t *val)
+{
 	return is_floating(val->v_tspec)
 	    ? val->v_ldbl != 0.0
 	    : val->v_quad != 0;
+}
 static inline bool
 constant_is_nonzero(const tnode_t *tn)
+{
 	lint_assert(tn->tn_op == CON);
 	lint_assert(tn->tn_type->t_tspec == tn->tn_val->v_tspec);
 	return is_nonzero_val(tn->tn_val);
+}
 static inline bool
 is_zero(const tnode_t *tn)
+{
 	return tn != NULL && tn->tn_op == CON && !is_nonzero_val(tn->tn_val);
+}
 static inline bool
 is_nonzero(const tnode_t *tn)
+{
 	return tn != NULL && tn->tn_op == CON && is_nonzero_val(tn->tn_val);
+}
 static inline uint64_t
 bit(unsigned i)
+{
 	lint_assert(i < 64);
 	return (uint64_t)1 << i;
+}
 static inline uint64_t
 value_bits(unsigned bitsize)
+{
 	lint_assert(bitsize > 0);
 	/* for long double (80 or 128), double _Complex (128) */
 	/*
 	 * XXX: double _Complex does not have 128 bits of precision,
 	 * therefore it should never be necessary to query the value bits
 	 * of such a type; see d_c99_complex_split.c to trigger this case.
 	 */
 	if (bitsize >= 64)
 		return ~((uint64_t)0);
 	return ~(~(uint64_t)0 << bitsize);
+}
 /* C99 6.7.8p7 */
 static inline bool
 is_struct_or_union(tspec_t t)
+{
 	return t == STRUCT || t == UNION;
+}