 @@ -1,14 +1,14 @@
-/*	$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.
 @@ -27,27 +27,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID) && !defined(lint)
-__RCSID("$NetBSD: func.c,v 1.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;
 @@ -66,27 +66,27 @@ bool	warn_about_unreachable;
  * 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.
 @@ -145,58 +145,58 @@ 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;
+}
 @@ -455,157 +455,157 @@ check_case_label_bitand(const tnode_t *c
 		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);
 @@ -991,95 +991,95 @@ 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 */

 @@ -1,14 +1,14 @@
-/* $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
 @@ -434,28 +434,28 @@ typedef struct control_statement {
 	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];