 @@ -1,14 +1,14 @@
-/*	$NetBSD: tree.c,v 1.75 2014/02/18 22:01:36 christos Exp $	*/
+/*	$NetBSD: tree.c,v 1.76 2014/04/17 18:23:18 christos 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.75 2014/02/18 22:01:36 christos Exp $");
+__RCSID("$NetBSD: tree.c,v 1.76 2014/04/17 18:23:18 christos Exp $");
 #endif
 #include <stdlib.h>
 #include <string.h>
 #include <float.h>
 #include <limits.h>
 #include <math.h>
 #include <signal.h>
 #include "lint1.h"
 #include "cgram.h"
 #include "externs1.h"
 @@ -79,26 +79,65 @@ static	tnode_t	*plength(type_t *);
 static	tnode_t	*fold(tnode_t *);
 static	tnode_t	*foldtst(tnode_t *);
 static	tnode_t	*foldflt(tnode_t *);
 static	tnode_t	*chkfarg(type_t *, tnode_t *);
 static	tnode_t	*parg(int, type_t *, tnode_t *);
 static	void	nulleff(tnode_t *);
 static	void	displexpr(tnode_t *, int);
 static	void	chkaidx(tnode_t *, int);
 static	void	chkcomp(op_t, tnode_t *, tnode_t *);
 static	void	precconf(tnode_t *);
 extern sig_atomic_t fpe;
 #if 0
 static char *
 dumpnode(char *buf, size_t len, tnode_t *tn) {
 	const char *n = getopname(tn->tn_op);
 	const char *s;
 	char tbuf[256];
 	switch (tn->tn_op) {
 	case NAME:
 		s = tn->tn_sym->s_name;
 		break;
 	case CON:
 	case STRING:
 		s = "*";	/* todo */
 		break;
 	default:
 		s = NULL;
 		break;
+	}
 	char lb[1024];
 	char rb[1024];
 	if (s == NULL && tn->tn_left != NULL)
 		dumpnode(lb, sizeof(lb), tn->tn_left);
 	else
 		strcpy(lb, "(null)");
 	if (s == NULL && tn->tn_right != NULL)
 		dumpnode(rb, sizeof(rb), tn->tn_right);
 	else
 		strcpy(rb, "(null)");
 	snprintf(buf, len, "%s: (%s) = %s [%s, %s]", n,
 	    tyname(tbuf, sizeof(tbuf), tn->tn_type), s, lb, rb);
 	return buf;
+}
 #endif
 /*
  * 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)
+{
 	type_t	*tp2;
 	tp2 = getblk(sizeof (type_t));
 	tp2->t_tspec = t;
 	tp2->t_subt = tp;
 	return (tp2);
 @@ -194,27 +233,27 @@ getnnode(sym_t *sym, int ntok)
 				} else {
 					error(99, sym->s_name);
 					fixtype = 0;
+				}
 				if (fixtype) {
 					sym->s_type = incref(gettyp(CHAR), PTR);
 					sym->s_type->t_const = 1;
+				}
+			}
+		}
+	}
 	if (sym->s_kind != FVFT && sym->s_kind != FMOS)
-		LERROR("getnnode()");
+		LERROR("getnnode(%d)", sym->s_kind);
 	n = getnode();
 	n->tn_type = sym->s_type;
 	if (sym->s_scl != ENUMCON) {
 		n->tn_op = NAME;
 		n->tn_sym = sym;
 		if (sym->s_kind == FVFT && sym->s_type->t_tspec != FUNC)
 			n->tn_lvalue = 1;
 	} else {
 		n->tn_op = CON;
 		n->tn_val = tgetblk(sizeof (val_t));
 		*n->tn_val = sym->s_value;
+	}
 @@ -1606,50 +1645,48 @@ balance(op_t op, tnode_t **lnp, tnode_t
+}
 /*
  * Insert a conversion operator, which converts the type of the node
  * to another given type.
  * If op is FARG, arg is the number of the argument (used for warnings).
  */
 tnode_t *
 convert(op_t op, int arg, type_t *tp, tnode_t *tn)
+{
 	tnode_t	*ntn;
 	tspec_t	nt, ot, ost = NOTSPEC;
 	if (tn->tn_lvalue)
 		LERROR("convert()");
 	nt = tp->t_tspec;
 	if ((ot = tn->tn_type->t_tspec) == PTR)
 		ost = tn->tn_type->t_subt->t_tspec;
 	if (!tflag && !sflag && op == FARG)
 		ptconv(arg, nt, ot, tp, tn);
 	if (isityp(nt) && isityp(ot)) {
 		iiconv(op, arg, nt, ot, tp, tn);
 	} else if (nt == PTR && ((ot == PTR && ost == VOID) || isityp(ot)) &&
 		   tn->tn_op == CON && tn->tn_val->v_quad == 0) {
 		/* 0, 0L and (void *)0 may be assigned to any pointer. */
 	} else if (isityp(nt) && ot == PTR) {
 		piconv(op, nt, tp, tn);
 	} else if (nt == PTR && ot == PTR) {
 		ppconv(op, tn, tp);
+	}
 	ntn = getnode();
 	ntn->tn_op = CVT;
 	ntn->tn_type = tp;
 	ntn->tn_cast = op == CVT;
 	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 (val_t));
 		cvtcon(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
 @@ -3559,27 +3596,29 @@ chkmisc(tnode_t *tn, int vctx, int tctx,
 		break;
 	case ASSIGN:
 		if (ln->tn_op == NAME && !szof && (reached || rchflg)) {
 			setsflg(ln->tn_sym);
 			if (ln->tn_sym->s_scl == EXTERN)
 				outusg(ln->tn_sym);
+		}
 		if (ln->tn_op == STAR && ln->tn_left->tn_op == PLUS)
 			/* check the range of array indices */
 			chkaidx(ln->tn_left, 0);
 		break;
 	case CALL:
 		if (ln->tn_op != AMPER || ln->tn_left->tn_op != NAME)
-			LERROR("chkmisc()");
+			LERROR("chkmisc(op=%s != %s || %s != %s)",
 			    getopname(ln->tn_op), getopname(AMPER),
 			    getopname(ln->tn_left->tn_op), getopname(NAME));
 		if (!szof)
 			outcall(tn, vctx || tctx, rvdisc);
 		break;
 	case EQ:
 		/* equality operator "==" found where "=" was exp. */
 		if (hflag && eqwarn)
 			warning(160);
 		break;
 	case CON:
 	case NAME:
 	case STRING:
 		return;
 		/* LINTED206: (enumeration values not handled in switch) */