 @@ -1,14 +1,14 @@
-/* $NetBSD: decl.c,v 1.246 2022/02/27 08:31:26 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.247 2022/02/27 10:31:58 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) && !defined(lint)
-__RCSID("$NetBSD: decl.c,v 1.246 2022/02/27 08:31:26 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.247 2022/02/27 10:31:58 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;
 @@ -149,52 +149,49 @@ scl_name(scl_t scl)
 	    "none", "extern", "static", "auto", "register", "typedef",
 	    "struct", "union", "enum", "member of struct", "member of union",
 	    "compile-time constant", "abstract",
 	    "old-style function argument", "prototype argument", "inline"
 	};
 	return names[scl];
+}
 #endif
 /*
  * Returns a shared type structure for arithmetic types and void.
+ *
- * It's important to duplicate this structure (using dup_type() or
+ * It's important to duplicate this structure using block_dup_type or
- * expr_dup_type()) if it is to be modified (adding qualifiers or anything
+ * expr_dup_type if it is to be modified (adding qualifiers or anything
  * else).
  */
 type_t *
 gettyp(tspec_t t)
+{
 	/* TODO: make the return type 'const' */
 	return &typetab[t];
+}
 type_t *
-dup_type(const type_t *tp)
+block_dup_type(const type_t *tp)
+{
 	type_t	*ntp;
 	ntp = block_zero_alloc(sizeof(*ntp));
 	*ntp = *tp;
 	return ntp;
+}
-/*
+/* Duplicate a type, free the allocated memory after the expression. */
  * Use expr_dup_type() instead of dup_type() inside expressions (if the
  * allocated memory should be freed after the expr).
  */
 type_t *
 expr_dup_type(const type_t *tp)
+{
 	type_t	*ntp;
 	ntp = expr_zero_alloc(sizeof(*ntp));
 	*ntp = *tp;
 	return ntp;
+}
 /*
  * Return the unqualified version of the type.  The returned type is freed at
  * the end of the current expression.
 @@ -441,60 +438,60 @@ merge_signedness(tspec_t t, tspec_t s)
 static type_t *
 tdeferr(type_t *td, tspec_t t)
+{
 	tspec_t	t2;
 	t2 = td->t_tspec;
 	if ((t == SIGNED || t == UNSIGN) &&
 	    (t2 == CHAR || t2 == SHORT || t2 == INT ||
 	     t2 == LONG || t2 == QUAD)) {
 		if (!tflag)
 			/* modifying typedef with '%s'; only qualifiers... */
 			warning(5, tspec_name(t));
-		td = dup_type(gettyp(merge_signedness(t2, t)));
+		td = block_dup_type(gettyp(merge_signedness(t2, t)));
 		td->t_typedef = true;
 		return td;
+	}
 	if (t == SHORT && (t2 == INT || t2 == UINT)) {
 		/* modifying typedef with '%s'; only qualifiers allowed */
 		warning(5, "short");
-		td = dup_type(gettyp(t2 == INT ? SHORT : USHORT));
+		td = block_dup_type(gettyp(t2 == INT ? SHORT : USHORT));
 		td->t_typedef = true;
 		return td;
+	}
 	if (t == LONG &&
 	    (t2 == INT || t2 == UINT || t2 == LONG || t2 == ULONG ||
 	     t2 == FLOAT || t2 == DOUBLE || t2 == DCOMPLEX)) {
 		/* modifying typedef with '%s'; only qualifiers allowed */
 		warning(5, "long");
 		if (t2 == INT) {
 			td = gettyp(LONG);
 		} else if (t2 == UINT) {
 			td = gettyp(ULONG);
 		} else if (t2 == LONG) {
 			td = gettyp(QUAD);
 		} else if (t2 == ULONG) {
 			td = gettyp(UQUAD);
 		} else if (t2 == FLOAT) {
 			td = gettyp(DOUBLE);
 		} else if (t2 == DOUBLE) {
 			td = gettyp(LDOUBLE);
 		} else if (t2 == DCOMPLEX) {
 			td = gettyp(LCOMPLEX);
+		}
-		td = dup_type(td);
+		td = block_dup_type(td);
 		td->t_typedef = true;
 		return td;
+	}
 	/* Anything else is not accepted. */
 	dcs->d_invalid_type_combination = true;
 	return td;
+}
 /*
  * Remember the symbol of a typedef name (2nd arg) in a struct, union
  * or enum tag if the typedef name is the first defined for this tag.
+ *
 @@ -854,27 +851,27 @@ end_type(void)
 	if (dcs->d_const && dcs->d_type->t_const) {
 		lint_assert(dcs->d_type->t_typedef);
 		/* typedef already qualified with '%s' */
 		warning(68, "const");
+	}
 	if (dcs->d_volatile && dcs->d_type->t_volatile) {
 		lint_assert(dcs->d_type->t_typedef);
 		/* typedef already qualified with '%s' */
 		warning(68, "volatile");
+	}
 	if (dcs->d_const || dcs->d_volatile) {
-		dcs->d_type = dup_type(dcs->d_type);
+		dcs->d_type = block_dup_type(dcs->d_type);
 		dcs->d_type->t_const |= dcs->d_const;
 		dcs->d_type->t_volatile |= dcs->d_volatile;
+	}
+}
 /*
  * Return the length of a type in bits.
+ *
  * Printing a message if the outermost dimension of an array is 0 must
  * be done by the caller. All other problems are reported by length()
  * if name is not NULL.
  */
 int
 @@ -985,29 +982,30 @@ check_type(sym_t *sym)
 		 * a better warning is printed in funcdef().
 		 */
 		if (t == FUNC && !tp->t_proto &&
 		    !(to == NOTSPEC && sym->s_osdef)) {
 			if (sflag && hflag)
 				/* function declaration is not a prototype */
 				warning(287);
+		}
 		if (to == FUNC) {
 			if (t == FUNC || t == ARRAY) {
 				/* function returns illegal type */
 				error(15);
 				if (t == FUNC) {
-					*tpp = derive_type(*tpp, PTR);
+					*tpp = block_derive_type(*tpp, PTR);
 				} else {
-					*tpp = derive_type((*tpp)->t_subt, PTR);
+					*tpp = block_derive_type(
 					    (*tpp)->t_subt, PTR);
+				}
 				return;
 			} else if (tp->t_const || tp->t_volatile) {
 				if (sflag) {	/* XXX or better !tflag ? */
 					/* function cannot return const... */
 					warning(228);
+				}
+			}
 		} if (to == ARRAY) {
 			if (t == FUNC) {
 				/* array of function is illegal */
 				error(16);
 				*tpp = gettyp(INT);
 @@ -1095,27 +1093,27 @@ check_bit_field_type(sym_t *dsym,  type_
+		}
 	} else if (t != INT && t != UINT && t != BOOL) {
 		/*
 		 * Non-integer types are always illegal for bitfields,
 		 * regardless of BITFIELDTYPE. Integer types not dealt with
 		 * above are okay only if BITFIELDTYPE is in effect.
 		 */
 		if (!(bitfieldtype_ok || gflag) || !is_integer(t)) {
 			unsigned int sz;
 			/* illegal bit-field type '%s' */
 			warning(35, type_name(tp));
 			sz = tp->t_flen;
-			dsym->s_type = tp = dup_type(gettyp(t = INT));
+			dsym->s_type = tp = block_dup_type(gettyp(t = INT));
 			if ((tp->t_flen = sz) > size_in_bits(t))
 				tp->t_flen = size_in_bits(t);
 			*inout_t = t;
 			*inout_tp = tp;
+		}
+	}
+}
 static void
 declare_bit_field(sym_t *dsym, tspec_t *inout_t, type_t **const inout_tp)
+{
 	type_t *tp;
 	tspec_t t;
 @@ -1165,27 +1163,27 @@ declarator_1_struct_union(sym_t *dsym)
 			rmsym(dcs->d_redeclared_symbol);
+		}
+	}
 	check_type(dsym);
 	t = (tp = dsym->s_type)->t_tspec;
 	if (dsym->s_bitfield) {
 		declare_bit_field(dsym, &t, &tp);
 	} else if (t == FUNC) {
 		/* function illegal in structure or union */
 		error(38);
-		dsym->s_type = tp = derive_type(tp, t = PTR);
+		dsym->s_type = tp = block_derive_type(tp, t = PTR);
+	}
 	/*
 	 * bit-fields of length 0 are not warned about because length()
 	 * does not return the length of the bit-field but the length
 	 * of the type the bit-field is packed in (it's ok)
 	 */
 	if ((sz = length(dsym->s_type, dsym->s_name)) == 0) {
 		if (t == ARRAY && dsym->s_type->t_dim == 0) {
 			/* zero sized array in struct is a C99 extension: %s */
 			c99ism(39, dsym->s_name);
+		}
+	}
 @@ -1249,27 +1247,27 @@ align(unsigned int al, unsigned int len)
  */
 sym_t *
 bitfield(sym_t *dsym, int len)
+{
 	if (dsym == NULL) {
 		dsym = block_zero_alloc(sizeof(*dsym));
 		dsym->s_name = unnamed;
 		dsym->s_kind = FMEMBER;
 		dsym->s_scl = MOS;
 		dsym->s_type = gettyp(UINT);
 		dsym->s_block_level = -1;
+	}
-	dsym->s_type = dup_type(dsym->s_type);
+	dsym->s_type = block_dup_type(dsym->s_type);
 	dsym->s_type->t_bitfield = true;
 	dsym->s_type->t_flen = len;
 	dsym->s_bitfield = true;
 	return dsym;
+}
 /*
  * A sequence of asterisks and qualifiers, from right to left.  For example,
  * 'const ***volatile **const volatile' results in [cvp, p, vp, p, p].  The
  * leftmost 'const' is not included in this list, it is stored in dcs->d_const
  * instead.
  */
 qual_ptr *
 @@ -2004,27 +2002,27 @@ declare_extern(sym_t *dsym, bool initflg
 			/* once a function is inline, it remains inline */
 			if (rdsym->s_inline)
 				dsym->s_inline = true;
 			complete_type(dsym, rdsym);
+		}
 		rmsym(rdsym);
+	}
 	if (dsym->s_scl == TYPEDEF) {
-		dsym->s_type = dup_type(dsym->s_type);
+		dsym->s_type = block_dup_type(dsym->s_type);
 		dsym->s_type->t_typedef = true;
 		settdsym(dsym->s_type, dsym);
+	}
+}
 void
 declare(sym_t *decl, bool initflg, sbuf_t *renaming)
+{
 	if (dcs->d_ctx == EXTERN) {
 		declare_extern(decl, initflg, renaming);
 	} else if (dcs->d_ctx == OLD_STYLE_ARG || dcs->d_ctx == PROTO_ARG) {
 @@ -2360,33 +2358,33 @@ void
 complete_type(sym_t *dsym, sym_t *ssym)
+{
 	type_t	**dstp, *src;
 	type_t	*dst;
 	dstp = &dsym->s_type;
 	src = ssym->s_type;
 	while ((dst = *dstp) != NULL) {
 		lint_assert(src != NULL);
 		lint_assert(dst->t_tspec == src->t_tspec);
 		if (dst->t_tspec == ARRAY) {
 			if (dst->t_dim == 0 && src->t_dim != 0) {
-				*dstp = dst = dup_type(dst);
+				*dstp = dst = block_dup_type(dst);
 				dst->t_dim = src->t_dim;
 				setcomplete(dst, true);
+			}
 		} else if (dst->t_tspec == FUNC) {
 			if (!dst->t_proto && src->t_proto) {
-				*dstp = dst = dup_type(dst);
+				*dstp = dst = block_dup_type(dst);
 				dst->t_proto = true;
 				dst->t_args = src->t_args;
+			}
+		}
 		dstp = &dst->t_subt;
 		src = src->t_subt;
+	}
+}
 /*
  * Completes the declaration of a single argument.
  */
 sym_t *
 @@ -2411,32 +2409,32 @@ declare_argument(sym_t *sym, bool initfl
 		error(53, sym->s_name);
 		sym->s_arg = true;
+	}
 	if (initflg) {
 		/* cannot initialize parameter: %s */
 		error(52, sym->s_name);
+	}
 	if (sym->s_type == NULL)	/* for c(void()) */
 		sym->s_type = gettyp(VOID);
 	if ((t = sym->s_type->t_tspec) == ARRAY) {
-		sym->s_type = derive_type(sym->s_type->t_subt, PTR);
+		sym->s_type = block_derive_type(sym->s_type->t_subt, PTR);
 	} else if (t == FUNC) {
 		if (tflag)
 			/* a function is declared as an argument: %s */
 			warning(50, sym->s_name);
-		sym->s_type = derive_type(sym->s_type, PTR);
+		sym->s_type = block_derive_type(sym->s_type, PTR);
 	} else if (t == FLOAT) {
 		if (tflag)
 			sym->s_type = gettyp(DOUBLE);
+	}
 	if (dcs->d_inline)
 		/* argument declared inline: %s */
 		warning(269, sym->s_name);
 	/*
 	 * Arguments must have complete types. length() prints the needed
 	 * error messages (null dimension is impossible because arrays are
 	 * converted to pointers).
 @@ -2745,27 +2743,27 @@ declare_local(sym_t *dsym, bool initflg)
 			outsym(dsym, dsym->s_ext_sym->s_scl, dsym->s_def);
+		}
+	}
 	if (dcs->d_redeclared_symbol != NULL)
 		check_local_redeclaration(dsym, dcs->d_redeclared_symbol);
 	if (initflg && !check_init(dsym)) {
 		dsym->s_def = DEF;
 		mark_as_set(dsym);
+	}
 	if (dsym->s_scl == TYPEDEF) {
-		dsym->s_type = dup_type(dsym->s_type);
+		dsym->s_type = block_dup_type(dsym->s_type);
 		dsym->s_type->t_typedef = true;
 		settdsym(dsym->s_type, dsym);
+	}
 	/*
 	 * Before we can check the size we must wait for a initialization
 	 * which may follow.
 	 */
+}
 /*
  * Processes (re)declarations of external symbols inside blocks.
  */

 @@ -1,14 +1,14 @@
-/*	$NetBSD: externs1.h,v 1.147 2022/02/27 08:31:26 rillig Exp $	*/
+/*	$NetBSD: externs1.h,v 1.148 2022/02/27 10:31:58 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.
 @@ -158,27 +158,27 @@ extern	void	internal_error(const char *,
 extern	void	assert_failed(const char *, int, const char *, const char *)
 		__attribute__((__noreturn__));
 extern	void	update_location(const char *, int, bool, bool);
 /*
  * decl.c
  */
 extern	dinfo_t	*dcs;
 extern	const	char *unnamed;
 extern	int	enumval;
 extern	void	initdecl(void);
 extern	type_t	*gettyp(tspec_t);
-extern	type_t	*dup_type(const type_t *);
+extern	type_t	*block_dup_type(const type_t *);
 extern	type_t	*expr_dup_type(const type_t *);
 extern	type_t	*expr_unqualified_type(const type_t *);
 extern	bool	is_incomplete(const type_t *);
 extern	void	setcomplete(type_t *, bool);
 extern	void	add_storage_class(scl_t);
 extern	void	add_type(type_t *);
 extern	void	add_qualifier(tqual_t);
 extern	void	addpacked(void);
 extern	void	add_attr_used(void);
 extern	void	begin_declaration_level(scl_t);
 extern	void	end_declaration_level(void);
 extern	void	setasm(void);
 extern	void	begin_type(void);
 @@ -219,27 +219,27 @@ extern	void	check_size(sym_t *);
 extern	void	mark_as_set(sym_t *);
 extern	void	mark_as_used(sym_t *, bool, bool);
 extern	void	check_usage(dinfo_t *);
 extern	void	check_usage_sym(bool, sym_t *);
 extern	void	check_global_symbols(void);
 extern	void	print_previous_declaration(int, const sym_t *);
 extern	int	to_int_constant(tnode_t *, bool);
 extern	const char *scl_name(scl_t);
 /*
  * tree.c
  */
 extern	const tnode_t *before_conversion(const tnode_t *);
-extern	type_t	*derive_type(type_t *, tspec_t);
+extern	type_t	*block_derive_type(type_t *, tspec_t);
 extern	type_t	*expr_derive_type(type_t *, tspec_t);
 extern	bool	is_compiler_builtin(const char *);
 extern	tnode_t	*build_constant(type_t *, val_t *);
 extern	tnode_t	*build_name(sym_t *, bool);
 extern	tnode_t	*build_string(strg_t *);
 extern	tnode_t	*build_generic_selection(const tnode_t *,
 		    struct generic_association *);
 extern	tnode_t	*build_binary(tnode_t *, op_t, bool, tnode_t *);
 extern	tnode_t	*build_unary(op_t, bool, tnode_t *);
 extern	tnode_t	*build_member_access(tnode_t *, op_t, bool, sbuf_t *);
 extern	tnode_t	*cconv(tnode_t *);
 extern	bool	is_typeok_bool_operand(const tnode_t *);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: tree.c,v 1.405 2022/02/27 08:31:26 rillig Exp $	*/
+/*	$NetBSD: tree.c,v 1.406 2022/02/27 10:31:58 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: tree.c,v 1.405 2022/02/27 08:31:26 rillig Exp $");
+__RCSID("$NetBSD: tree.c,v 1.406 2022/02/27 10:31:58 rillig Exp $");
 #endif
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <signal.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 #include "cgram.h"
 static	tnode_t	*build_integer_constant(tspec_t, int64_t);
 @@ -94,27 +94,27 @@ static	void	check_array_index(tnode_t *,
 static	void	check_integer_comparison(op_t, tnode_t *, tnode_t *);
 static	void	check_precedence_confusion(tnode_t *);
 extern sig_atomic_t fpe;
 static const char *
 op_name(op_t op)
+{
 	return modtab[op].m_name;
+}
 /* Build 'pointer to tp', 'array of tp' or 'function returning tp'. */
 type_t *
-derive_type(type_t *tp, tspec_t t)
+block_derive_type(type_t *tp, tspec_t t)
+{
 	type_t	*tp2;
 	tp2 = block_zero_alloc(sizeof(*tp2));
 	tp2->t_tspec = t;
 	tp2->t_subt = tp;
 	return tp2;
+}
 /*
  * Derive 'pointer to tp' or 'function returning tp'.
  * The memory is freed at the end of the current expression.
  */
 @@ -163,36 +163,36 @@ build_integer_constant(tspec_t t, int64_
+}
 static void
 fallback_symbol(sym_t *sym)
+{
 	if (fallback_symbol_strict_bool(sym))
 		return;
 	if (block_level > 0 && (strcmp(sym->s_name, "__FUNCTION__") == 0 ||
 			   strcmp(sym->s_name, "__PRETTY_FUNCTION__") == 0)) {
 		/* __FUNCTION__/__PRETTY_FUNCTION__ is a GCC extension */
 		gnuism(316);
-		sym->s_type = derive_type(gettyp(CHAR), PTR);
+		sym->s_type = block_derive_type(gettyp(CHAR), PTR);
 		sym->s_type->t_const = true;
 		return;
+	}
 	if (block_level > 0 && strcmp(sym->s_name, "__func__") == 0) {
 		if (!Sflag)
 			/* __func__ is a C9X feature */
 			warning(317);
-		sym->s_type = derive_type(gettyp(CHAR), PTR);
+		sym->s_type = block_derive_type(gettyp(CHAR), PTR);
 		sym->s_type->t_const = true;
 		return;
+	}
 	/* '%s' undefined */
 	error(99, sym->s_name);
+}
 /*
  * Functions that are predeclared by GCC or other compilers can be called
  * with arbitrary arguments.  Since lint usually runs after a successful
  * compilation, it's the compiler's job to catch any errors.
  */
 @@ -247,27 +247,27 @@ build_name_call(sym_t *sym)
 		 */
 		if (gflag && is_gcc_bool_builtin(sym->s_name))
 			sym->s_type = gettyp(BOOL);
 	} else if (Sflag) {
 		/* function '%s' implicitly declared to return int */
 		error(215, sym->s_name);
 	} else if (sflag) {
 		/* function '%s' implicitly declared to return int */
 		warning(215, sym->s_name);
+	}
 	/* XXX if tflag is set, the symbol should be exported to level 0 */
-	sym->s_type = derive_type(sym->s_type, FUNC);
+	sym->s_type = block_derive_type(sym->s_type, FUNC);
+}
 /* Create a node for a name (symbol table entry). */
 tnode_t *
 build_name(sym_t *sym, bool is_funcname)
+{
 	tnode_t	*n;
 	if (sym->s_scl == NOSCL) {
 		sym->s_scl = EXTERN;
 		sym->s_def = DECL;
 		if (is_funcname)
 			build_name_call(sym);
 @@ -4552,27 +4552,27 @@ begin_statement_expr(void)
+{
 	stmt_expr *se = xmalloc(sizeof(*se));
 	se->se_mem = expr_save_memory();
 	se->se_sym = NULL;
 	se->se_enclosing = stmt_exprs;
 	stmt_exprs = se;
+}
 void
 do_statement_expr(tnode_t *tn)
+{
 	block_level--;
 	mem_block_level--;
-	stmt_exprs->se_sym = mktempsym(dup_type(tn->tn_type));
+	stmt_exprs->se_sym = mktempsym(block_dup_type(tn->tn_type));
 	mem_block_level++;
 	block_level++;
 	/* ({ }) is a GCC extension */
 	gnuism(320);
+}
 tnode_t *
 end_statement_expr(void)
+{
 	stmt_expr *se = stmt_exprs;
 	tnode_t *tn = build_name(se->se_sym, false);
 	expr_save_memory();	/* leak */