 @@ -1,14 +1,14 @@
-/* $NetBSD: decl.c,v 1.368 2023/07/30 20:12:35 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.369 2023/07/30 22:38:09 rillig Exp $ */
 /*
  * Copyright (c) 1996 Christopher G. Demetriou.  All Rights Reserved.
  * Copyright (c) 1994, 1995 Jochen Pohl
  * All Rights Reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
 @@ -28,27 +28,27 @@
  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 #if HAVE_NBTOOL_CONFIG_H
 #include "nbtool_config.h"
 #endif
 #include <sys/cdefs.h>
 #if defined(__RCSID)
-__RCSID("$NetBSD: decl.c,v 1.368 2023/07/30 20:12:35 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.369 2023/07/30 22:38:09 rillig Exp $");
 #endif
 #include <sys/param.h>
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 const char unnamed[] = "<unnamed>";
 /* shared type structures for arithmetic types and void */
 static	type_t	typetab[NTSPEC];
 @@ -106,36 +106,38 @@ initdecl(void)
 type_t *
 gettyp(tspec_t t)
+{
 	lint_assert((int)t < (int)STRUCT);
 	/* TODO: make the return type 'const' */
 	return &typetab[t];
+}
 type_t *
 block_dup_type(const type_t *tp)
+{
 	debug_step("%s '%s'", __func__, type_name(tp));
 	type_t *ntp = block_zero_alloc(sizeof(*ntp), "type");
 	*ntp = *tp;
 	return ntp;
+}
 /* Duplicate a type, free the allocated memory after the expression. */
 type_t *
 expr_dup_type(const type_t *tp)
+{
 	debug_step("%s '%s'", __func__, type_name(tp));
 	type_t *ntp = expr_zero_alloc(sizeof(*ntp), "type");
 	*ntp = *tp;
 	return ntp;
+}
 /*
  * Return the unqualified version of the type.  The returned type is freed at
  * the end of the current expression.
+ *
  * See C99 6.2.5p25.
  */
 type_t *
 expr_unqualified_type(const type_t *tp)
 @@ -144,26 +146,27 @@ expr_unqualified_type(const type_t *tp)
 	type_t *ntp = expr_zero_alloc(sizeof(*ntp), "type");
 	*ntp = *tp;
 	ntp->t_const = false;
 	ntp->t_volatile = false;
 	/*
 	 * In case of a struct or union type, the members should lose their
 	 * qualifiers as well, but that would require a deep copy of the
 	 * struct or union type.  This in turn would defeat the type
 	 * comparison in types_compatible, which simply tests whether
 	 * tp1->t_sou == tp2->t_sou.
 	 */
 	debug_step("%s '%s'", __func__, type_name(ntp));
 	return ntp;
+}
 /*
  * Returns whether the argument is void or an incomplete array, struct, union
  * or enum type.
  */
 bool
 is_incomplete(const type_t *tp)
+{
 	tspec_t t = tp->t_tspec;
 	if (t == VOID)
 @@ -203,26 +206,28 @@ dcs_add_storage_class(scl_t sc)
 		warning(83);
+	}
 	if (dcs->d_scl == NOSCL)
 		dcs->d_scl = sc;
 	else if ((dcs->d_scl == EXTERN && sc == THREAD_LOCAL)
 	    || (dcs->d_scl == THREAD_LOCAL && sc == EXTERN))
 		dcs->d_scl = EXTERN;	/* ignore thread_local */
 	else if ((dcs->d_scl == STATIC && sc == THREAD_LOCAL)
 	    || (dcs->d_scl == THREAD_LOCAL && sc == STATIC))
 		dcs->d_scl = STATIC;	/* ignore thread_local */
 	else
 		dcs->d_multiple_storage_classes = true;
 	debug_step("%s:", __func__);
 	debug_dcs(false);
+}
 /* Merge the signedness into the abstract type. */
 static tspec_t
 merge_signedness(tspec_t t, tspec_t s)
+{
 	if (s == SIGNED)
 		return t == CHAR ? SCHAR : t;
 	if (s != UNSIGN)
 		return t;
 	return t == CHAR ? UCHAR
 	    : t == SHORT ? USHORT
 @@ -230,26 +235,28 @@ merge_signedness(tspec_t t, tspec_t s)
 	    : t == LONG ? ULONG
 	    : t == LLONG ? ULLONG
 	    : t;
+}
 /*
  * Called if a list of declaration specifiers contains a typedef name
  * and other specifiers (except struct, union, enum, typedef name).
  */
 static type_t *
 typedef_error(type_t *td, tspec_t t)
+{
 	debug_step("%s: '%s' %s", __func__, type_name(td), tspec_name(t));
 	tspec_t t2 = td->t_tspec;
 	if ((t == SIGNED || t == UNSIGN) &&
 	    (t2 == CHAR || t2 == SHORT || t2 == INT ||
 	     t2 == LONG || t2 == LLONG)) {
 		if (allow_c90)
 			/* modifying typedef with '%s'; only qualifiers... */
 			warning(5, tspec_name(t));
 		td = block_dup_type(gettyp(merge_signedness(t2, t)));
 		td->t_typedef = true;
 		return td;
+	}
 @@ -298,26 +305,27 @@ invalid:
  * Remember the type, modifier or typedef name returned by the parser in the
  * top element of the declaration stack. This information is used in
  * dcs_end_type to build the type used for all declarators in this declaration.
+ *
  * If tp->t_typedef is true, the type comes from a previously defined typename.
  * Otherwise, it comes from a type specifier (int, long, ...) or a
  * struct/union/enum tag.
  */
 void
 dcs_add_type(type_t *tp)
+{
 	debug_step("%s: %s", __func__, type_name(tp));
 	debug_dcs(false);
 	if (tp->t_typedef) {
 		/*
 		 * something like "typedef int a; int a b;"
 		 * This should not happen with current grammar.
 		 */
 		lint_assert(dcs->d_type == NULL);
 		lint_assert(dcs->d_abstract_type == NO_TSPEC);
 		lint_assert(dcs->d_sign_mod == NO_TSPEC);
 		lint_assert(dcs->d_rank_mod == NO_TSPEC);
 		dcs->d_type = tp;
 		return;
+	}
 @@ -326,26 +334,27 @@ dcs_add_type(type_t *tp)
 	if (is_struct_or_union(t) || t == ENUM) {
 		/*
 		 * something like "int struct a ..."
 		 * struct/union/enum with anything else is not allowed
 		 */
 		if (dcs->d_type != NULL || dcs->d_abstract_type != NO_TSPEC ||
 		    dcs->d_rank_mod != NO_TSPEC || dcs->d_sign_mod != NO_TSPEC) {
 			dcs->d_invalid_type_combination = true;
 			dcs->d_abstract_type = NO_TSPEC;
 			dcs->d_sign_mod = NO_TSPEC;
 			dcs->d_rank_mod = NO_TSPEC;
+		}
 		dcs->d_type = tp;
 		debug_dcs(false);
 		return;
+	}
 	if (dcs->d_type != NULL && !dcs->d_type->t_typedef) {
 		/*
 		 * something like "struct a int"
 		 * struct/union/enum with anything else is not allowed
 		 */
 		dcs->d_invalid_type_combination = true;
 		return;
+	}
 	if (t == COMPLEX) {
 @@ -393,26 +402,27 @@ dcs_add_type(type_t *tp)
 			dcs->d_complex_mod = t;
 		} else {
 			if (dcs->d_abstract_type != NO_TSPEC)
 				dcs->d_invalid_type_combination = true;
 			dcs->d_abstract_type = t;
+		}
 	} else if (t == PTR) {
 		dcs->d_type = tp;
 	} else {
 		if (dcs->d_abstract_type != NO_TSPEC)
 			dcs->d_invalid_type_combination = true;
 		dcs->d_abstract_type = t;
+	}
 	debug_dcs(false);
+}
 static void
 set_first_typedef(type_t *tp, sym_t *sym)
+{
 	tspec_t t = tp->t_tspec;
 	if (is_struct_or_union(t) && tp->t_sou->sou_first_typedef == NULL)
 		tp->t_sou->sou_first_typedef = sym;
 	if (t == ENUM && tp->t_enum->en_first_typedef == NULL)
 		tp->t_enum->en_first_typedef = sym;
+}
 @@ -450,26 +460,27 @@ pack_struct_or_union(type_t *tp)
 		// TODO: Maybe update mem->u.s_member.sm_offset_in_bits.
 		if (mem->s_type->t_bitfield) {
 			bits += bit_fields_width(&mem, &named);
 			if (mem == NULL)
 				break;
+		}
 		unsigned int mem_bits = type_size_in_bits(mem->s_type);
 		if (tp->t_tspec == STRUCT)
 			bits += mem_bits;
 		else if (mem_bits > bits)
 			bits = mem_bits;
+	}
 	tp->t_sou->sou_size_in_bits = bits;
 	debug_dcs(false);
+}
 void
 dcs_add_packed(void)
+{
 	if (dcs->d_type == NULL)
 		dcs->d_packed = true;
 	else
 		pack_struct_or_union(dcs->d_type);
+}
 void
 dcs_set_used(void)
 @@ -678,26 +689,27 @@ dcs_merge_declaration_specifiers(void)
+	}
 	if (l == LONG && t == DCOMPLEX) {
 		l = NO_TSPEC;
 		t = LCOMPLEX;
+	}
 	if (t != INT && t != CHAR && (s != NO_TSPEC || l != NO_TSPEC)) {
 		dcs->d_invalid_type_combination = true;
 		l = s = NO_TSPEC;
+	}
 	if (l != NO_TSPEC)
 		t = l;
 	dcs->d_type = gettyp(merge_signedness(t, s));
 	debug_dcs(false);
+}
 /* Create a type in 'dcs->d_type' from the information gathered in 'dcs'. */
 void
 dcs_end_type(void)
+{
 	dcs_merge_declaration_specifiers();
 	if (dcs->d_multiple_storage_classes) {
 		/* only one storage class allowed */
 		error(7);
+	}
 @@ -717,26 +729,27 @@ dcs_end_type(void)
 	if (dcs->d_qual.tq_volatile && dcs->d_type->t_volatile &&
 	    !dcs->d_type->t_typeof) {
 		lint_assert(dcs->d_type->t_typedef);
 		/* typedef already qualified with '%s' */
 		warning(68, "volatile");
+	}
 	if (dcs->d_qual.tq_const || dcs->d_qual.tq_volatile) {
 		dcs->d_type = block_dup_type(dcs->d_type);
 		dcs->d_type->t_const |= dcs->d_qual.tq_const;
 		dcs->d_type->t_volatile |= dcs->d_qual.tq_volatile;
+	}
 	debug_dcs(false);
 	debug_leave();
+}
 /*
  * Return the length of a type in bits. For bit-fields, return the length of
  * the underlying storage type.
+ *
  * Printing a message if the outermost dimension of an array is 0 must
  * be done by the caller. All other problems are reported by this function
  * if name is not NULL.
  */
 int
 length_in_bits(const type_t *tp, const char *name)
 @@ -1026,59 +1039,63 @@ dcs_add_member(sym_t *mem)
 		mem->u.s_member.sm_offset_in_bits = dcs->d_sou_size_in_bits
 		    - dcs->d_sou_size_in_bits % size_in_bits(tp->t_tspec);
 		tp->t_bit_field_offset = dcs->d_sou_size_in_bits
 		    - mem->u.s_member.sm_offset_in_bits;
 		dcs->d_sou_size_in_bits += tp->t_bit_field_width;
 	} else {
 		dcs_align(alignment_in_bits(tp), 0);
 		mem->u.s_member.sm_offset_in_bits = dcs->d_sou_size_in_bits;
 		dcs->d_sou_size_in_bits += type_size_in_bits(tp);
+	}
 	if (union_size > dcs->d_sou_size_in_bits)
 		dcs->d_sou_size_in_bits = union_size;
 	debug_dcs(false);
+}
 sym_t *
 declare_unnamed_member(void)
+{
 	sym_t *mem = block_zero_alloc(sizeof(*mem), "sym");
 	mem->s_name = unnamed;
 	mem->s_kind = FMEMBER;
 	mem->s_scl = dcs->d_kind == DLK_STRUCT ? STRUCT_MEMBER : UNION_MEMBER;
 	mem->s_block_level = -1;
 	mem->s_type = dcs->d_type;
 	mem->u.s_member.sm_containing_type = dcs->d_tag_type->t_sou;
 	dcs_add_member(mem);
 	suppress_bitfieldtype = false;
 	return mem;
+}
 sym_t *
 declare_member(sym_t *dsym)
+{
 	lint_assert(is_member(dsym));
-	if (dcs->d_redeclared_symbol != NULL) {
+	sym_t *rdsym = dcs->d_redeclared_symbol;
-		lint_assert(is_member(dcs->d_redeclared_symbol));
+	if (rdsym != NULL) {
 		debug_sym("rdsym: ", rdsym, "\n");
 		lint_assert(is_member(rdsym));
 		if (dsym->u.s_member.sm_containing_type ==
-		    dcs->d_redeclared_symbol->u.s_member.sm_containing_type) {
+		    rdsym->u.s_member.sm_containing_type) {
 			/* duplicate member name '%s' */
 			error(33, dsym->s_name);
-			rmsym(dcs->d_redeclared_symbol);
+			rmsym(rdsym);
+		}
+	}
 	check_type(dsym);
 	type_t *tp = dsym->s_type;
 	tspec_t t = tp->t_tspec;
 	if (dsym->s_bitfield)
 		check_bit_field(dsym, &t, &tp);
 	else if (t == FUNC) {
 		/* function illegal in structure or union */
 		error(38);
 		dsym->s_type = tp = block_derive_type(tp, t = PTR);
 @@ -1110,64 +1127,67 @@ set_bit_field_width(sym_t *dsym, int bit
 	if (dsym == NULL) {
 		dsym = block_zero_alloc(sizeof(*dsym), "sym");
 		dsym->s_name = unnamed;
 		dsym->s_kind = FMEMBER;
 		dsym->s_scl = STRUCT_MEMBER;
 		dsym->s_type = gettyp(UINT);
 		dsym->s_block_level = -1;
+	}
 	dsym->s_type = block_dup_type(dsym->s_type);
 	dsym->s_type->t_bitfield = true;
 	dsym->s_type->t_bit_field_width = bit_field_width;
 	dsym->s_bitfield = true;
 	debug_sym("set_bit_field_width: ", dsym, "\n");
 	return dsym;
+}
 void
 add_type_qualifiers(type_qualifiers *dst, type_qualifiers src)
+{
 	if (src.tq_const && dst->tq_const)
 		/* duplicate '%s' */
 		warning(10, "const");
 	if (src.tq_volatile && dst->tq_volatile)
 		/* duplicate '%s' */
 		warning(10, "volatile");
 	dst->tq_const = dst->tq_const | src.tq_const;
 	dst->tq_restrict = dst->tq_restrict | src.tq_restrict;
 	dst->tq_volatile = dst->tq_volatile | src.tq_volatile;
 	dst->tq_atomic = dst->tq_atomic | src.tq_atomic;
 	debug_step("%s: '%s'", __func__, type_qualifiers_string(*dst));
+}
 qual_ptr *
 append_qualified_pointer(qual_ptr *p1, qual_ptr *p2)
+{
 	qual_ptr *tail = p2;
 	while (tail->p_next != NULL)
 		tail = tail->p_next;
 	tail->p_next = p1;
 	return p2;
+}
 static type_t *
 block_derive_pointer(type_t *stp, bool is_const, bool is_volatile)
+{
 	type_t *tp = block_derive_type(stp, PTR);
 	tp->t_const = is_const;
 	tp->t_volatile = is_volatile;
 	debug_step("%s: '%s'", __func__, type_name(tp));
 	return tp;
+}
 /*
  * The following 3 functions extend the type of a declarator with
  * pointer, function and array types.
+ *
  * The current type is the type built by dcs_end_type (dcs->d_type) and
  * pointer, function and array types already added for this
  * declarator. The new type extension is inserted between both.
  */
 sym_t *
 add_pointer(sym_t *decl, qual_ptr *p)
 @@ -1222,63 +1242,65 @@ block_derive_array(type_t *stp, bool dim
 		error(301);
 		tp->t_subt = gettyp(CHAR);
+	}
 #endif
 	if (len < 0) {
 		/* negative array dimension (%d) */
 		error(20, len);
 	} else if (len == 0 && dim) {
 		/* zero sized array is a C99 extension */
 		c99ism(322);
 	} else if (len == 0 && !dim)
 		tp->t_incomplete_array = true;
 	debug_step("%s: '%s'", __func__, type_name(tp));
 	return tp;
+}
 /*
  * If a dimension was specified, dim is true, otherwise false
  * n is the specified dimension
  */
 sym_t *
 add_array(sym_t *decl, bool dim, int n)
+{
 	debug_dcs(false);
 	type_t **tpp = &decl->s_type;
 	while (*tpp != NULL && *tpp != dcs->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL) {
 		debug_step("add_array: unchanged '%s'",
 		    type_name(decl->s_type));
 		return decl;
+	}
 	*tpp = block_derive_array(dcs->d_type, dim, n);
-	debug_step("add_array: '%s'", type_name(decl->s_type));
+	debug_step("%s: '%s'", __func__, type_name(decl->s_type));
 	return decl;
+}
 static type_t *
 block_derive_function(type_t *ret, bool proto, sym_t *args, bool vararg)
+{
 	type_t *tp = block_derive_type(ret, FUNC);
 	tp->t_proto = proto;
 	if (proto)
 		tp->t_args = args;
 	tp->t_vararg = vararg;
 	debug_step("%s: '%s'", __func__, type_name(tp));
 	return tp;
+}
 static void
 check_prototype_parameters(sym_t *args)
+{
 	for (sym_t *sym = dcs->d_first_dlsym;
 	     sym != NULL; sym = sym->s_level_next) {
 		scl_t sc = sym->s_scl;
 		if (sc == STRUCT_TAG || sc == UNION_TAG || sc == ENUM_TAG) {
 			/* dubious tag declaration '%s %s' */
 			warning(85, storage_class_name(sc), sym->s_name);
 @@ -1485,45 +1507,47 @@ declarator_name(sym_t *sym)
+		}
 		break;
 	default:
 		lint_assert(dcs->d_kind == DLK_ABSTRACT);
 		/* try to continue after syntax errors */
 		sc = NOSCL;
+	}
 	sym->s_scl = sc;
 	sym->s_type = dcs->d_type;
 	dcs->d_func_proto_syms = NULL;
 	debug_sym("declarator_name: ", sym, "\n");
 	return sym;
+}
 sym_t *
 old_style_function_parameter_name(sym_t *sym)
+{
 	if (sym->s_scl != NOSCL) {
 		if (block_level == sym->s_block_level) {
 			/* redeclaration of formal parameter '%s' */
 			error(21, sym->s_name);
 			lint_assert(sym->s_defarg);
+		}
 		sym = pushdown(sym);
+	}
 	sym->s_type = gettyp(INT);
 	sym->s_scl = AUTO;
 	sym->s_def = DEF;
 	sym->s_defarg = sym->s_arg = true;
 	debug_sym("old_style_function_parameter_name: ", sym, "\n");
 	return sym;
+}
 /*-
  * Checks all possible cases of tag redeclarations.
+ *
  * decl		whether T_LBRACE follows
  * semi		whether T_SEMI follows
  */
 static sym_t *
 new_tag(sym_t *tag, scl_t scl, bool decl, bool semi)
+{
 @@ -1565,26 +1589,27 @@ new_tag(sym_t *tag, scl_t scl, bool decl
+		}
 	} else {
 		if (tag->s_scl != scl ||
 		    (decl && !is_incomplete(tag->s_type))) {
 			/* %s tag '%s' redeclared as %s */
 			error(46, storage_class_name(tag->s_scl),
 			    tag->s_name, storage_class_name(scl));
 			print_previous_declaration(tag);
 			tag = pushdown(tag);
 			dcs->d_enclosing->d_nonempty_decl = true;
 		} else if (semi || decl)
 			dcs->d_enclosing->d_nonempty_decl = true;
+	}
 	debug_sym("new_tag: ", tag, "\n");
 	return tag;
+}
 /*-
  * tag		the symbol table entry of the tag
  * kind		the kind of the tag (STRUCT/UNION/ENUM)
  * decl		whether the tag type will be completed in this declaration
  *		(when the following token is T_LBRACE)
  * semi		whether the following token is T_SEMI
  */
 type_t *
 make_tag_type(sym_t *tag, tspec_t kind, bool decl, bool semi)
+{
 @@ -1640,26 +1665,28 @@ make_tag_type(sym_t *tag, tspec_t kind,
 			tp->t_sou = block_zero_alloc(sizeof(*tp->t_sou),
 			    "struct_or_union");
 			tp->t_sou->sou_align_in_bits = CHAR_SIZE;
 			tp->t_sou->sou_tag = tag;
 			tp->t_sou->sou_incomplete = true;
 		} else {
 			tp->t_is_enum = true;
 			tp->t_enum = block_zero_alloc(sizeof(*tp->t_enum),
 			    "enumeration");
 			tp->t_enum->en_tag = tag;
 			tp->t_enum->en_incomplete = true;
+		}
+	}
 	debug_printf("%s: '%s'", __func__, type_name(tp));
 	debug_sym(" ", tag, "\n");
 	return tp;
+}
 const char *
 storage_class_name(scl_t sc)
+{
 	switch (sc) {
 	case EXTERN:	return "extern";
 	case STATIC:	return "static";
 	case AUTO:	return "auto";
 	case REG:	return "register";
 	case TYPEDEF:	return "typedef";
 	case STRUCT_TAG:return "struct";
 @@ -1700,36 +1727,38 @@ complete_struct_or_union(sym_t *first_me
 	sou->sou_first_member = first_member;
 	if (tp->t_packed)
 		pack_struct_or_union(tp);
 	else
 		sou->sou_size_in_bits = dcs->d_sou_size_in_bits;
 	if (sou->sou_size_in_bits == 0) {
 		/* zero sized %s is a C99 feature */
 		c99ism(47, tspec_name(tp->t_tspec));
 	} else if (!has_named_member(tp)) {
 		/* '%s' has no named members */
 		warning(65, type_name(tp));
+	}
 	debug_step("%s: '%s'", __func__, type_name(tp));
 	return tp;
+}
 type_t *
 complete_enum(sym_t *first_enumerator)
+{
 	type_t *tp = dcs->d_tag_type;
 	tp->t_enum->en_incomplete = false;
 	tp->t_enum->en_first_enumerator = first_enumerator;
 	debug_step("%s: '%s'", __func__, type_name(tp));
 	return tp;
+}
 /*
  * Processes the name of an enumerator in an enum declaration.
+ *
  * sym points to the enumerator
  * val is the value of the enumerator
  * impl is true if the value of the enumerator was not explicitly specified.
  */
 sym_t *
 enumeration_constant(sym_t *sym, int val, bool impl)
+{
 @@ -1759,26 +1788,27 @@ enumeration_constant(sym_t *sym, int val
 		sym = pushdown(sym);
+	}
 	sym->s_scl = ENUM_CONST;
 	sym->s_type = dcs->d_tag_type;
 	sym->u.s_enum_constant = val;
 	if (impl && val == TARG_INT_MIN) {
 		/* enumeration value '%s' overflows */
 		warning(48, sym->s_name);
+	}
 	enumval = val == TARG_INT_MAX ? TARG_INT_MIN : val + 1;
 	debug_sym("enumeration_constant: ", sym, "\n");
 	return sym;
+}
 static bool
 ends_with(const char *s, const char *suffix)
+{
 	size_t s_len = strlen(s);
 	size_t suffix_len = strlen(suffix);
 	return s_len >= suffix_len &&
 	       memcmp(s + s_len - suffix_len, suffix, suffix_len) == 0;
+}
 void
 @@ -1832,49 +1862,49 @@ check_init(sym_t *sym)
 			error(26, sym->s_name);
 			return true;
+		}
+	}
 	return false;
+}
 /*
  * Compares a prototype declaration with the remembered arguments of a previous
  * old-style function definition.
  */
 static bool
-check_old_style_definition(sym_t *rdsym, sym_t *dsym)
+check_old_style_definition(const sym_t *rdsym, const sym_t *dsym)
+{
-	sym_t *args = rdsym->u.s_old_style_args;
+	const sym_t *args = rdsym->u.s_old_style_args;
-	sym_t *pargs = dsym->s_type->t_args;
+	const sym_t *pargs = dsym->s_type->t_args;
 	bool msg = false;
 	int narg = 0;
-	for (sym_t *arg = args; arg != NULL; arg = arg->s_next)
+	for (const sym_t *arg = args; arg != NULL; arg = arg->s_next)
 		narg++;
 	int nparg = 0;
-	for (sym_t *parg = pargs; parg != NULL; parg = parg->s_next)
+	for (const sym_t *parg = pargs; parg != NULL; parg = parg->s_next)
 		nparg++;
 	if (narg != nparg) {
 		/* prototype does not match old-style definition */
 		error(63);
 		msg = true;
 		goto end;
+	}
-	sym_t *arg = args;
+	const sym_t *arg = args;
-	sym_t *parg = pargs;
+	const sym_t *parg = pargs;
 	int n = 1;
 	while (narg-- > 0) {
 		bool dowarn = false;
 		if (!types_compatible(arg->s_type, parg->s_type,
 		    true, true, &dowarn) ||
 		    dowarn) {
 			/* prototype does not match old-style ... */
 			error(299, n);
 			msg = true;
+		}
 		arg = arg->s_next;
 		parg = parg->s_next;
 		n++;
 @@ -1994,49 +2024,53 @@ declare_extern(sym_t *dsym, bool has_ini
 				dsym->s_inline = true;
 			complete_type(dsym, rdsym);
+		}
 		rmsym(rdsym);
+	}
 	if (dsym->s_scl == TYPEDEF) {
 		dsym->s_type = block_dup_type(dsym->s_type);
 		dsym->s_type->t_typedef = true;
 		set_first_typedef(dsym->s_type, dsym);
+	}
 	debug_printf("%s: ", __func__);
 	debug_sym("", dsym, "\n");
+}
 void
 declare(sym_t *decl, bool has_initializer, sbuf_t *renaming)
+{
 	if (dcs->d_kind == DLK_EXTERN)
 		declare_extern(decl, has_initializer, renaming);
 	else if (dcs->d_kind == DLK_OLD_STYLE_ARGS ||
 		 dcs->d_kind == DLK_PROTO_PARAMS) {
 		if (renaming != NULL) {
 			/* symbol renaming can't be used on function arguments */
 			error(310);
 		} else
 			(void)declare_argument(decl, has_initializer);
 	} else {
 		lint_assert(dcs->d_kind == DLK_AUTO);
 		if (renaming != NULL) {
 			/* symbol renaming can't be used on automatic variables */
 			error(311);
 		} else
 			declare_local(decl, has_initializer);
+	}
 	debug_printf("%s: ", __func__);
 	debug_sym("", decl, "\n");
+}
 /*
  * Copies information about usage into a new symbol table entry of
  * the same symbol.
  */
 void
 copy_usage_info(sym_t *sym, sym_t *rdsym)
+{
 	sym->s_set_pos = rdsym->s_set_pos;
 	sym->s_use_pos = rdsym->s_use_pos;
 	sym->s_set = rdsym->s_set;
 @@ -2282,26 +2316,29 @@ complete_type(sym_t *dsym, sym_t *ssym)
 				dst->t_dim = src->t_dim;
 				dst->t_incomplete_array = false;
+			}
 		} else if (dst->t_tspec == FUNC) {
 			if (!dst->t_proto && src->t_proto) {
 				*dstp = dst = block_dup_type(dst);
 				dst->t_proto = true;
 				dst->t_args = src->t_args;
+			}
+		}
 		dstp = &dst->t_subt;
 		src = src->t_subt;
+	}
 	debug_printf("%s: ", __func__);
 	debug_sym("dsym: ", dsym, "");
 	debug_sym("ssym: ", ssym, "\n");
+}
 /*
  * Completes the declaration of a single argument.
  */
 sym_t *
 declare_argument(sym_t *sym, bool has_initializer)
+{
 	check_function_definition(sym, true);
 	check_type(sym);
 @@ -2344,26 +2381,28 @@ declare_argument(sym_t *sym, bool has_in
 		warning(269, sym->s_name);
 	/*
 	 * Arguments must have complete types. length_in_bits prints the
 	 * needed error messages (null dimension is impossible because arrays
 	 * are converted to pointers).
 	 */
 	if (sym->s_type->t_tspec != VOID)
 		(void)length_in_bits(sym->s_type, sym->s_name);
 	sym->s_used = dcs->d_used;
 	mark_as_set(sym);
 	debug_printf("%s: ", __func__);
 	debug_sym("", sym, "\n");
 	return sym;
+}
 static bool
 is_character_pointer(const type_t *tp)
+{
 	tspec_t st;
 	return tp->t_tspec == PTR &&
 	       (st = tp->t_subt->t_tspec,
 		   st == CHAR || st == SCHAR || st == UCHAR);
+}
 @@ -2409,27 +2448,27 @@ check_func_lint_directives(void)
 	} else if (printflike_argnum == 0) {
 		printflike_argnum = -1;
+	}
 	if (scanflike_argnum > narg) {
 		/* argument number mismatch in comment ** %s ** */
 		warning(283, "SCANFLIKE");
 		scanflike_argnum = -1;
 	} else if (scanflike_argnum == 0) {
 		scanflike_argnum = -1;
+	}
 	if (printflike_argnum != -1 || scanflike_argnum != -1) {
 		narg = printflike_argnum != -1
 		    ? printflike_argnum : scanflike_argnum;
-		sym_t *arg = dcs->d_func_args;
+		const sym_t *arg = dcs->d_func_args;
 		for (int n = 1; n < narg; n++)
 			arg = arg->s_next;
 		if (!is_character_pointer(arg->s_type)) {
 			/* argument %d must be 'char *' for PRINTFLIKE/... */
 			warning(293, narg);
 			printflike_argnum = scanflike_argnum = -1;
+		}
+	}
+}
 /*
  * Checks compatibility of an old-style function definition with a previous
  * prototype declaration.
 @@ -2718,26 +2757,29 @@ declare_local(sym_t *dsym, bool has_init
 		mark_as_set(dsym);
+	}
 	if (dsym->s_scl == TYPEDEF) {
 		dsym->s_type = block_dup_type(dsym->s_type);
 		dsym->s_type->t_typedef = true;
 		set_first_typedef(dsym->s_type, dsym);
+	}
 	if (dsym->s_scl == STATIC && any_query_enabled) {
 		/* static variable '%s' in function */
 		query_message(11, dsym->s_name);
+	}
 	debug_printf("%s: ", __func__);
 	debug_sym("", dsym, "\n");
+}
 /* Create a symbol for an abstract declaration. */
 sym_t *
 abstract_name(void)
+{
 	lint_assert(dcs->d_kind == DLK_ABSTRACT
 	    || dcs->d_kind == DLK_PROTO_PARAMS);
 	sym_t *sym = block_zero_alloc(sizeof(*sym), "sym");
 	sym->s_name = unnamed;
 	sym->s_def = DEF;
 @@ -2748,26 +2790,28 @@ abstract_name(void)
 	/*
 	 * At this point, dcs->d_type contains only the basic type.  That
 	 * type will be updated later, adding pointers, arrays and functions
 	 * as necessary.
 	 */
 	/*
 	 * XXX: This is not the correct type.  For example in msg_347, it is
 	 * the type of the last prototype parameter, but it should rather be
 	 * the return type of the function.
 	 */
 	sym->s_type = dcs->d_type;
 	dcs->d_redeclared_symbol = NULL;
 	debug_printf("%s: ", __func__);
 	debug_sym("", sym, "\n");
 	return sym;
+}
 /* Removes anything which has nothing to do on global level. */
 void
 global_clean_up(void)
+{
 	while (dcs->d_enclosing != NULL)
 		end_declaration_level();
 	clean_up_after_error();
 	block_level = 0;