 @@ -1,14 +1,14 @@
-/*	$NetBSD: d_c99_bool_strict.c,v 1.36 2022/01/15 14:22:03 rillig Exp $	*/
+/*	$NetBSD: d_c99_bool_strict.c,v 1.37 2022/02/27 08:31:26 rillig Exp $	*/
 # 3 "d_c99_bool_strict.c"
 /*
  * The option -T treats _Bool as incompatible with all other scalar types.
  * This is implemented by the following rules:
+ *
  * strict-bool-typedef:
  *	The type _Bool is compatible with any typedef of _Bool.
+ *
  *	Note: Since <stdbool.h> defines bool as textual alias of _Bool,
  *	having another typedef for bool is unusual.
+ *
  * strict-bool-constant:
 @@ -1032,27 +1032,27 @@ controlling_expression(FILE *f, const ch
 	 * rather tn_relaxed at that time) to true.
 	 */
 	/* expect+5: error: controlling expression must be bool, not 'int' [333] */
 	if (ferror(
 # 1037 "d_c99_bool_strict.c" 3 4
 	    (stdio_stdout)
 # 1039 "d_c99_bool_strict.c"
 	    ))
 		return;
 	/*
 	 * Before cgram.y 1.369 from 2021-11-16, the comment following
 	 * 'stdio_stdout' did not prevent the search for '('.  At the point
-	 * where build_name called expr_zalloc_tnode, the parser was already
+	 * where build_name called expr_alloc_tnode, the parser was already
 	 * in the main file again, thus treating 'stdio_stdout' as not coming
 	 * from a system header.
+	 *
 	 * This has been fixed in tree.c 1.395 from 2021-11-16.  Before that,
 	 * an expression had come from a system header if its operands came
 	 * from a system header, but that was only close to the truth.  In a
 	 * case where both operands come from a system header but the
 	 * operator comes from the main translation unit, the main
 	 * translation unit still has control over the whole expression.  So
 	 * the correct approach is to focus on the operator, not the
 	 * operands.  There are a few corner cases where the operator is
 	 * invisible (for implicit conversions) or synthetic (for translating
 	 * 'arr[index]' to '*(arr + index)', but these are handled as well.

 @@ -1,15 +1,15 @@
 %{
-/* $NetBSD: cgram.y,v 1.382 2022/02/27 01:47:28 rillig Exp $ */
+/* $NetBSD: cgram.y,v 1.383 2022/02/27 08:31:26 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
 @@ -25,50 +25,50 @@
  * 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 <sys/cdefs.h>
 #if defined(__RCSID) && !defined(lint)
-__RCSID("$NetBSD: cgram.y,v 1.382 2022/02/27 01:47:28 rillig Exp $");
+__RCSID("$NetBSD: cgram.y,v 1.383 2022/02/27 08:31:26 rillig Exp $");
 #endif
 #include <limits.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 extern char *yytext;
 /*
  * Contains the level of current declaration, used for symbol table entries.
  * 0 is the top-level, > 0 is inside a function body.
  */
 int	block_level;
 /*
  * level for memory allocation. Normally the same as block_level.
  * An exception is the declaration of arguments in prototypes. Memory
  * for these can't be freed after the declaration, but symbols must
  * be removed from the symbol table after the declaration.
  */
-int	mem_block_level;
+size_t	mem_block_level;
 /*
  * Save the no-warns state and restore it to avoid the problem where
  * if (expr) { stmt } / * NOLINT * / stmt;
  */
 static int olwarn = LWARN_BAD;
 static	void	cgram_declare(sym_t *, bool, sbuf_t *);
 static	void	read_until_rparen(void);
 static	sym_t	*symbolrename(sym_t *, sbuf_t *);
 #ifdef DEBUG
 @@ -467,32 +467,32 @@ generic_selection:
 /* K&R ---, C90 ---, C99 ---, C11 6.5.1.1 */
 generic_assoc_list:
 	  generic_association
 	| generic_assoc_list T_COMMA generic_association {
 		$3->ga_prev = $1;
 		$$ = $3;
+	  }
+	;
 /* K&R ---, C90 ---, C99 ---, C11 6.5.1.1 */
 generic_association:
 	  type_name T_COLON assignment_expression {
-		$$ = getblk(sizeof(*$$));
+		$$ = block_zero_alloc(sizeof(*$$));
 		$$->ga_arg = $1;
 		$$->ga_result = $3;
+	  }
 	| T_DEFAULT T_COLON assignment_expression {
-		$$ = getblk(sizeof(*$$));
+		$$ = block_zero_alloc(sizeof(*$$));
 		$$->ga_arg = NULL;
 		$$->ga_result = $3;
+	  }
+	;
 /* K&R 7.1, C90 ???, C99 6.5.2, C11 6.5.2 */
 postfix_expression:
 	  primary_expression
 	| postfix_expression T_LBRACK sys expression T_RBRACK {
 		$$ = build_unary(INDIR, $3, build_binary($1, PLUS, $3, $4));
+	  }
 	| postfix_expression T_LPAREN sys T_RPAREN {
 		$$ = build_function_call($1, $3, NULL);
 @@ -539,32 +539,32 @@ comma_opt:			/* helper for 'postfix_expr
 gcc_statement_expr_list:
 	  gcc_statement_expr_item
 	| gcc_statement_expr_list gcc_statement_expr_item {
 		$$ = $2;
+	  }
+	;
 gcc_statement_expr_item:
 	  declaration_or_error {
 		clear_warning_flags();
 		$$ = NULL;
+	  }
 	| non_expr_statement {
-		$$ = expr_zalloc_tnode();
+		$$ = expr_alloc_tnode();
 		$$->tn_type = gettyp(VOID);
+	  }
 	| expression T_SEMI {
 		if ($1 == NULL) {	/* in case of syntax errors */
-			$$ = expr_zalloc_tnode();
+			$$ = expr_alloc_tnode();
 			$$->tn_type = gettyp(VOID);
 		} else {
 			/* XXX: do that only on the last name */
 			if ($1->tn_op == NAME)
 				$1->tn_sym->s_used = true;
 			expr($1, false, false, false, false);
 			seen_fallthrough = false;
 			$$ = $1;
+		}
+	  }
+	;
 point_or_arrow:			/* helper for 'postfix_expression' */
 @@ -1682,27 +1682,27 @@ compound_statement:		/* C99 6.8.2 */
+	;
 compound_statement_lbrace:
 	  T_LBRACE {
 		block_level++;
 		mem_block_level++;
 		begin_declaration_level(AUTO);
+	  }
+	;
 compound_statement_rbrace:
 	  T_RBRACE {
 		end_declaration_level();
-		freeblk();
+		level_free_all(mem_block_level);
 		mem_block_level--;
 		block_level--;
 		seen_fallthrough = false;
+	  }
+	;
 block_item_list:		/* C99 6.8.2 */
 	  block_item
 	| block_item_list block_item {
 		if (!Sflag && $1 && !$2)
 			/* declarations after statements is a C99 feature */
 			c99ism(327);
 		$$ = $1 || $2;

 @@ -1,14 +1,14 @@
-/* $NetBSD: decl.c,v 1.245 2022/02/27 01:47:28 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.246 2022/02/27 08:31:26 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.245 2022/02/27 01:47:28 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.246 2022/02/27 08:31:26 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;
 @@ -166,57 +166,57 @@ scl_name(scl_t scl)
 type_t *
 gettyp(tspec_t t)
+{
 	/* TODO: make the return type 'const' */
 	return &typetab[t];
+}
 type_t *
 dup_type(const type_t *tp)
+{
 	type_t	*ntp;
-	ntp = getblk(sizeof(*ntp));
+	ntp = block_zero_alloc(sizeof(*ntp));
 	*ntp = *tp;
 	return ntp;
+}
 /*
  * 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_zalloc(sizeof(*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.
+ *
  * See C99 6.2.5p25.
  */
 type_t *
 expr_unqualified_type(const type_t *tp)
+{
 	type_t *ntp;
-	ntp = expr_zalloc(sizeof(*ntp));
+	ntp = expr_zero_alloc(sizeof(*ntp));
 	*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 eqtype, which simply tests whether tp1->t_str ==
 	 * tp2->t_str.
 	 */
 	return ntp;
 @@ -1242,27 +1242,27 @@ align(unsigned int al, unsigned int len)
 	no = (dcs->d_offset + (al - 1)) & ~(al - 1);
 	if (len == 0 || dcs->d_offset + len > no)
 		dcs->d_offset = no;
+}
 /*
  * Remember the width of the field in its type structure.
  */
 sym_t *
 bitfield(sym_t *dsym, int len)
+{
 	if (dsym == NULL) {
-		dsym = getblk(sizeof(*dsym));
+		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->t_bitfield = true;
 	dsym->s_type->t_flen = len;
 	dsym->s_bitfield = true;
 	return dsym;
+}
 @@ -1318,54 +1318,54 @@ merge_qualified_pointer(qual_ptr *p1, qu
 sym_t *
 add_pointer(sym_t *decl, qual_ptr *p)
+{
 	type_t **tpp, *tp;
 	qual_ptr *next;
 	tpp = &decl->s_type;
 	while (*tpp != NULL && *tpp != dcs->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL)
 		return decl;
 	while (p != NULL) {
-		*tpp = tp = getblk(sizeof(*tp));
+		*tpp = tp = block_zero_alloc(sizeof(*tp));
 		tp->t_tspec = PTR;
 		tp->t_const = p->p_const;
 		tp->t_volatile = p->p_volatile;
 		*(tpp = &tp->t_subt) = dcs->d_type;
 		next = p->p_next;
 		free(p);
 		p = next;
+	}
 	return decl;
+}
 /*
  * 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)
+{
 	type_t	**tpp, *tp;
 	tpp = &decl->s_type;
 	while (*tpp != NULL && *tpp != dcs->d_type)
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL)
 	    return decl;
-	*tpp = tp = getblk(sizeof(*tp));
+	*tpp = tp = block_zero_alloc(sizeof(*tp));
 	tp->t_tspec = ARRAY;
 	tp->t_subt = dcs->d_type;
 	tp->t_dim = n;
 	if (n < 0) {
 		/* negative array dimension (%d) */
 		error(20, n);
 		n = 0;
 	} else if (n == 0 && dim) {
 		/* zero sized array is a C99 extension */
 		c99ism(322);
 	} else if (n == 0 && !dim) {
 		setcomplete(tp, false);
 @@ -1408,27 +1408,27 @@ add_function(sym_t *decl, sym_t *args)
 	 * XXX: What is this code doing on a semantic level, and why?
 	 * Returning decl leads to the wrong function types in msg_347.
 	 */
 	tpp = &decl->s_type;
 	while (*tpp != NULL && *tpp != dcs->d_next->d_type)
 		/*
 		 * XXX: accessing INT->t_subt feels strange, even though it
 		 * may even be guaranteed to be NULL.
 		 */
 		tpp = &(*tpp)->t_subt;
 	if (*tpp == NULL)
 	    return decl;	/* see msg_347 */
-	*tpp = tp = getblk(sizeof(*tp));
+	*tpp = tp = block_zero_alloc(sizeof(*tp));
 	tp->t_tspec = FUNC;
 	tp->t_subt = dcs->d_next->d_type;
 	if ((tp->t_proto = dcs->d_proto) != false)
 		tp->t_args = args;
 	tp->t_vararg = dcs->d_vararg;
 	return decl;
+}
 /*
  * Called for new style function declarations.
  */
 /* ARGSUSED */
 @@ -1659,52 +1659,52 @@ mktag(sym_t *tag, tspec_t kind, bool dec
 		if (tag->s_scl != NOSCL) {
 			tag = newtag(tag, scl, decl, semi);
 		} else {
 			/* a new tag, no empty declaration */
 			dcs->d_next->d_nonempty_decl = true;
 			if (scl == ENUM_TAG && !decl) {
 				if (!tflag && (sflag || pflag))
 					/* forward reference to enum type */
 					warning(42);
+			}
+		}
 		if (tag->s_scl == NOSCL) {
 			tag->s_scl = scl;
-			tag->s_type = tp = getblk(sizeof(*tp));
+			tag->s_type = tp = block_zero_alloc(sizeof(*tp));
 			tp->t_packed = dcs->d_packed;
 		} else {
 			tp = tag->s_type;
+		}
 	} else {
-		tag = getblk(sizeof(*tag));
+		tag = block_zero_alloc(sizeof(*tag));
 		tag->s_name = unnamed;
 		UNIQUE_CURR_POS(tag->s_def_pos);
 		tag->s_kind = FTAG;
 		tag->s_scl = scl;
 		tag->s_block_level = -1;
-		tag->s_type = tp = getblk(sizeof(*tp));
+		tag->s_type = tp = block_zero_alloc(sizeof(*tp));
 		tp->t_packed = dcs->d_packed;
 		dcs->d_next->d_nonempty_decl = true;
+	}
 	if (tp->t_tspec == NOTSPEC) {
 		tp->t_tspec = kind;
 		if (kind != ENUM) {
-			tp->t_str = getblk(sizeof(*tp->t_str));
+			tp->t_str = block_zero_alloc(sizeof(*tp->t_str));
 			tp->t_str->sou_align_in_bits = CHAR_SIZE;
 			tp->t_str->sou_tag = tag;
 		} else {
 			tp->t_is_enum = true;
-			tp->t_enum = getblk(sizeof(*tp->t_enum));
+			tp->t_enum = block_zero_alloc(sizeof(*tp->t_enum));
 			tp->t_enum->en_tag = tag;
+		}
 		setcomplete(tp, false);
+	}
 	return tp;
+}
 /*
  * Checks all possible cases of tag redeclarations.
  * decl is true if T_LBRACE follows
  * semi is true if T_SEMI follows
  */
 static sym_t *
 @@ -1892,27 +1892,27 @@ enumeration_constant(sym_t *sym, int val
 /*
  * Process a single external declarator.
  */
 static void
 declare_extern(sym_t *dsym, bool initflg, sbuf_t *renaming)
+{
 	bool	dowarn, rval, redec;
 	sym_t	*rdsym;
 	char	*s;
 	if (renaming != NULL) {
 		lint_assert(dsym->s_rename == NULL);
-		s = getlblk(1, renaming->sb_len + 1);
+		s = level_zero_alloc(1, renaming->sb_len + 1);
 		(void)memcpy(s, renaming->sb_name, renaming->sb_len + 1);
 		dsym->s_rename = s;
+	}
 	check_function_definition(dsym, true);
 	check_type(dsym);
 	if (initflg && !check_init(dsym))
 		dsym->s_def = DEF;
 	/*
 	 * Declarations of functions are marked as "tentative" in
 @@ -2853,27 +2853,27 @@ check_init(sym_t *sym)
 	return erred;
+}
 /*
  * Create a symbol for an abstract declaration.
  */
 sym_t *
 abstract_name(void)
+{
 	sym_t	*sym;
 	lint_assert(dcs->d_ctx == ABSTRACT || dcs->d_ctx == PROTO_ARG);
-	sym = getblk(sizeof(*sym));
+	sym = block_zero_alloc(sizeof(*sym));
 	sym->s_name = unnamed;
 	sym->s_def = DEF;
 	sym->s_scl = ABSTRACT;
 	sym->s_block_level = -1;
 	if (dcs->d_ctx == PROTO_ARG)
 		sym->s_arg = true;
 	/*
 	 * At this point, dcs->d_type contains only the basic type.  That
 	 * type will be updated later, adding pointers, arrays and functions
 	 * as necessary.

 @@ -1,14 +1,14 @@
-/*	$NetBSD: externs1.h,v 1.146 2022/02/26 20:36:11 rillig Exp $	*/
+/*	$NetBSD: externs1.h,v 1.147 2022/02/27 08:31:26 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.
 @@ -51,27 +51,27 @@ extern	bool	vflag;
 extern	bool	yflag;
 extern	bool	wflag;
 extern	bool	zflag;
 extern	bool	Sflag;
 extern	bool	Tflag;
 extern	bool	Pflag;
 extern	void	norecover(void);
 /*
  * cgram.y
  */
 extern	int	block_level;
-extern	int	mem_block_level;
+extern	size_t	mem_block_level;
 extern	int	yydebug;
 extern	int	yyerror(const char *);
 extern	int	yyparse(void);
 /*
  * scan.l
  */
 extern  bool	in_gcc_attribute;
 extern	pos_t	curr_pos;
 extern	pos_t	csrc_pos;
 extern	bool	in_system_header;
 extern	symt_t	symtyp;
 @@ -90,33 +90,32 @@ extern	void	inssym(int, sym_t *);
 extern	void	freeyyv(void *, int);
 extern	int	yylex(void);
 /*
  * mem1.c
  */
 extern	const	char *record_filename(const char *, size_t);
 extern	int	get_filename_id(const char *);
 extern	void	add_directory_replacement(char *);
 extern	const char *transform_filename(const char *, size_t);
 extern	void	initmem(void);
-extern	void	*getblk(size_t);
+extern	void	*block_zero_alloc(size_t);
-extern	void	*getlblk(size_t, size_t);
+extern	void	*level_zero_alloc(size_t, size_t);
-extern	void	freeblk(void);
+extern	void	level_free_all(size_t);
 extern	void	freelblk(int);
-extern	void	*expr_zalloc(size_t);
+extern	void	*expr_zero_alloc(size_t);
-extern	tnode_t	*expr_zalloc_tnode(void);
+extern	tnode_t	*expr_alloc_tnode(void);
 extern	void	expr_free_all(void);
 extern	struct	memory_block *expr_save_memory(void);
 extern	void	expr_restore_memory(struct memory_block *);
 /*
  * debug.c
  */
 #ifdef DEBUG
 void	debug_node(const tnode_t *);
 void	debug_printf(const char *fmt, ...) __printflike(1, 2);
 void	debug_print_indent(void);
 void	debug_indent_inc(void);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: func.c,v 1.126 2021/11/16 21:01:05 rillig Exp $	*/
+/*	$NetBSD: func.c,v 1.127 2022/02/27 08:31:26 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.126 2021/11/16 21:01:05 rillig Exp $");
+__RCSID("$NetBSD: func.c,v 1.127 2022/02/27 08:31:26 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;
 @@ -1076,27 +1076,27 @@ do_return(bool sys, tnode_t *tn)
 	} 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 = expr_zero_alloc(sizeof(*ln));
 		ln->tn_op = NAME;
 		ln->tn_type = expr_unqualified_type(funcsym->s_type->t_subt);
 		ln->tn_lvalue = true;
 		ln->tn_sym = funcsym;		/* better than nothing */
 		tn = build_binary(ln, RETURN, sys, 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) {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: init.c,v 1.230 2021/12/22 14:35:23 rillig Exp $	*/
+/*	$NetBSD: init.c,v 1.231 2022/02/27 08:31:26 rillig Exp $	*/
 /*
  * Copyright (c) 1994, 1995 Jochen Pohl
  * Copyright (c) 2021 Roland Illig
  * 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: init.c,v 1.230 2021/12/22 14:35:23 rillig Exp $");
+__RCSID("$NetBSD: init.c,v 1.231 2022/02/27 08:31:26 rillig Exp $");
 #endif
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 /*
  * Initialization of global or local objects, like in:
+ *
  *	int number = 12345;
  *	int number_with_braces = { 12345 };
 @@ -304,27 +304,27 @@ check_trad_no_auto_aggregate(const sym_t
+}
 static void
 check_init_expr(const type_t *ltp, sym_t *lsym, tnode_t *rn)
+{
 	tnode_t *ln;
 	type_t *lutp;
 	tspec_t lt, rt;
 	struct memory_block *tmem;
 	lutp = expr_unqualified_type(ltp);
 	/* Create a temporary node for the left side. */
-	ln = expr_zalloc(sizeof(*ln));
+	ln = expr_zero_alloc(sizeof(*ln));
 	ln->tn_op = NAME;
 	ln->tn_type = lutp;
 	ln->tn_lvalue = true;
 	ln->tn_sym = lsym;
 	rn = cconv(rn);
 	lt = ln->tn_type->t_tspec;
 	rt = rn->tn_type->t_tspec;
 	debug_step("typeok '%s', '%s'",
 	    type_name(ln->tn_type), type_name(rn->tn_type));
 	if (!typeok(INIT, 0, ln, rn))

 @@ -1,14 +1,14 @@
-/* $NetBSD: lex.c,v 1.100 2022/02/27 07:50:09 rillig Exp $ */
+/* $NetBSD: lex.c,v 1.101 2022/02/27 08:31:26 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: lex.c,v 1.100 2022/02/27 07:50:09 rillig Exp $");
+__RCSID("$NetBSD: lex.c,v 1.101 2022/02/27 08:31:26 rillig Exp $");
 #endif
 #include <ctype.h>
 #include <errno.h>
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 #include "cgram.h"
 @@ -287,27 +287,27 @@ add_keyword(const struct keyword *kw, bo
+{
 	sym_t *sym;
 	char buf[256];
 	const char *name;
 	if (!leading && !trailing) {
 		name = kw->kw_name;
 	} else {
 		(void)snprintf(buf, sizeof(buf), "%s%s%s",
 		    leading ? "__" : "", kw->kw_name, trailing ? "__" : "");
 		name = xstrdup(buf);
+	}
-	sym = getblk(sizeof(*sym));
+	sym = block_zero_alloc(sizeof(*sym));
 	sym->s_name = name;
 	sym->s_keyword = kw;
 	sym->s_value.v_quad = kw->kw_token;
 	if (kw->kw_token == T_TYPE || kw->kw_token == T_STRUCT_OR_UNION) {
 		sym->s_tspec = kw->kw_tspec;
 	} else if (kw->kw_token == T_SCLASS) {
 		sym->s_scl = kw->kw_scl;
 	} else if (kw->kw_token == T_QUAL) {
 		sym->s_tqual = kw->kw_tqual;
+	}
 	symtab_add(sym);
+}
 @@ -397,27 +397,27 @@ lex_name(const char *yytext, size_t yyle
 	if ((sym = search(sb)) != NULL && sym->s_keyword != NULL) {
 		free(sb);
 		return keyw(sym);
+	}
 	sb->sb_sym = sym;
 	if (sym != NULL) {
 		lint_assert(block_level >= sym->s_block_level);
 		sb->sb_name = sym->s_name;
 		sb->sb_len = strlen(sym->s_name);
 		tok = sym->s_scl == TYPEDEF ? T_TYPENAME : T_NAME;
 	} else {
-		s = getblk(yyleng + 1);
+		s = block_zero_alloc(yyleng + 1);
 		(void)memcpy(s, yytext, yyleng + 1);
 		sb->sb_name = s;
 		sb->sb_len = yyleng;
 		tok = T_NAME;
+	}
 	yylval.y_name = sb;
 	return tok;
+}
 static sym_t *
 search(sbuf_t *sb)
+{
 @@ -1342,37 +1342,37 @@ getsym(sbuf_t *sb)
+	}
 	if (sym != NULL) {
 		lint_assert(sym->s_kind == symtyp);
 		symtyp = FVFT;
 		free(sb);
 		return sym;
+	}
 	/* create a new symbol table entry */
 	/* labels must always be allocated at level 1 (outermost block) */
 	if (symtyp == FLABEL) {
-		sym = getlblk(1, sizeof(*sym));
+		sym = level_zero_alloc(1, sizeof(*sym));
-		s = getlblk(1, sb->sb_len + 1);
+		s = level_zero_alloc(1, sb->sb_len + 1);
 		(void)memcpy(s, sb->sb_name, sb->sb_len + 1);
 		sym->s_name = s;
 		sym->s_block_level = 1;
 		di = dcs;
 		while (di->d_next != NULL && di->d_next->d_next != NULL)
 			di = di->d_next;
 		lint_assert(di->d_ctx == AUTO);
 	} else {
-		sym = getblk(sizeof(*sym));
+		sym = block_zero_alloc(sizeof(*sym));
 		sym->s_name = sb->sb_name;
 		sym->s_block_level = block_level;
 		di = dcs;
+	}
 	UNIQUE_CURR_POS(sym->s_def_pos);
 	if ((sym->s_kind = symtyp) != FLABEL)
 		sym->s_type = gettyp(INT);
 	symtyp = FVFT;
 	symtab_add(sym);
 @@ -1381,28 +1381,28 @@ getsym(sbuf_t *sb)
 	free(sb);
 	return sym;
+}
 /*
  * Construct a temporary symbol. The symbol name starts with a digit, making
  * the name illegal.
  */
 sym_t *
 mktempsym(type_t *t)
+{
 	static int n = 0;
-	char *s = getlblk(block_level, 64);
+	char *s = level_zero_alloc(block_level, 64);
-	sym_t *sym = getblk(sizeof(*sym));
+	sym_t *sym = block_zero_alloc(sizeof(*sym));
 	scl_t scl;
 	(void)snprintf(s, 64, "%.8d_tmp", n++);
 	scl = dcs->d_scl;
 	if (scl == NOSCL)
 		scl = block_level > 0 ? AUTO : EXTERN;
 	sym->s_name = s;
 	sym->s_type = t;
 	sym->s_block_level = block_level;
 	sym->s_scl = scl;
 	sym->s_kind = FVFT;
 @@ -1466,51 +1466,51 @@ inssym(int bl, sym_t *sym)
+}
 /*
  * Called at level 0 after syntax errors.
+ *
  * Removes all symbols which are not declared at level 0 from the
  * symbol table. Also frees all memory which is not associated with
  * level 0.
  */
 void
 cleanup(void)
+{
 	sym_t	*sym, *nsym;
-	int	i;
+	size_t	i;
 	for (i = 0; i < HSHSIZ1; i++) {
 		for (sym = symtab[i]; sym != NULL; sym = nsym) {
 			nsym = sym->s_link;
 			if (sym->s_block_level >= 1)
 				symtab_remove(sym);
+		}
+	}
 	for (i = mem_block_level; i > 0; i--)
-		freelblk(i);
+		level_free_all(i);
+}
 /*
  * Create a new symbol with the name of an existing symbol.
  */
 sym_t *
 pushdown(const sym_t *sym)
+{
 	sym_t	*nsym;
 	debug_step("pushdown '%s' %s '%s'",
 	    sym->s_name, symt_name(sym->s_kind), type_name(sym->s_type));
-	nsym = getblk(sizeof(*nsym));
+	nsym = block_zero_alloc(sizeof(*nsym));
 	lint_assert(sym->s_block_level <= block_level);
 	nsym->s_name = sym->s_name;
 	UNIQUE_CURR_POS(nsym->s_def_pos);
 	nsym->s_kind = sym->s_kind;
 	nsym->s_block_level = block_level;
 	symtab_add(nsym);
 	*dcs->d_ldlsym = nsym;
 	dcs->d_ldlsym = &nsym->s_dlnxt;
 	return nsym;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: mem1.c,v 1.59 2022/02/27 07:38:54 rillig Exp $	*/
+/*	$NetBSD: mem1.c,v 1.60 2022/02/27 08:31:26 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: mem1.c,v 1.59 2022/02/27 07:38:54 rillig Exp $");
+__RCSID("$NetBSD: mem1.c,v 1.60 2022/02/27 08:31:26 rillig Exp $");
 #endif
 #include <sys/param.h>
 #include <stdlib.h>
 #include <string.h>
 #include "lint1.h"
 /*
  * Filenames allocated by record_filename are shared and have unlimited
  * lifetime.
  */
 struct filename {
 @@ -233,97 +233,84 @@ xfreeblk(memory_block **fmbp)
+}
 void
 initmem(void)
+{
 	mblk_size = mem_block_size();
 	mblks = xcalloc(nmblks = ML_INC, sizeof(*mblks));
+}
 /* Allocate memory associated with level l, initialized with zero. */
 void *
-getlblk(size_t l, size_t s)
+level_zero_alloc(size_t l, size_t s)
+{
 	while (l >= nmblks) {
 		mblks = xrealloc(mblks, (nmblks + ML_INC) * sizeof(*mblks));
 		(void)memset(&mblks[nmblks], 0, ML_INC * sizeof(*mblks));
 		nmblks += ML_INC;
+	}
 	return xgetblk(&mblks[l], s);
+}
-/*
+/* Allocate memory that is freed at the end of the current block. */
  * Return allocated memory for the current mem_block_level, initialized with
  * zero.
  */
 void *
-getblk(size_t s)
+block_zero_alloc(size_t s)
+{
-	return getlblk(mem_block_level, s);
+	return level_zero_alloc(mem_block_level, s);
+}
 /* Free all memory associated with level l. */
 void
-freelblk(int l)
+level_free_all(size_t level)
+{
-	xfreeblk(&mblks[l]);
+	xfreeblk(&mblks[level]);
+}
 void
 freeblk(void)
 	freelblk(mem_block_level);
 static	memory_block	*tmblk;
-/*
+/* Allocate memory that is freed at the end of the current expression. */
  * Return zero-initialized memory that is freed at the end of the current
  * expression.
  */
 void *
-expr_zalloc(size_t s)
+expr_zero_alloc(size_t s)
+{
 	return xgetblk(&tmblk, s);
+}
 static bool
 str_endswith(const char *haystack, const char *needle)
+{
 	size_t hlen = strlen(haystack);
 	size_t nlen = strlen(needle);
 	return nlen <= hlen &&
 	       memcmp(haystack + hlen - nlen, needle, nlen) == 0;
+}
 /*
  * Return a freshly allocated tree node that is freed at the end of the
  * current expression.
+ *
  * The node records whether it comes from a system file, which makes strict
  * bool mode less restrictive.
  */
 tnode_t *
-expr_zalloc_tnode(void)
+expr_alloc_tnode(void)
+{
-	tnode_t *tn = expr_zalloc(sizeof(*tn));
+	tnode_t *tn = expr_zero_alloc(sizeof(*tn));
 	/*
 	 * files named *.c that are different from the main translation unit
 	 * typically contain generated code that cannot be influenced, such
 	 * as a flex lexer or a yacc parser.
 	 */
 	tn->tn_sys = in_system_header ||
 		     (curr_pos.p_file != csrc_pos.p_file &&
 		      str_endswith(curr_pos.p_file, ".c"));
 	return tn;
+}
 /* Free all memory which is allocated by the current expression. */
 void

 @@ -1,14 +1,14 @@
-/*	$NetBSD: tree.c,v 1.404 2022/02/26 20:36:11 rillig Exp $	*/
+/*	$NetBSD: tree.c,v 1.405 2022/02/27 08:31:26 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.404 2022/02/26 20:36:11 rillig Exp $");
+__RCSID("$NetBSD: tree.c,v 1.405 2022/02/27 08:31:26 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);
 @@ -98,75 +98,75 @@ 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)
+{
 	type_t	*tp2;
-	tp2 = getblk(sizeof(*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.
  */
 type_t *
 expr_derive_type(type_t *tp, tspec_t t)
+{
 	type_t	*tp2;
-	tp2 = expr_zalloc(sizeof(*tp2));
+	tp2 = expr_zero_alloc(sizeof(*tp2));
 	tp2->t_tspec = t;
 	tp2->t_subt = tp;
 	return tp2;
+}
 /*
  * Create a node for a constant.
  */
 tnode_t *
 build_constant(type_t *tp, val_t *v)
+{
 	tnode_t	*n;
-	n = expr_zalloc_tnode();
+	n = expr_alloc_tnode();
 	n->tn_op = CON;
 	n->tn_type = tp;
-	n->tn_val = expr_zalloc(sizeof(*n->tn_val));
+	n->tn_val = expr_zero_alloc(sizeof(*n->tn_val));
 	n->tn_val->v_tspec = tp->t_tspec;
 	n->tn_val->v_unsigned_since_c90 = v->v_unsigned_since_c90;
 	n->tn_val->v_u = v->v_u;
 	free(v);
 	return n;
+}
 static tnode_t *
 build_integer_constant(tspec_t t, int64_t q)
+{
 	tnode_t	*n;
-	n = expr_zalloc_tnode();
+	n = expr_alloc_tnode();
 	n->tn_op = CON;
 	n->tn_type = gettyp(t);
-	n->tn_val = expr_zalloc(sizeof(*n->tn_val));
+	n->tn_val = expr_zero_alloc(sizeof(*n->tn_val));
 	n->tn_val->v_tspec = t;
 	n->tn_val->v_quad = q;
 	return n;
+}
 static void
 fallback_symbol(sym_t *sym)
+{
 	if (fallback_symbol_strict_bool(sym))
 		return;
 	if (block_level > 0 && (strcmp(sym->s_name, "__FUNCTION__") == 0 ||
 @@ -267,73 +267,73 @@ 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);
 		else
 			fallback_symbol(sym);
+	}
 	lint_assert(sym->s_kind == FVFT || sym->s_kind == FMEMBER);
-	n = expr_zalloc_tnode();
+	n = expr_alloc_tnode();
 	n->tn_type = sym->s_type;
 	if (sym->s_scl == CTCONST) {
 		n->tn_op = CON;
-		n->tn_val = expr_zalloc(sizeof(*n->tn_val));
+		n->tn_val = expr_zero_alloc(sizeof(*n->tn_val));
 		*n->tn_val = sym->s_value;
 	} else {
 		n->tn_op = NAME;
 		n->tn_sym = sym;
 		if (sym->s_kind == FVFT && sym->s_type->t_tspec != FUNC)
 			n->tn_lvalue = true;
+	}
 	return n;
+}
 tnode_t *
 build_string(strg_t *strg)
+{
 	size_t	len;
 	tnode_t	*n;
 	type_t *tp;
 	len = strg->st_len;
-	n = expr_zalloc_tnode();
+	n = expr_alloc_tnode();
-	tp = expr_zalloc(sizeof(*tp));
+	tp = expr_zero_alloc(sizeof(*tp));
 	tp->t_tspec = ARRAY;
 	tp->t_subt = gettyp(strg->st_tspec);
 	tp->t_dim = (int)(len + 1);
 	n->tn_op = STRING;
 	n->tn_type = tp;
 	n->tn_lvalue = true;
-	n->tn_string = expr_zalloc(sizeof(*n->tn_string));
+	n->tn_string = expr_zero_alloc(sizeof(*n->tn_string));
 	n->tn_string->st_tspec = strg->st_tspec;
 	n->tn_string->st_len = len;
 	if (strg->st_tspec == CHAR) {
-		n->tn_string->st_cp = expr_zalloc(len + 1);
+		n->tn_string->st_cp = expr_zero_alloc(len + 1);
 		(void)memcpy(n->tn_string->st_cp, strg->st_cp, len + 1);
 		free(strg->st_cp);
 	} else {
 		size_t size = (len + 1) * sizeof(*n->tn_string->st_wcp);
-		n->tn_string->st_wcp = expr_zalloc(size);
+		n->tn_string->st_wcp = expr_zero_alloc(size);
 		(void)memcpy(n->tn_string->st_wcp, strg->st_wcp, size);
 		free(strg->st_wcp);
+	}
 	free(strg);
 	return n;
+}
 /*
  * Returns a symbol which has the same name as the msym argument and is a
  * member of the struct or union specified by the tn argument.
  */
 static sym_t *
 @@ -345,28 +345,28 @@ struct_or_union_member(tnode_t *tn, op_t
 	bool	eq;
 	tspec_t	t;
 	/*
 	 * Remove the member if it was unknown until now, which means
 	 * that no defined struct or union has a member with the same name.
 	 */
 	if (msym->s_scl == NOSCL) {
 		/* type '%s' does not have member '%s' */
 		error(101, type_name(tn->tn_type), msym->s_name);
 		rmsym(msym);
 		msym->s_kind = FMEMBER;
 		msym->s_scl = MOS;
-		msym->s_styp = expr_zalloc(sizeof(*msym->s_styp));
+		msym->s_styp = expr_zero_alloc(sizeof(*msym->s_styp));
-		msym->s_styp->sou_tag = expr_zalloc(
+		msym->s_styp->sou_tag = expr_zero_alloc(
 		    sizeof(*msym->s_styp->sou_tag));
 		msym->s_styp->sou_tag->s_name = unnamed;
 		msym->s_value.v_tspec = INT;
 		return msym;
+	}
 	/* Set str to the tag of which msym is expected to be a member. */
 	str = NULL;
 	t = (tp = tn->tn_type)->t_tspec;
 	if (op == POINT) {
 		if (t == STRUCT || t == UNION)
 			str = tp->t_str;
 	} else if (op == ARROW && t == PTR) {
 @@ -1824,27 +1824,27 @@ check_enum_array_index(const tnode_t *ln
 /*
  * Build and initialize a new node.
  */
 static tnode_t *
 new_tnode(op_t op, bool sys, type_t *type, tnode_t *ln, tnode_t *rn)
+{
 	tnode_t	*ntn;
 	tspec_t	t;
 #if 0 /* not yet */
 	size_t l;
 	uint64_t rnum;
 #endif
-	ntn = expr_zalloc_tnode();
+	ntn = expr_alloc_tnode();
 	ntn->tn_op = op;
 	ntn->tn_type = type;
 	ntn->tn_sys = sys;
 	ntn->tn_left = ln;
 	ntn->tn_right = rn;
 	switch (op) {
 #if 0 /* not yet */
 	case SHR:
 		if (rn->tn_op != CON)
 			break;
 		rnum = rn->tn_val->v_quad;
 @@ -2070,37 +2070,37 @@ convert(op_t op, int arg, type_t *tp, tn
 	if (!tflag && !sflag && op == FARG)
 		check_prototype_conversion(arg, nt, ot, tp, tn);
 	if (is_integer(nt) && is_integer(ot)) {
 		check_integer_conversion(op, arg, nt, ot, tp, tn);
 	} else if (nt == PTR && is_null_pointer(tn)) {
 		/* a null pointer may be assigned to any pointer. */
 	} else if (is_integer(nt) && nt != BOOL && ot == PTR) {
 		check_pointer_integer_conversion(op, nt, tp, tn);
 	} else if (nt == PTR && ot == PTR && op == CVT) {
 		check_pointer_conversion(tn, tp);
+	}
-	ntn = expr_zalloc_tnode();
+	ntn = expr_alloc_tnode();
 	ntn->tn_op = CVT;
 	ntn->tn_type = tp;
 	ntn->tn_cast = op == CVT;
 	ntn->tn_sys |= tn->tn_sys;
 	ntn->tn_right = NULL;
 	if (tn->tn_op != CON || nt == VOID) {
 		ntn->tn_left = tn;
 	} else {
 		ntn->tn_op = CON;
-		ntn->tn_val = expr_zalloc(sizeof(*ntn->tn_val));
+		ntn->tn_val = expr_zero_alloc(sizeof(*ntn->tn_val));
 		convert_constant(op, arg, ntn->tn_type, ntn->tn_val,
 		    tn->tn_val);
+	}
 	return ntn;
+}
 static bool
 should_warn_about_prototype_conversion(tspec_t nt,
 				       tspec_t ot, const tnode_t *ptn)
+{
 	if (nt == ot)
 @@ -3599,27 +3599,27 @@ cast(tnode_t *tn, type_t *tp)
 		 * But this seems really questionable.
 		 */
 	} else if (nt == UNION) {
 		sym_t *m;
 		struct_or_union *str = tp->t_str;
 		if (!gflag) {
 			/* union cast is a GCC extension */
 			error(328);
 			return NULL;
+		}
 		for (m = str->sou_first_member; m != NULL; m = m->s_next) {
 			if (eqtype(m->s_type, tn->tn_type,
 			    false, false, NULL)) {
-				tn = expr_zalloc_tnode();
+				tn = expr_alloc_tnode();
 				tn->tn_op = CVT;
 				tn->tn_type = tp;
 				tn->tn_cast = true;
 				tn->tn_right = NULL;
 				return tn;
+			}
+		}
 		/* type '%s' is not a member of '%s' */
 		error(329, type_name(tn->tn_type), type_name(tp));
 		return NULL;
 	} else if (nt == STRUCT || nt == ARRAY || nt == FUNC) {
 		/* Casting to a struct is an undocumented GCC extension. */
 		if (!(gflag && nt == STRUCT))