 @@ -1,15 +1,15 @@
 %{
-/* $NetBSD: cgram.y,v 1.208 2021/04/02 09:52:36 rillig Exp $ */
+/* $NetBSD: cgram.y,v 1.209 2021/04/02 10:13:03 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,27 +25,27 @@
  * 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.208 2021/04/02 09:52:36 rillig Exp $");
+__RCSID("$NetBSD: cgram.y,v 1.209 2021/04/02 10:13:03 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.
 @@ -1868,27 +1868,27 @@ expr:
+	;
 term:
 	  T_NAME {
 		/* XXX really necessary? */
 		if (yychar < 0)
 			yychar = yylex();
 		$$ = new_name_node(getsym($1), yychar);
+	  }
 	| string {
 		$$ = new_string_node($1);
+	  }
 	| T_CON {
-		$$ = new_constant_node(gettyp($1->v_tspec), $1);
+		$$ = expr_new_constant(gettyp($1->v_tspec), $1);
+	  }
 	| T_LPAREN expr T_RPAREN {
 		if ($2 != NULL)
 			$2->tn_parenthesized = true;
 		$$ = $2;
+	  }
 	| T_LPAREN compound_statement_lbrace declaration_list
 	    expr_statement_list {
 		block_level--;
 		mem_block_level--;
 		begin_initialization(mktempsym(duptyp($4->tn_type)));
 		mem_block_level++;
 		block_level++;

 @@ -1,14 +1,14 @@
-/* $NetBSD: decl.c,v 1.167 2021/03/30 14:25:28 rillig Exp $ */
+/* $NetBSD: decl.c,v 1.168 2021/04/02 10:13:03 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.167 2021/03/30 14:25:28 rillig Exp $");
+__RCSID("$NetBSD: decl.c,v 1.168 2021/04/02 10:13:03 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;
 @@ -152,27 +152,27 @@ duptyp(const type_t *tp)
 	*ntp = *tp;
 	return ntp;
+}
 /*
  * Use tduptyp() instead of duptyp() inside expressions (if the
  * allocated memory should be freed after the expr).
  */
 type_t *
 tduptyp(const type_t *tp)
+{
 	type_t	*ntp;
-	ntp = tgetblk(sizeof *ntp);
+	ntp = expr_zalloc(sizeof *ntp);
 	*ntp = *tp;
 	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;
 @@ -1005,29 +1005,29 @@ 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 = incref(*tpp, PTR);
+					*tpp = derive_type(*tpp, PTR);
 				} else {
-					*tpp = incref((*tpp)->t_subt, PTR);
+					*tpp = 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);
 @@ -1173,27 +1173,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 = incref(tp, t = PTR);
+		dsym->s_type = tp = 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);
+		}
+	}
 @@ -2406,32 +2406,32 @@ declare_argument(sym_t *sym, bool initfl
 	if (!sym->s_arg) {
 		/* declared argument %s is missing */
 		error(53, sym->s_name);
 		sym->s_arg = true;
+	}
 	if (initflg) {
 		/* cannot initialize parameter: %s */
 		error(52, sym->s_name);
+	}
 	if ((t = sym->s_type->t_tspec) == ARRAY) {
-		sym->s_type = incref(sym->s_type->t_subt, PTR);
+		sym->s_type = 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 = incref(sym->s_type, PTR);
+		sym->s_type = 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. lengths() prints the needed
 	 * error messages (null dimension is impossible because arrays are
 	 * converted to pointers).
 @@ -3324,27 +3324,27 @@ to_int_constant(tnode_t *tn, bool requir
 	if (tn == NULL) {
 		i = 1;
 		goto done;
+	}
 	/*
 	 * Abstract declarations are used inside expression. To free
 	 * the memory would be a fatal error.
 	 * We don't free blocks that are inside casts because these
 	 * will be used later to match types.
 	 */
 	if (tn->tn_op != CON && dcs->d_ctx != ABSTRACT)
-		tfreeblk();
+		expr_free_all();
 	if ((t = v->v_tspec) == FLOAT || t == DOUBLE || t == LDOUBLE) {
 		i = (int)v->v_ldbl;
 		/* integral constant expression expected */
 		error(55);
 	} else {
 		i = (int)v->v_quad;
 		if (is_uinteger(t)) {
 			if ((uint64_t)v->v_quad > (uint64_t)TARG_INT_MAX) {
 				/* integral constant too large */
 				warning(56);
+			}
 		} else {

 @@ -1,14 +1,14 @@
-/*	$NetBSD: externs1.h,v 1.97 2021/04/02 09:52:36 rillig Exp $	*/
+/*	$NetBSD: externs1.h,v 1.98 2021/04/02 10:13:03 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.
 @@ -95,31 +95,31 @@ extern	int	yylex(void);
  */
 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	*getlblk(size_t, size_t);
 extern	void	freeblk(void);
 extern	void	freelblk(int);
-extern	void	*tgetblk(size_t);
+extern	void	*expr_zalloc(size_t);
 extern	tnode_t	*expr_zalloc_tnode(void);
-extern	void	tfreeblk(void);
+extern	void	expr_free_all(void);
-extern	struct	memory_block *tsave(void);
+extern	struct	memory_block *expr_save_memory(void);
-extern	void	trestor(struct memory_block *);
+extern	void	expr_restore_memory(struct memory_block *);
 /*
  * err.c
  */
 extern	int	nerr;
 extern	int	sytxerr;
 extern	const	char *msgs[];
 extern	void	msglist(void);
 extern	void	error(int, ...);
 extern	void	warning(int, ...);
 extern	void	message(int, ...);
 extern	void	gnuism(int, ...);
 @@ -186,29 +186,29 @@ extern	void	global_clean_up(void);
 extern	sym_t	*declare_1_abstract(sym_t *);
 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);
 /*
  * tree.c
  */
-extern	type_t	*incref(type_t *, tspec_t);
+extern	type_t	*derive_type(type_t *, tspec_t);
-extern	type_t	*tincref(type_t *, tspec_t);
+extern	type_t	*expr_derive_type(type_t *, tspec_t);
-extern	tnode_t	*new_constant_node(type_t *, val_t *);
+extern	tnode_t	*expr_new_constant(type_t *, val_t *);
 extern	tnode_t	*new_name_node(sym_t *, int);
 extern	tnode_t	*new_string_node(strg_t *);
 extern	sym_t	*struct_or_union_member(tnode_t *, op_t, sym_t *);
 extern	tnode_t	*build(op_t, tnode_t *, tnode_t *);
 extern	tnode_t	*cconv(tnode_t *);
 extern	bool	is_typeok_bool_operand(const tnode_t *);
 extern	bool	typeok(op_t, int, const tnode_t *, const tnode_t *);
 extern	tnode_t	*promote(op_t, bool, tnode_t *);
 extern	tnode_t	*convert(op_t, int, type_t *, tnode_t *);
 extern	void	convert_constant(op_t, int, const type_t *, val_t *, val_t *);
 extern	tnode_t	*build_sizeof(const type_t *);
 extern	tnode_t	*build_offsetof(const type_t *, const sym_t *);
 extern	tnode_t	*build_alignof(const type_t *);

 @@ -1,14 +1,14 @@
-/*	$NetBSD: func.c,v 1.98 2021/03/26 20:31:07 rillig Exp $	*/
+/*	$NetBSD: func.c,v 1.99 2021/04/02 10:13:03 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.98 2021/03/26 20:31:07 rillig Exp $");
+__RCSID("$NetBSD: func.c,v 1.99 2021/04/02 10:13:03 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;
 @@ -531,27 +531,27 @@ check_case_label(tnode_t *tn, cstk_t *ci
+}
 void
 case_label(tnode_t *tn)
+{
 	cstk_t	*ci;
 	/* find the innermost switch statement */
 	for (ci = cstmt; ci != NULL && !ci->c_switch; ci = ci->c_surrounding)
 		continue;
 	check_case_label(tn, ci);
-	tfreeblk();
+	expr_free_all();
 	set_reached(true);
+}
 void
 default_label(void)
+{
 	cstk_t	*ci;
 	/* find the innermost switch statement */
 	for (ci = cstmt; ci != NULL && !ci->c_switch; ci = ci->c_surrounding)
 		continue;
 @@ -873,27 +873,27 @@ for1(tnode_t *tn1, tnode_t *tn2, tnode_t
 		/* loop not entered at top */
 		warning(207);
 		set_reached(true);
+	}
 	begin_control_statement(CS_FOR);
 	cstmt->c_loop = true;
 	/*
 	 * Store the tree memory for the reinitialization expression.
 	 * Also remember this expression itself. We must check it at
 	 * the end of the loop to get "used but not set" warnings correct.
 	 */
-	cstmt->c_for_expr3_mem = tsave();
+	cstmt->c_for_expr3_mem = expr_save_memory();
 	cstmt->c_for_expr3 = tn3;
 	cstmt->c_for_expr3_pos = curr_pos;
 	cstmt->c_for_expr3_csrc_pos = csrc_pos;
 	if (tn1 != NULL)
 		expr(tn1, false, false, true, false);
 	if (tn2 != NULL)
 		tn2 = check_controlling_expression(tn2);
 	if (tn2 != NULL)
 		expr(tn2, false, true, true, false);
 	cstmt->c_maybe_endless = tn2 == NULL || is_nonzero(tn2);
 @@ -910,42 +910,42 @@ for1(tnode_t *tn1, tnode_t *tn2, tnode_t
 void
 for2(void)
+{
 	pos_t	cpos, cspos;
 	tnode_t	*tn3;
 	if (cstmt->c_continue)
 		set_reached(true);
 	cpos = curr_pos;
 	cspos = csrc_pos;
 	/* Restore the tree memory for the reinitialization expression */
-	trestor(cstmt->c_for_expr3_mem);
+	expr_restore_memory(cstmt->c_for_expr3_mem);
 	tn3 = cstmt->c_for_expr3;
 	curr_pos = cstmt->c_for_expr3_pos;
 	csrc_pos = cstmt->c_for_expr3_csrc_pos;
 	/* simply "statement not reached" would be confusing */
 	if (!reached && warn_about_unreachable) {
 		/* end-of-loop code not reached */
 		warning(223);
 		set_reached(true);
+	}
 	if (tn3 != NULL) {
 		expr(tn3, false, false, true, false);
 	} else {
-		tfreeblk();
+		expr_free_all();
+	}
 	curr_pos = cpos;
 	csrc_pos = cspos;
 	/* An endless loop without break will never terminate */
 	/* TODO: What if the loop contains a 'return'? */
 	set_reached(cstmt->c_break || !cstmt->c_maybe_endless);
 	end_control_statement(CS_FOR);
+}
 /*
 @@ -1024,42 +1024,42 @@ do_return(tnode_t *tn)
 	op_t	op;
 	for (ci = cstmt; ci->c_surrounding != NULL; ci = ci->c_surrounding)
 		continue;
 	if (tn != NULL)
 		ci->c_had_return_value = true;
 	else
 		ci->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);
-		tfreeblk();
+		expr_free_all();
 		tn = NULL;
 	} else if (tn == NULL && funcsym->s_type->t_subt->t_tspec != VOID) {
 		/*
 		 * Assume that the function has a return value only if it
 		 * is explicitly declared.
 		 */
 		if (!funcsym->s_return_type_implicit_int)
 			/* function %s expects to return value */
 			warning(214, funcsym->s_name);
+	}
 	if (tn != NULL) {
 		/* Create a temporary node for the left side */
-		ln = tgetblk(sizeof *ln);
+		ln = expr_zalloc(sizeof *ln);
 		ln->tn_op = NAME;
 		ln->tn_type = tduptyp(funcsym->s_type->t_subt);
 		ln->tn_type->t_const = false;
 		ln->tn_lvalue = true;
 		ln->tn_sym = funcsym;		/* better than nothing */
 		tn = build(RETURN, ln, 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 &&

 @@ -1,14 +1,14 @@
-/*	$NetBSD: init.c,v 1.187 2021/04/02 09:39:25 rillig Exp $	*/
+/*	$NetBSD: init.c,v 1.188 2021/04/02 10:13:03 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.187 2021/04/02 09:39:25 rillig Exp $");
+__RCSID("$NetBSD: init.c,v 1.188 2021/04/02 10:13:03 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 };
 @@ -373,50 +373,50 @@ check_no_auto_aggregate(const sym_t *sym
 		/* no automatic aggregate initialization in trad. C */
 		warning(188);
+	}
+}
 static void
 check_init_expr(const type_t *tp, sym_t *sym, tnode_t *tn)
+{
 	tnode_t *ln;
 	tspec_t lt, rt;
 	struct memory_block *tmem;
 	/* Create a temporary node for the left side. */
-	ln = tgetblk(sizeof *ln);
+	ln = expr_zalloc(sizeof *ln);
 	ln->tn_op = NAME;
 	ln->tn_type = tduptyp(tp);
 	ln->tn_type->t_const = false;
 	ln->tn_lvalue = true;
 	ln->tn_sym = sym;
 	tn = cconv(tn);
 	lt = ln->tn_type->t_tspec;
 	rt = tn->tn_type->t_tspec;
 	debug_step2("typeok '%s', '%s'",
 	    type_name(ln->tn_type), type_name(tn->tn_type));
 	if (!typeok(INIT, 0, ln, tn))
 		return;
 	/*
 	 * Preserve the tree memory. This is necessary because otherwise
 	 * expr() would free it.
 	 */
-	tmem = tsave();
+	tmem = expr_save_memory();
 	expr(tn, true, false, true, false);
-	trestor(tmem);
+	expr_restore_memory(tmem);
 	check_bit_field_init(ln, lt, rt);
 	/*
 	 * XXX: Is it correct to do this conversion _after_ the typeok above?
 	 */
 	if (lt != rt || (tp->t_bitfield && tn->tn_op == CON))
 		tn = convert(INIT, 0, unconst_cast(tp), tn);
 	check_non_constant_initializer(tn, sym);
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: mem1.c,v 1.40 2021/04/02 09:52:36 rillig Exp $	*/
+/*	$NetBSD: mem1.c,v 1.41 2021/04/02 10:13:03 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.40 2021/04/02 09:52:36 rillig Exp $");
+__RCSID("$NetBSD: mem1.c,v 1.41 2021/04/02 10:13:03 rillig Exp $");
 #endif
 #include <sys/types.h>
 #include <sys/param.h>
 #include <stdlib.h>
 #include <string.h>
 #include <unistd.h>
 #include "lint1.h"
 /*
  * Filenames allocated by record_filename are shared.
  */
 @@ -326,67 +326,70 @@ void
 freeblk(void)
+{
 	freelblk(mem_block_level);
+}
 static	memory_block	*tmblk;
 /*
  * Return zero-initialized memory that is freed at the end of the current
  * expression.
  */
 void *
-tgetblk(size_t s)
+expr_zalloc(size_t s)
+{
 	return xgetblk(&tmblk, s);
+}
-/* Return a freshly allocated tree node. */
+/*
  * Return a freshly allocated tree node that is freed at the end of the
  * current expression.
  */
 tnode_t *
 expr_zalloc_tnode(void)
+{
-	tnode_t *tn = tgetblk(sizeof *tn);
+	tnode_t *tn = expr_zalloc(sizeof *tn);
 	tn->tn_from_system_header = in_system_header;
 	return tn;
+}
 /* Free all memory which is allocated by the current expression. */
 void
-tfreeblk(void)
+expr_free_all(void)
+{
 	xfreeblk(&tmblk);
+}
 /*
  * Save the memory which is used by the current expression. This memory
- * is not freed by the next tfreeblk() call. The pointer returned can be
+ * is not freed by the next expr_free_all() call. The pointer returned can be
  * used to restore the memory.
  */
 memory_block *
-tsave(void)
+expr_save_memory(void)
+{
 	memory_block	*tmem;
 	tmem = tmblk;
 	tmblk = NULL;
 	return tmem;
+}
 /*
  * Free all memory used for the current expression and the memory used
- * be a previous expression and saved by tsave(). The next call to
+ * be a previous expression and saved by expr_save_memory(). The next call to
- * tfreeblk() frees the restored memory.
+ * expr_free_all() frees the restored memory.
  */
 void
-trestor(memory_block *tmem)
+expr_restore_memory(memory_block *tmem)
+{
-	tfreeblk();
+	expr_free_all();
 	if (tmblk != NULL) {
 		free(tmblk->blk);
 		free(tmblk);
+	}
 	tmblk = tmem;
+}

 @@ -1,14 +1,14 @@
-/*	$NetBSD: tree.c,v 1.256 2021/04/02 09:52:36 rillig Exp $	*/
+/*	$NetBSD: tree.c,v 1.257 2021/04/02 10:13:03 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,40 +27,40 @@
  * 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.256 2021/04/02 09:52:36 rillig Exp $");
+__RCSID("$NetBSD: tree.c,v 1.257 2021/04/02 10:13:03 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	*new_integer_constant_node(tspec_t, int64_t);
+static	tnode_t	*expr_new_integer_constant(tspec_t, int64_t);
 static	void	check_pointer_comparison(op_t,
 					 const tnode_t *, const tnode_t *);
 static	bool	check_assign_types_compatible(op_t, int,
 					      const tnode_t *, const tnode_t *);
 static	void	check_bad_enum_operation(op_t,
 					 const tnode_t *, const tnode_t *);
 static	void	check_enum_type_mismatch(op_t, int,
 				         const tnode_t *, const tnode_t *);
 static	void	check_enum_int_mismatch(op_t, int,
 					const tnode_t *, const tnode_t *);
 static	tnode_t	*new_tnode(op_t, type_t *, tnode_t *, tnode_t *);
 static	void	balance(op_t, tnode_t **, tnode_t **);
 static	void	warn_incompatible_types(op_t, const type_t *, tspec_t,
 @@ -134,83 +134,81 @@ debug_node(const tnode_t *tn, int indent
 		printf(", unknown value\n");
 	else if (op == STRING)
 		printf(", length %zu\n", tn->tn_string->st_len);
 	else {
 		printf("\n");
 		debug_node(tn->tn_left, indent + 1);
 		if (modtab[op].m_binary || tn->tn_right != NULL)
 			debug_node(tn->tn_right, indent + 1);
+	}
+}
 #endif
-/*
+/* Build 'pointer to tp', 'array of tp' or 'function returning tp'. */
  * Increase degree of reference.
  * This is most often used to change type "T" in type "pointer to T".
  */
 type_t *
-incref(type_t *tp, tspec_t t)
+derive_type(type_t *tp, tspec_t t)
+{
 	type_t	*tp2;
 	tp2 = getblk(sizeof *tp2);
 	tp2->t_tspec = t;
 	tp2->t_subt = tp;
 	return tp2;
+}
 /*
- * same for use in expressions
+ * Build 'pointer to tp', 'array of tp' or 'function returning tp'.  The
  * memory is freed at the end of the current expression.
  */
 type_t *
-tincref(type_t *tp, tspec_t t)
+expr_derive_type(type_t *tp, tspec_t t)
+{
 	type_t	*tp2;
-	tp2 = tgetblk(sizeof *tp2);
+	tp2 = expr_zalloc(sizeof *tp2);
 	tp2->t_tspec = t;
 	tp2->t_subt = tp;
 	return tp2;
+}
 /*
  * Create a node for a constant.
  */
 tnode_t *
-new_constant_node(type_t *tp, val_t *v)
+expr_new_constant(type_t *tp, val_t *v)
+{
 	tnode_t	*n;
 	n = expr_zalloc_tnode();
 	n->tn_op = CON;
 	n->tn_type = tp;
-	n->tn_val = tgetblk(sizeof *n->tn_val);
+	n->tn_val = expr_zalloc(sizeof *n->tn_val);
 	n->tn_val->v_tspec = tp->t_tspec;
 	n->tn_val->v_ansiu = v->v_ansiu;
 	n->tn_val->v_u = v->v_u;
 	free(v);
 	return n;
+}
 static tnode_t *
-new_integer_constant_node(tspec_t t, int64_t q)
+expr_new_integer_constant(tspec_t t, int64_t q)
+{
 	tnode_t	*n;
 	n = expr_zalloc_tnode();
 	n->tn_op = CON;
 	n->tn_type = gettyp(t);
-	n->tn_val = tgetblk(sizeof *n->tn_val);
+	n->tn_val = expr_zalloc(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 (Tflag && strcmp(sym->s_name, "__lint_false") == 0) {
 		sym->s_scl = CTCONST; /* close enough */
 		sym->s_type = gettyp(BOOL);
 		sym->s_value.v_tspec = BOOL;
 @@ -222,36 +220,36 @@ fallback_symbol(sym_t *sym)
 	if (Tflag && strcmp(sym->s_name, "__lint_true") == 0) {
 		sym->s_scl = CTCONST; /* close enough */
 		sym->s_type = gettyp(BOOL);
 		sym->s_value.v_tspec = BOOL;
 		sym->s_value.v_ansiu = false;
 		sym->s_value.v_quad = 1;
 		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 = incref(gettyp(CHAR), PTR);
+		sym->s_type = 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 = incref(gettyp(CHAR), PTR);
+		sym->s_type = derive_type(gettyp(CHAR), PTR);
 		sym->s_type->t_const = true;
 		return;
+	}
 	/* '%s' undefined */
 	error(99, sym->s_name);
+}
 /*
  * Create a node for a name (symbol table entry).
  * follow_token is the token which follows the name.
  */
 tnode_t *
 @@ -261,76 +259,76 @@ new_name_node(sym_t *sym, int follow_tok
 	if (sym->s_scl == NOSCL) {
 		sym->s_scl = EXTERN;
 		sym->s_def = DECL;
 		if (follow_token == T_LPAREN) {
 			if (sflag) {
 				/* function implicitly declared to ... */
 				warning(215);
+			}
 			/*
 			 * XXX if tflag is set the symbol should be
 			 * exported to level 0
 			 */
-			sym->s_type = incref(sym->s_type, FUNC);
+			sym->s_type = derive_type(sym->s_type, FUNC);
 		} else {
 			fallback_symbol(sym);
+		}
+	}
 	lint_assert(sym->s_kind == FVFT || sym->s_kind == FMEMBER);
 	n = expr_zalloc_tnode();
 	n->tn_type = sym->s_type;
 	if (sym->s_scl != CTCONST) {
 		n->tn_op = NAME;
 		n->tn_sym = sym;
 		if (sym->s_kind == FVFT && sym->s_type->t_tspec != FUNC)
 			n->tn_lvalue = true;
 	} else {
 		n->tn_op = CON;
-		n->tn_val = tgetblk(sizeof *n->tn_val);
+		n->tn_val = expr_zalloc(sizeof *n->tn_val);
 		*n->tn_val = sym->s_value;
+	}
 	return n;
+}
 tnode_t *
 new_string_node(strg_t *strg)
+{
 	size_t	len;
 	tnode_t	*n;
 	len = strg->st_len;
 	n = expr_zalloc_tnode();
 	n->tn_op = STRING;
-	n->tn_type = tincref(gettyp(strg->st_tspec), ARRAY);
+	n->tn_type = expr_derive_type(gettyp(strg->st_tspec), ARRAY);
 	n->tn_type->t_dim = len + 1;
 	n->tn_lvalue = true;
-	n->tn_string = tgetblk(sizeof *n->tn_string);
+	n->tn_string = expr_zalloc(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 = tgetblk(len + 1);
+		n->tn_string->st_cp = expr_zalloc(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 = tgetblk(size);
+		n->tn_string->st_wcp = expr_zalloc(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.
  */
 sym_t *
 @@ -342,28 +340,29 @@ 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(msym->s_type), msym->s_name);
 		rmsym(msym);
 		msym->s_kind = FMEMBER;
 		msym->s_scl = MOS;
-		msym->s_styp = tgetblk(sizeof *msym->s_styp);
+		msym->s_styp = expr_zalloc(sizeof *msym->s_styp);
-		msym->s_styp->sou_tag = tgetblk(sizeof *msym->s_styp->sou_tag);
+		msym->s_styp->sou_tag = expr_zalloc(
 		    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) {
 		t = (tp = tp->t_subt)->t_tspec;
 @@ -688,28 +687,28 @@ cconv(tnode_t *tn)
+{
 	type_t	*tp;
 	/*
 	 * Array-lvalue (array of type T) is converted into rvalue
 	 * (pointer to type T)
 	 */
 	if (tn->tn_type->t_tspec == ARRAY) {
 		if (!tn->tn_lvalue) {
 			/* XXX print correct operator */
 			/* %soperand of '%s' must be lvalue */
 			gnuism(114, "", modtab[ADDR].m_name);
+		}
-		tn = new_tnode(ADDR, tincref(tn->tn_type->t_subt, PTR),
+		tn = new_tnode(ADDR,
-			     tn, NULL);
+		    expr_derive_type(tn->tn_type->t_subt, PTR), tn, NULL);
+	}
 	/*
 	 * Expression of type function (function with return value of type T)
 	 * in rvalue-expression (pointer to function with return value
 	 * of type T)
 	 */
 	if (tn->tn_type->t_tspec == FUNC)
 		tn = build_address(tn, true);
 	/* lvalue to rvalue */
 	if (tn->tn_lvalue) {
 		tp = tduptyp(tn->tn_type);
 @@ -2056,27 +2055,27 @@ convert(op_t op, int arg, type_t *tp, tn
 		check_pointer_conversion(op, tn, tp);
+	}
 	ntn = expr_zalloc_tnode();
 	ntn->tn_op = CVT;
 	ntn->tn_type = tp;
 	ntn->tn_cast = op == CVT;
 	ntn->tn_from_system_header |= tn->tn_from_system_header;
 	ntn->tn_right = NULL;
 	if (tn->tn_op != CON || nt == VOID) {
 		ntn->tn_left = tn;
 	} else {
 		ntn->tn_op = CON;
-		ntn->tn_val = tgetblk(sizeof *ntn->tn_val);
+		ntn->tn_val = expr_zalloc(sizeof *ntn->tn_val);
 		convert_constant(op, arg, ntn->tn_type, ntn->tn_val,
 		    tn->tn_val);
+	}
 	return ntn;
+}
 /*
  * Print a warning if a prototype causes a type conversion that is
  * different from what would happen to the same argument in the
  * absence of a prototype.
+ *
  * Errors/warnings about illegal type combinations are already printed
 @@ -2674,33 +2673,33 @@ build_struct_access(op_t op, tnode_t *ln
 	lint_assert(rn->tn_sym->s_scl == MOS || rn->tn_sym->s_scl == MOU);
 	/*
 	 * Remember if the left operand is an lvalue (structure members
 	 * are lvalues if and only if the structure itself is an lvalue).
 	 */
 	nolval = op == POINT && !ln->tn_lvalue;
 	if (op == POINT) {
 		ln = build_address(ln, true);
 	} else if (ln->tn_type->t_tspec != PTR) {
 		lint_assert(tflag);
 		lint_assert(is_integer(ln->tn_type->t_tspec));
-		ln = convert(NOOP, 0, tincref(gettyp(VOID), PTR), ln);
+		ln = convert(NOOP, 0, expr_derive_type(gettyp(VOID), PTR), ln);
+	}
-	ctn = new_integer_constant_node(PTRDIFF_TSPEC,
+	ctn = expr_new_integer_constant(PTRDIFF_TSPEC,
 	    rn->tn_sym->s_value.v_quad / CHAR_SIZE);
-	ntn = new_tnode(PLUS, tincref(rn->tn_type, PTR), ln, ctn);
+	ntn = new_tnode(PLUS, expr_derive_type(rn->tn_type, PTR), ln, ctn);
 	if (ln->tn_op == CON)
 		ntn = fold(ntn);
 	if (rn->tn_type->t_bitfield) {
 		ntn = new_tnode(FSEL, ntn->tn_type->t_subt, ntn, NULL);
 	} else {
 		ntn = new_tnode(INDIR, ntn->tn_type->t_subt, ntn, NULL);
+	}
 	if (nolval)
 		ntn->tn_lvalue = false;
 	return ntn;
 @@ -2709,53 +2708,55 @@ build_struct_access(op_t op, tnode_t *ln
 /*
  * Create a node for INCAFT, INCBEF, DECAFT and DECBEF.
  */
 static tnode_t *
 build_prepost_incdec(op_t op, tnode_t *ln)
+{
 	tnode_t	*cn, *ntn;
 	lint_assert(ln != NULL);
 	if (ln->tn_type->t_tspec == PTR) {
 		cn = plength(ln->tn_type);
 	} else {
-		cn = new_integer_constant_node(INT, (int64_t)1);
+		cn = expr_new_integer_constant(INT, (int64_t)1);
+	}
 	ntn = new_tnode(op, ln->tn_type, ln, cn);
 	return ntn;
+}
 /*
  * Create a node for REAL, IMAG
  */
 static tnode_t *
 build_real_imag(op_t op, tnode_t *ln)
+{
 	tnode_t	*cn, *ntn;
 	lint_assert(ln != NULL);
 	switch (ln->tn_type->t_tspec) {
 	case LCOMPLEX:
 		/* XXX: integer and LDOUBLE don't match. */
-		cn = new_integer_constant_node(LDOUBLE, (int64_t)1);
+		cn = expr_new_integer_constant(LDOUBLE, (int64_t)1);
 		break;
 	case DCOMPLEX:
-		cn = new_integer_constant_node(DOUBLE, (int64_t)1);
+		/* XXX: integer and DOUBLE don't match. */
 		cn = expr_new_integer_constant(DOUBLE, (int64_t)1);
 		break;
 	case FCOMPLEX:
-		cn = new_integer_constant_node(FLOAT, (int64_t)1);
+		/* XXX: integer and FLOAT don't match. */
 		cn = expr_new_integer_constant(FLOAT, (int64_t)1);
 		break;
 	default:
 		/* __%s__ is illegal for type %s */
 		error(276, op == REAL ? "real" : "imag",
 		    type_name(ln->tn_type));
 		return NULL;
+	}
 	ntn = new_tnode(op, cn->tn_type, ln, cn);
 	ntn->tn_lvalue = true;
 	return ntn;
+}
 /*
 @@ -2770,27 +2771,27 @@ build_address(tnode_t *tn, bool noign)
 		if (tflag)
 			/* '&' before array or function: ignored */
 			warning(127);
 		return tn;
+	}
 	/* eliminate &* */
 	if (tn->tn_op == INDIR &&
 	    tn->tn_left->tn_type->t_tspec == PTR &&
 	    tn->tn_left->tn_type->t_subt == tn->tn_type) {
 		return tn->tn_left;
+	}
-	return new_tnode(ADDR, tincref(tn->tn_type, PTR), tn, NULL);
+	return new_tnode(ADDR, expr_derive_type(tn->tn_type, PTR), tn, NULL);
+}
 /*
  * Create a node for operators PLUS and MINUS.
  */
 static tnode_t *
 build_plus_minus(op_t op, tnode_t *ln, tnode_t *rn)
+{
 	tnode_t	*ntn, *ctn;
 	type_t	*tp;
 	/* If pointer and integer, then pointer to the lhs. */
 	if (rn->tn_type->t_tspec == PTR && is_integer(ln->tn_type->t_tspec)) {
 @@ -3027,27 +3028,27 @@ plength(type_t *tp)
 			lint_assert(elsz != -1);
+		}
 		break;
+	}
 	if (elem == 0 && elsz != 0) {
 		/* cannot do pointer arithmetic on operand of unknown size */
 		error(136);
+	}
 	if (elsz == 0)
 		elsz = CHAR_SIZE;
-	return new_integer_constant_node(PTRDIFF_TSPEC,
+	return expr_new_integer_constant(PTRDIFF_TSPEC,
 	    (int64_t)(elem * elsz / CHAR_SIZE));
+}
 /*
  * XXX
  * Note: There appear to be a number of bugs in detecting overflow in
  * this function. An audit and a set of proper regression tests are needed.
  *     --Perry Metzger, Nov. 16, 2001
  */
 /*
  * Do only as much as necessary to compute constant expressions.
  * Called only if the operator allows folding and all operands are constants.
  */
 @@ -3177,27 +3178,27 @@ fold(tnode_t *tn)
 		lint_assert(/*CONSTCOND*/false);
+	}
 	/* XXX does not work for quads. */
 	if (ovfl || ((uint64_t)(q | mask) != ~(uint64_t)0 &&
 	    (q & ~mask) != 0)) {
 		if (hflag)
 			/* integer overflow detected, op %s */
 			warning(141, modtab[tn->tn_op].m_name);
+	}
 	v->v_quad = xsign(q, t, -1);
-	cn = new_constant_node(tn->tn_type, v);
+	cn = expr_new_constant(tn->tn_type, v);
 	if (tn->tn_left->tn_system_dependent)
 		cn->tn_system_dependent = true;
 	if (modtab[tn->tn_op].m_binary && tn->tn_right->tn_system_dependent)
 		cn->tn_system_dependent = true;
 	return cn;
+}
 /*
  * Fold constant nodes, as much as is needed for comparing the value with 0
  * (test context, for controlling expressions).
  */
 static tnode_t *
 @@ -3220,27 +3221,27 @@ fold_test(tnode_t *tn)
 			warning(239);
 		v->v_quad = !l ? 1 : 0;
 		break;
 	case LOGAND:
 		v->v_quad = l && r ? 1 : 0;
 		break;
 	case LOGOR:
 		v->v_quad = l || r ? 1 : 0;
 		break;
 	default:
 		lint_assert(/*CONSTCOND*/false);
+	}
-	return new_constant_node(tn->tn_type, v);
+	return expr_new_constant(tn->tn_type, v);
+}
 /*
  * Fold constant nodes having operands with floating point type.
  */
 static tnode_t *
 fold_float(tnode_t *tn)
+{
 	val_t	*v;
 	tspec_t	t;
 	ldbl_t	l, r = 0;
 	fpe = 0;
 @@ -3317,56 +3318,56 @@ fold_float(tnode_t *tn)
 	     (v->v_ldbl > DBL_MAX || v->v_ldbl < -DBL_MAX))) {
 		/* floating point overflow detected, op %s */
 		warning(142, modtab[tn->tn_op].m_name);
 		if (t == FLOAT) {
 			v->v_ldbl = v->v_ldbl < 0 ? -FLT_MAX : FLT_MAX;
 		} else if (t == DOUBLE) {
 			v->v_ldbl = v->v_ldbl < 0 ? -DBL_MAX : DBL_MAX;
 		} else {
 			v->v_ldbl = v->v_ldbl < 0 ? -LDBL_MAX: LDBL_MAX;
+		}
 	    fpe = 0;
+	}
-	return new_constant_node(tn->tn_type, v);
+	return expr_new_constant(tn->tn_type, v);
+}
 /*
  * Create a constant node for sizeof.
  */
 tnode_t *
 build_sizeof(const type_t *tp)
+{
 	int64_t size_in_bytes = type_size_in_bits(tp) / CHAR_SIZE;
-	tnode_t *tn = new_integer_constant_node(SIZEOF_TSPEC, size_in_bytes);
+	tnode_t *tn = expr_new_integer_constant(SIZEOF_TSPEC, size_in_bytes);
 	tn->tn_system_dependent = true;
 	return tn;
+}
 /*
  * Create a constant node for offsetof.
  */
 tnode_t *
 build_offsetof(const type_t *tp, const sym_t *sym)
+{
 	tspec_t t = tp->t_tspec;
 	if (t != STRUCT && t != UNION)
 		/* unacceptable operand of '%s' */
 		error(111, "offsetof");
 	// XXX: wrong size, no checking for sym fixme
 	int64_t offset_in_bytes = type_size_in_bits(tp) / CHAR_SIZE;
-	tnode_t *tn = new_integer_constant_node(SIZEOF_TSPEC, offset_in_bytes);
+	tnode_t *tn = expr_new_integer_constant(SIZEOF_TSPEC, offset_in_bytes);
 	tn->tn_system_dependent = true;
 	return tn;
+}
 int64_t
 type_size_in_bits(const type_t *tp)
+{
 	int	elem, elsz;
 	bool	flex;
 	elem = 1;
 	flex = false;
 	while (tp->t_tspec == ARRAY) {
 @@ -3448,27 +3449,27 @@ build_alignof(const type_t *tp)
 		if (tp->t_bitfield) {
 			/* cannot take size/alignment of bit-field */
 			error(145);
 			return 0;
+		}
 		if (tp->t_tspec == VOID) {
 			/* cannot take size/alignment of void */
 			error(146);
 			return 0;
+		}
 		break;
+	}
-	return new_integer_constant_node(SIZEOF_TSPEC,
+	return expr_new_integer_constant(SIZEOF_TSPEC,
 	    (int64_t)alignment_in_bits(tp) / CHAR_SIZE);
+}
 /*
  * Type casts.
  */
 tnode_t *
 cast(tnode_t *tn, type_t *tp)
+{
 	tspec_t	nt, ot;
 	if (tn == NULL)
 		return NULL;
 @@ -3557,27 +3558,27 @@ cast(tnode_t *tn, type_t *tp)
  * information about expected argument types.
  */
 tnode_t *
 new_function_argument_node(tnode_t *args, tnode_t *arg)
+{
 	tnode_t	*ntn;
 	/*
 	 * If there was a serious error in the expression for the argument,
 	 * create a dummy argument so the positions of the remaining arguments
 	 * will not change.
 	 */
 	if (arg == NULL)
-		arg = new_integer_constant_node(INT, (int64_t)0);
+		arg = expr_new_integer_constant(INT, 0);
 	ntn = new_tnode(PUSH, arg->tn_type, arg, args);
 	return ntn;
+}
 /*
  * Create the node for a function call. Also check types of
  * function arguments and insert conversions, if necessary.
  */
 tnode_t *
 new_function_call_node(tnode_t *func, tnode_t *args)
+{
 @@ -3779,27 +3780,27 @@ is_constcond_false(const tnode_t *tn, ts
  * functions called by build(). These tests must be done here because
  * we need some information about the context in which the operations
  * are performed.
  * After all tests are performed and dofreeblk is true, expr() frees the
  * memory which is used for the expression.
  */
 void
 expr(tnode_t *tn, bool vctx, bool tctx, bool dofreeblk, bool constcond_false_ok)
+{
 	lint_assert(tn != NULL || nerr != 0);
 	if (tn == NULL) {
-		tfreeblk();
+		expr_free_all();
 		return;
+	}
 	/* expr() is also called in global initializations */
 	/* TODO: rename constcond_false_ok */
 	if (dcs->d_ctx != EXTERN && !constcond_false_ok)
 		check_statement_reachable();
 	check_expr_misc(tn, vctx, tctx, !tctx, false, false, false);
 	if (tn->tn_op == ASSIGN) {
 		if (hflag && tctx)
 			/* assignment in conditional context */
 			warning(159);
 @@ -3814,27 +3815,27 @@ expr(tnode_t *tn, bool vctx, bool tctx,
 	if (!modtab[tn->tn_op].m_has_side_effect) {
 		/*
 		 * for left operands of COMMA this warning is already
 		 * printed
 		 */
 		if (tn->tn_op != COMMA && !vctx && !tctx)
 			check_null_effect(tn);
+	}
 	if (dflag)
 		display_expression(tn, 0);
 	/* free the tree memory */
 	if (dofreeblk)
-		tfreeblk();
+		expr_free_all();
+}
 static bool
 has_side_effect(const tnode_t *tn) // NOLINT(misc-no-recursion)
+{
 	op_t op = tn->tn_op;
 	if (modtab[op].m_has_side_effect)
 		return true;
 	if (op == CVT && tn->tn_type->t_tspec == VOID)
 		return has_side_effect(tn->tn_left);