xref: /netbsd-src/usr.bin/xlint/lint1/tree.c (revision bdc22b2e01993381dcefeff2bc9b56ca75a4235c)
1 /*	$NetBSD: tree.c,v 1.85 2018/06/29 20:18:05 christos Exp $	*/
2 
3 /*
4  * Copyright (c) 1994, 1995 Jochen Pohl
5  * All Rights Reserved.
6  *
7  * Redistribution and use in source and binary forms, with or without
8  * modification, are permitted provided that the following conditions
9  * are met:
10  * 1. Redistributions of source code must retain the above copyright
11  *    notice, this list of conditions and the following disclaimer.
12  * 2. Redistributions in binary form must reproduce the above copyright
13  *    notice, this list of conditions and the following disclaimer in the
14  *    documentation and/or other materials provided with the distribution.
15  * 3. All advertising materials mentioning features or use of this software
16  *    must display the following acknowledgement:
17  *      This product includes software developed by Jochen Pohl for
18  *	The NetBSD Project.
19  * 4. The name of the author may not be used to endorse or promote products
20  *    derived from this software without specific prior written permission.
21  *
22  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
23  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
24  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
25  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
26  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
27  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
28  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
29  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
30  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
31  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32  */
33 
34 #if HAVE_NBTOOL_CONFIG_H
35 #include "nbtool_config.h"
36 #endif
37 
38 #include <sys/cdefs.h>
39 #if defined(__RCSID) && !defined(lint)
40 __RCSID("$NetBSD: tree.c,v 1.85 2018/06/29 20:18:05 christos Exp $");
41 #endif
42 
43 #include <stdlib.h>
44 #include <string.h>
45 #include <float.h>
46 #include <limits.h>
47 #include <math.h>
48 #include <signal.h>
49 
50 #include "lint1.h"
51 #include "cgram.h"
52 #include "externs1.h"
53 
54 static	tnode_t	*getinode(tspec_t, int64_t);
55 static	void	ptrcmpok(op_t, tnode_t *, tnode_t *);
56 static	int	asgntypok(op_t, int, tnode_t *, tnode_t *);
57 static	void	chkbeop(op_t, tnode_t *, tnode_t *);
58 static	void	chkeop2(op_t, int, tnode_t *, tnode_t *);
59 static	void	chkeop1(op_t, int, tnode_t *, tnode_t *);
60 static	tnode_t	*mktnode(op_t, type_t *, tnode_t *, tnode_t *);
61 static	void	balance(op_t, tnode_t **, tnode_t **);
62 static	void	incompat(op_t, tspec_t, tspec_t);
63 static	void	illptrc(mod_t *, type_t *, type_t *);
64 static	void	mrgqual(type_t **, type_t *, type_t *);
65 static	int	conmemb(type_t *);
66 static	void	ptconv(int, tspec_t, tspec_t, type_t *, tnode_t *);
67 static	void	iiconv(op_t, int, tspec_t, tspec_t, type_t *, tnode_t *);
68 static	void	piconv(op_t, tspec_t, type_t *, tnode_t *);
69 static	void	ppconv(op_t, tnode_t *, type_t *);
70 static	tnode_t	*bldstr(op_t, tnode_t *, tnode_t *);
71 static	tnode_t	*bldincdec(op_t, tnode_t *);
72 static	tnode_t	*bldri(op_t, tnode_t *);
73 static	tnode_t	*bldamper(tnode_t *, int);
74 static	tnode_t	*bldplmi(op_t, tnode_t *, tnode_t *);
75 static	tnode_t	*bldshft(op_t, tnode_t *, tnode_t *);
76 static	tnode_t	*bldcol(tnode_t *, tnode_t *);
77 static	tnode_t	*bldasgn(op_t, tnode_t *, tnode_t *);
78 static	tnode_t	*plength(type_t *);
79 static	tnode_t	*fold(tnode_t *);
80 static	tnode_t	*foldtst(tnode_t *);
81 static	tnode_t	*foldflt(tnode_t *);
82 static	tnode_t	*chkfarg(type_t *, tnode_t *);
83 static	tnode_t	*parg(int, type_t *, tnode_t *);
84 static	void	nulleff(tnode_t *);
85 static	void	displexpr(tnode_t *, int);
86 static	void	chkaidx(tnode_t *, int);
87 static	void	chkcomp(op_t, tnode_t *, tnode_t *);
88 static	void	precconf(tnode_t *);
89 
90 extern sig_atomic_t fpe;
91 
92 #if 0
93 static char *
94 dumpnode(char *buf, size_t len, tnode_t *tn) {
95 	const char *n = getopname(tn->tn_op);
96 	const char *s;
97 	char tbuf[256];
98 
99 	switch (tn->tn_op) {
100 	case NAME:
101 		s = tn->tn_sym->s_name;
102 		break;
103 	case CON:
104 	case STRING:
105 		s = "*";	/* todo */
106 		break;
107 	default:
108 		s = NULL;
109 		break;
110 	}
111 	char lb[1024];
112 	char rb[1024];
113 
114 	if (s == NULL && tn->tn_left != NULL)
115 		dumpnode(lb, sizeof(lb), tn->tn_left);
116 	else
117 		strcpy(lb, "(null)");
118 
119 	if (s == NULL && tn->tn_right != NULL)
120 		dumpnode(rb, sizeof(rb), tn->tn_right);
121 	else
122 		strcpy(rb, "(null)");
123 
124 
125 	snprintf(buf, len, "%s: (%s) = %s [%s, %s]", n,
126 	    tyname(tbuf, sizeof(tbuf), tn->tn_type), s, lb, rb);
127 	return buf;
128 }
129 #endif
130 
131 /*
132  * Increase degree of reference.
133  * This is most often used to change type "T" in type "pointer to T".
134  */
135 type_t *
136 incref(type_t *tp, tspec_t t)
137 {
138 	type_t	*tp2;
139 
140 	tp2 = getblk(sizeof (type_t));
141 	tp2->t_tspec = t;
142 	tp2->t_subt = tp;
143 	return (tp2);
144 }
145 
146 /*
147  * same for use in expressions
148  */
149 type_t *
150 tincref(type_t *tp, tspec_t t)
151 {
152 	type_t	*tp2;
153 
154 	tp2 = tgetblk(sizeof (type_t));
155 	tp2->t_tspec = t;
156 	tp2->t_subt = tp;
157 	return (tp2);
158 }
159 
160 /*
161  * Create a node for a constant.
162  */
163 tnode_t *
164 getcnode(type_t *tp, val_t *v)
165 {
166 	tnode_t	*n;
167 
168 	n = getnode();
169 	n->tn_op = CON;
170 	n->tn_type = tp;
171 	n->tn_val = tgetblk(sizeof (val_t));
172 	n->tn_val->v_tspec = tp->t_tspec;
173 	n->tn_val->v_ansiu = v->v_ansiu;
174 	n->tn_val->v_u = v->v_u;
175 	free(v);
176 	return (n);
177 }
178 
179 /*
180  * Create a node for a integer constant.
181  */
182 static tnode_t *
183 getinode(tspec_t t, int64_t q)
184 {
185 	tnode_t	*n;
186 
187 	n = getnode();
188 	n->tn_op = CON;
189 	n->tn_type = gettyp(t);
190 	n->tn_val = tgetblk(sizeof (val_t));
191 	n->tn_val->v_tspec = t;
192 	n->tn_val->v_quad = q;
193 	return (n);
194 }
195 
196 /*
197  * Create a node for a name (symbol table entry).
198  * ntok is the token which follows the name.
199  */
200 tnode_t *
201 getnnode(sym_t *sym, int ntok)
202 {
203 	tnode_t	*n;
204 
205 	if (sym->s_scl == NOSCL) {
206 		sym->s_scl = EXTERN;
207 		sym->s_def = DECL;
208 		if (ntok == T_LPARN) {
209 			if (sflag) {
210 				/* function implicitly declared to ... */
211 				warning(215);
212 			}
213 			/*
214 			 * XXX if tflag is set the symbol should be
215 			 * exported to level 0
216 			 */
217 			sym->s_type = incref(sym->s_type, FUNC);
218 		} else {
219 			if (!blklev) {
220 				/* %s undefined */
221 				error(99, sym->s_name);
222 			} else {
223 				int fixtype;
224 				if (strcmp(sym->s_name, "__FUNCTION__") == 0 ||
225 				    strcmp(sym->s_name, "__PRETTY_FUNCTION__")
226 				    == 0) {
227 					gnuism(316);
228 					fixtype = 1;
229 				} else if (strcmp(sym->s_name, "__func__") == 0) {
230 					if (!Sflag)
231 						warning(317);
232 					fixtype = 1;
233 				} else {
234 					error(99, sym->s_name);
235 					fixtype = 0;
236 				}
237 				if (fixtype) {
238 					sym->s_type = incref(gettyp(CHAR), PTR);
239 					sym->s_type->t_const = 1;
240 				}
241 			}
242 		}
243 	}
244 
245 	if (sym->s_kind != FVFT && sym->s_kind != FMOS)
246 		LERROR("getnnode(%d)", sym->s_kind);
247 
248 	n = getnode();
249 	n->tn_type = sym->s_type;
250 	if (sym->s_scl != ENUMCON) {
251 		n->tn_op = NAME;
252 		n->tn_sym = sym;
253 		if (sym->s_kind == FVFT && sym->s_type->t_tspec != FUNC)
254 			n->tn_lvalue = 1;
255 	} else {
256 		n->tn_op = CON;
257 		n->tn_val = tgetblk(sizeof (val_t));
258 		*n->tn_val = sym->s_value;
259 	}
260 
261 	return (n);
262 }
263 
264 /*
265  * Create a node for a string.
266  */
267 tnode_t *
268 getsnode(strg_t *strg)
269 {
270 	size_t	len;
271 	tnode_t	*n;
272 
273 	len = strg->st_len;
274 
275 	n = getnode();
276 
277 	n->tn_op = STRING;
278 	n->tn_type = tincref(gettyp(strg->st_tspec), ARRAY);
279 	n->tn_type->t_dim = len + 1;
280 	n->tn_lvalue = 1;
281 
282 	n->tn_strg = tgetblk(sizeof (strg_t));
283 	n->tn_strg->st_tspec = strg->st_tspec;
284 	n->tn_strg->st_len = len;
285 
286 	if (strg->st_tspec == CHAR) {
287 		n->tn_strg->st_cp = tgetblk(len + 1);
288 		(void)memcpy(n->tn_strg->st_cp, strg->st_cp, len + 1);
289 		free(strg->st_cp);
290 	} else {
291 		n->tn_strg->st_wcp = tgetblk((len + 1) * sizeof (wchar_t));
292 		(void)memcpy(n->tn_strg->st_wcp, strg->st_wcp,
293 			     (len + 1) * sizeof (wchar_t));
294 		free(strg->st_wcp);
295 	}
296 	free(strg);
297 
298 	return (n);
299 }
300 
301 /*
302  * Returns a symbol which has the same name as the msym argument and is a
303  * member of the struct or union specified by the tn argument.
304  */
305 sym_t *
306 strmemb(tnode_t *tn, op_t op, sym_t *msym)
307 {
308 	str_t	*str;
309 	type_t	*tp;
310 	sym_t	*sym, *csym;
311 	int	eq;
312 	tspec_t	t;
313 
314 	/*
315 	 * Remove the member if it was unknown until now (Which means
316 	 * that no defined struct or union has a member with the same name).
317 	 */
318 	if (msym->s_scl == NOSCL) {
319 		/* undefined struct/union member: %s */
320 		error(101, msym->s_name);
321 		rmsym(msym);
322 		msym->s_kind = FMOS;
323 		msym->s_scl = MOS;
324 		msym->s_styp = tgetblk(sizeof (str_t));
325 		msym->s_styp->stag = tgetblk(sizeof (sym_t));
326 		msym->s_styp->stag->s_name = unnamed;
327 		msym->s_value.v_tspec = INT;
328 		return (msym);
329 	}
330 
331 	/* Set str to the tag of which msym is expected to be a member. */
332 	str = NULL;
333 	t = (tp = tn->tn_type)->t_tspec;
334 	if (op == POINT) {
335 		if (t == STRUCT || t == UNION)
336 			str = tp->t_str;
337 	} else if (op == ARROW && t == PTR) {
338 		t = (tp = tp->t_subt)->t_tspec;
339 		if (t == STRUCT || t == UNION)
340 			str = tp->t_str;
341 	}
342 
343 	/*
344 	 * If this struct/union has a member with the name of msym, return
345 	 * return this it.
346 	 */
347 	if (str != NULL) {
348 		for (sym = msym; sym != NULL; sym = sym->s_link) {
349 			if (sym->s_scl != MOS && sym->s_scl != MOU)
350 				continue;
351 			if (sym->s_styp != str)
352 				continue;
353 			if (strcmp(sym->s_name, msym->s_name) != 0)
354 				continue;
355 			return (sym);
356 		}
357 	}
358 
359 	/*
360 	 * Set eq to 0 if there are struct/union members with the same name
361 	 * and different types and/or offsets.
362 	 */
363 	eq = 1;
364 	for (csym = msym; csym != NULL; csym = csym->s_link) {
365 		if (csym->s_scl != MOS && csym->s_scl != MOU)
366 			continue;
367 		if (strcmp(msym->s_name, csym->s_name) != 0)
368 			continue;
369 		for (sym = csym->s_link ; sym != NULL; sym = sym->s_link) {
370 			int w;
371 
372 			if (sym->s_scl != MOS && sym->s_scl != MOU)
373 				continue;
374 			if (strcmp(csym->s_name, sym->s_name) != 0)
375 				continue;
376 			if (csym->s_value.v_quad != sym->s_value.v_quad) {
377 				eq = 0;
378 				break;
379 			}
380 			w = 0;
381 			eq = eqtype(csym->s_type, sym->s_type, 0, 0, &w) && !w;
382 			if (!eq)
383 				break;
384 			if (csym->s_field != sym->s_field) {
385 				eq = 0;
386 				break;
387 			}
388 			if (csym->s_field) {
389 				type_t	*tp1, *tp2;
390 
391 				tp1 = csym->s_type;
392 				tp2 = sym->s_type;
393 				if (tp1->t_flen != tp2->t_flen) {
394 					eq = 0;
395 					break;
396 				}
397 				if (tp1->t_foffs != tp2->t_foffs) {
398 					eq = 0;
399 					break;
400 				}
401 			}
402 		}
403 		if (!eq)
404 			break;
405 	}
406 
407 	/*
408 	 * Now handle the case in which the left operand refers really
409 	 * to a struct/union, but the right operand is not member of it.
410 	 */
411 	if (str != NULL) {
412 		/* illegal member use: %s */
413 		if (eq && tflag) {
414 			warning(102, msym->s_name);
415 		} else {
416 			error(102, msym->s_name);
417 		}
418 		return (msym);
419 	}
420 
421 	/*
422 	 * Now the left operand of ARROW does not point to a struct/union
423 	 * or the left operand of POINT is no struct/union.
424 	 */
425 	if (eq) {
426 		if (op == POINT) {
427 			/* left operand of "." must be struct/union object */
428 			if (tflag) {
429 				warning(103);
430 			} else {
431 				error(103);
432 			}
433 		} else {
434 			char buf[64];
435 			/* left operand of "->" must be pointer to ... */
436 			if (tflag && tn->tn_type->t_tspec == PTR) {
437 				tyname(buf, sizeof(buf), tn->tn_type);
438 				warning(104, buf);
439 			} else {
440 				tyname(buf, sizeof(buf), tn->tn_type);
441 				error(104, buf);
442 			}
443 		}
444 	} else {
445 		if (tflag) {
446 			/* non-unique member requires struct/union %s */
447 			error(105, op == POINT ? "object" : "pointer");
448 		} else {
449 			/* unacceptable operand of %s */
450 			error(111, modtab[op].m_name);
451 		}
452 	}
453 
454 	return (msym);
455 }
456 
457 /*
458  * Create a tree node. Called for most operands except function calls,
459  * sizeof and casts.
460  *
461  * op	operator
462  * ln	left operand
463  * rn	if not NULL, right operand
464  */
465 tnode_t *
466 build(op_t op, tnode_t *ln, tnode_t *rn)
467 {
468 	mod_t	*mp;
469 	tnode_t	*ntn;
470 	type_t	*rtp;
471 
472 	mp = &modtab[op];
473 
474 	/* If there was an error in one of the operands, return. */
475 	if (ln == NULL || (mp->m_binary && rn == NULL))
476 		return (NULL);
477 
478 	/*
479 	 * Apply class conversions to the left operand, but only if its
480 	 * value is needed or it is compaired with null.
481 	 */
482 	if (mp->m_vctx || mp->m_tctx)
483 		ln = cconv(ln);
484 	/*
485 	 * The right operand is almost always in a test or value context,
486 	 * except if it is a struct or union member.
487 	 */
488 	if (mp->m_binary && op != ARROW && op != POINT)
489 		rn = cconv(rn);
490 
491 	/*
492 	 * Print some warnings for comparisons of unsigned values with
493 	 * constants lower than or equal to null. This must be done
494 	 * before promote() because otherwise unsigned char and unsigned
495 	 * short would be promoted to int. Also types are tested to be
496 	 * CHAR, which would also become int.
497 	 */
498 	if (mp->m_comp)
499 		chkcomp(op, ln, rn);
500 
501 	/*
502 	 * Promote the left operand if it is in a test or value context
503 	 */
504 	if (mp->m_vctx || mp->m_tctx)
505 		ln = promote(op, 0, ln);
506 	/*
507 	 * Promote the right operand, but only if it is no struct or
508 	 * union member, or if it is not to be assigned to the left operand
509 	 */
510 	if (mp->m_binary && op != ARROW && op != POINT &&
511 	    op != ASSIGN && op != RETURN) {
512 		rn = promote(op, 0, rn);
513 	}
514 
515 	/*
516 	 * If the result of the operation is different for signed or
517 	 * unsigned operands and one of the operands is signed only in
518 	 * ANSI C, print a warning.
519 	 */
520 	if (mp->m_tlansiu && ln->tn_op == CON && ln->tn_val->v_ansiu) {
521 		/* ANSI C treats constant as unsigned, op %s */
522 		warning(218, mp->m_name);
523 		ln->tn_val->v_ansiu = 0;
524 	}
525 	if (mp->m_transiu && rn->tn_op == CON && rn->tn_val->v_ansiu) {
526 		/* ANSI C treats constant as unsigned, op %s */
527 		warning(218, mp->m_name);
528 		rn->tn_val->v_ansiu = 0;
529 	}
530 
531 	/* Make sure both operands are of the same type */
532 	if (mp->m_balance || (tflag && (op == SHL || op == SHR)))
533 		balance(op, &ln, &rn);
534 
535 	/*
536 	 * Check types for compatibility with the operation and mutual
537 	 * compatibility. Return if there are serios problems.
538 	 */
539 	if (!typeok(op, 0, ln, rn))
540 		return (NULL);
541 
542 	/* And now create the node. */
543 	switch (op) {
544 	case POINT:
545 	case ARROW:
546 		ntn = bldstr(op, ln, rn);
547 		break;
548 	case INCAFT:
549 	case DECAFT:
550 	case INCBEF:
551 	case DECBEF:
552 		ntn = bldincdec(op, ln);
553 		break;
554 	case AMPER:
555 		ntn = bldamper(ln, 0);
556 		break;
557 	case STAR:
558 		ntn = mktnode(STAR, ln->tn_type->t_subt, ln, NULL);
559 		break;
560 	case PLUS:
561 	case MINUS:
562 		ntn = bldplmi(op, ln, rn);
563 		break;
564 	case SHL:
565 	case SHR:
566 		ntn = bldshft(op, ln, rn);
567 		break;
568 	case COLON:
569 		ntn = bldcol(ln, rn);
570 		break;
571 	case ASSIGN:
572 	case MULASS:
573 	case DIVASS:
574 	case MODASS:
575 	case ADDASS:
576 	case SUBASS:
577 	case SHLASS:
578 	case SHRASS:
579 	case ANDASS:
580 	case XORASS:
581 	case ORASS:
582 	case RETURN:
583 		ntn = bldasgn(op, ln, rn);
584 		break;
585 	case COMMA:
586 	case QUEST:
587 		ntn = mktnode(op, rn->tn_type, ln, rn);
588 		break;
589 	case REAL:
590 	case IMAG:
591 		ntn = bldri(op, ln);
592 		break;
593 	default:
594 		rtp = mp->m_logop ? gettyp(INT) : ln->tn_type;
595 		if (!mp->m_binary && rn != NULL)
596 			LERROR("build()");
597 		ntn = mktnode(op, rtp, ln, rn);
598 		break;
599 	}
600 
601 	/* Return if an error occurred. */
602 	if (ntn == NULL)
603 		return (NULL);
604 
605 	/* Print a warning if precedence confusion is possible */
606 	if (mp->m_tpconf)
607 		precconf(ntn);
608 
609 	/*
610 	 * Print a warning if one of the operands is in a context where
611 	 * it is compared with null and if this operand is a constant.
612 	 */
613 	if (mp->m_tctx) {
614 		if (ln->tn_op == CON ||
615 		    ((mp->m_binary && op != QUEST) && rn->tn_op == CON)) {
616 			if (hflag && !ccflg)
617 				/* constant in conditional context */
618 				warning(161);
619 		}
620 	}
621 
622 	/* Fold if the operator requires it */
623 	if (mp->m_fold) {
624 		if (ln->tn_op == CON && (!mp->m_binary || rn->tn_op == CON)) {
625 			if (mp->m_tctx) {
626 				ntn = foldtst(ntn);
627 			} else if (isftyp(ntn->tn_type->t_tspec)) {
628 				ntn = foldflt(ntn);
629 			} else {
630 				ntn = fold(ntn);
631 			}
632 		} else if (op == QUEST && ln->tn_op == CON) {
633 			ntn = ln->tn_val->v_quad ? rn->tn_left : rn->tn_right;
634 		}
635 	}
636 
637 	return (ntn);
638 }
639 
640 /*
641  * Perform class conversions.
642  *
643  * Arrays of type T are converted into pointers to type T.
644  * Functions are converted to pointers to functions.
645  * Lvalues are converted to rvalues.
646  */
647 tnode_t *
648 cconv(tnode_t *tn)
649 {
650 	type_t	*tp;
651 
652 	/*
653 	 * Array-lvalue (array of type T) is converted into rvalue
654 	 * (pointer to type T)
655 	 */
656 	if (tn->tn_type->t_tspec == ARRAY) {
657 		if (!tn->tn_lvalue) {
658 			/* %soperand of '%s' must be lvalue */
659 			/* XXX print correct operator */
660 			(void)gnuism(114, "", modtab[AMPER].m_name);
661 		}
662 		tn = mktnode(AMPER, tincref(tn->tn_type->t_subt, PTR),
663 			     tn, NULL);
664 	}
665 
666 	/*
667 	 * Expression of type function (function with return value of type T)
668 	 * in rvalue-expression (pointer to function with return value
669 	 * of type T)
670 	 */
671 	if (tn->tn_type->t_tspec == FUNC)
672 		tn = bldamper(tn, 1);
673 
674 	/* lvalue to rvalue */
675 	if (tn->tn_lvalue) {
676 		tp = tduptyp(tn->tn_type);
677 		tp->t_const = tp->t_volatile = 0;
678 		tn = mktnode(LOAD, tp, tn, NULL);
679 	}
680 
681 	return (tn);
682 }
683 
684 /*
685  * Perform most type checks. First the types are checked using
686  * informations from modtab[]. After that it is done by hand for
687  * more complicated operators and type combinations.
688  *
689  * If the types are ok, typeok() returns 1, otherwise 0.
690  */
691 int
692 typeok(op_t op, int arg, tnode_t *ln, tnode_t *rn)
693 {
694 	mod_t	*mp;
695 	tspec_t	lt, rt = NOTSPEC, lst = NOTSPEC, rst = NOTSPEC, olt = NOTSPEC,
696 	    ort = NOTSPEC;
697 	type_t	*ltp, *rtp = NULL, *lstp = NULL, *rstp = NULL;
698 	char lbuf[128], rbuf[128];
699 	tnode_t	*tn;
700 
701 	mp = &modtab[op];
702 
703 	if ((ltp = ln->tn_type) == NULL)
704 		LERROR("typeok()");
705 
706 	if ((lt = ltp->t_tspec) == PTR)
707 		lst = (lstp = ltp->t_subt)->t_tspec;
708 	if (mp->m_binary) {
709 		if ((rtp = rn->tn_type) == NULL)
710 			LERROR("typeok()");
711 		if ((rt = rtp->t_tspec) == PTR)
712 			rst = (rstp = rtp->t_subt)->t_tspec;
713 	}
714 
715 	if (mp->m_rqint) {
716 		/* integertypes required */
717 		if (!isityp(lt) || (mp->m_binary && !isityp(rt))) {
718 			incompat(op, lt, rt);
719 			return (0);
720 		}
721 	} else if (mp->m_rqintcomp) {
722 		/* integertypes required */
723 		if ((!isityp(lt) && !isctyp(lt)) ||
724 		    (mp->m_binary && (!isityp(rt) && !isctyp(rt)))) {
725 			incompat(op, lt, rt);
726 			return (0);
727 		}
728 	} else if (mp->m_rqsclt) {
729 		/* scalar types required */
730 		if (!issclt(lt) || (mp->m_binary && !issclt(rt))) {
731 			incompat(op, lt, rt);
732 			return (0);
733 		}
734 	} else if (mp->m_rqatyp) {
735 		/* arithmetic types required */
736 		if (!isatyp(lt) || (mp->m_binary && !isatyp(rt))) {
737 			incompat(op, lt, rt);
738 			return (0);
739 		}
740 	}
741 
742 	if (op == SHL || op == SHR || op == SHLASS || op == SHRASS) {
743 		/*
744 		 * For these operations we need the types before promotion
745 		 * and balancing.
746 		 */
747 		for (tn=ln; tn->tn_op==CVT && !tn->tn_cast; tn=tn->tn_left)
748 			continue;
749 		olt = tn->tn_type->t_tspec;
750 		for (tn=rn; tn->tn_op==CVT && !tn->tn_cast; tn=tn->tn_left)
751 			continue;
752 		ort = tn->tn_type->t_tspec;
753 	}
754 
755 	switch (op) {
756 	case POINT:
757 		/*
758 		 * Most errors required by ANSI C are reported in strmemb().
759 		 * Here we only must check for totaly wrong things.
760 		 */
761 		if (lt == FUNC || lt == VOID || ltp->t_isfield ||
762 		    ((lt != STRUCT && lt != UNION) && !ln->tn_lvalue)) {
763 			/* Without tflag we got already an error */
764 			if (tflag)
765 				/* unacceptable operand of %s */
766 				error(111, mp->m_name);
767 			return (0);
768 		}
769 		/* Now we have an object we can create a pointer to */
770 		break;
771 	case ARROW:
772 		if (lt != PTR && !(tflag && isityp(lt))) {
773 			/* Without tflag we got already an error */
774 			if (tflag)
775 				/* unacceptabel operand of %s */
776 				error(111, mp->m_name);
777 			return (0);
778 		}
779 		break;
780 	case INCAFT:
781 	case DECAFT:
782 	case INCBEF:
783 	case DECBEF:
784 		/* operands have scalar types (checked above) */
785 		if (!ln->tn_lvalue) {
786 			if (ln->tn_op == CVT && ln->tn_cast &&
787 			    ln->tn_left->tn_op == LOAD) {
788 				/* a cast to non-ptr does not yield an lvalue */
789 				if (ln->tn_type->t_tspec == PTR)
790 					break;
791 				error(163);
792 			}
793 			/* %soperand of %s must be lvalue */
794 			error(114, "", mp->m_name);
795 			return (0);
796 		} else if (ltp->t_const) {
797 			/* %soperand of %s must be modifiable lvalue */
798 			if (!tflag)
799 				warning(115, "", mp->m_name);
800 		}
801 		break;
802 	case AMPER:
803 		if (lt == ARRAY || lt == FUNC) {
804 			/* ok, a warning comes later (in bldamper()) */
805 		} else if (!ln->tn_lvalue) {
806 			if (ln->tn_op == CVT && ln->tn_cast &&
807 			    ln->tn_left->tn_op == LOAD) {
808 				/* a cast to non-ptr does not yield an lvalue */
809 				if (ln->tn_type->t_tspec == PTR)
810 					break;
811 				error(163);
812 			}
813 			/* %soperand of %s must be lvalue */
814 			error(114, "", mp->m_name);
815 			return (0);
816 		} else if (issclt(lt)) {
817 			if (ltp->t_isfield) {
818 				/* cannot take address of bit-field */
819 				error(112);
820 				return (0);
821 			}
822 		} else if (lt != STRUCT && lt != UNION) {
823 			/* unacceptable operand of %s */
824 			error(111, mp->m_name);
825 			return (0);
826 		}
827 		if (ln->tn_op == NAME && ln->tn_sym->s_reg) {
828 			/* cannot take address of register %s */
829 			error(113, ln->tn_sym->s_name);
830 			return (0);
831 		}
832 		break;
833 	case STAR:
834 		/* until now there were no type checks for this operator */
835 		if (lt != PTR) {
836 			/* cannot dereference non-pointer type */
837 			error(96);
838 			return (0);
839 		}
840 		break;
841 	case PLUS:
842 		/* operands have scalar types (checked above) */
843 		if ((lt == PTR && !isityp(rt)) || (rt == PTR && !isityp(lt))) {
844 			incompat(op, lt, rt);
845 			return (0);
846 		}
847 		break;
848 	case MINUS:
849 		/* operands have scalar types (checked above) */
850 		if (lt == PTR && (!isityp(rt) && rt != PTR)) {
851 			incompat(op, lt, rt);
852 			return (0);
853 		} else if (rt == PTR && lt != PTR) {
854 			incompat(op, lt, rt);
855 			return (0);
856 		}
857 		if (lt == PTR && rt == PTR) {
858 			if (!eqtype(lstp, rstp, 1, 0, NULL)) {
859 				/* illegal pointer subtraction */
860 				error(116);
861 			}
862 		}
863 		break;
864 	case SHR:
865 		/* operands have integer types (checked above) */
866 		if (pflag && !isutyp(lt)) {
867 			/*
868 			 * The left operand is signed. This means that
869 			 * the operation is (possibly) nonportable.
870 			 */
871 			/* bitwise operation on signed value nonportable */
872 			if (ln->tn_op != CON) {
873 				/* possibly nonportable */
874 				warning(117);
875 			} else if (ln->tn_val->v_quad < 0) {
876 				warning(120);
877 			}
878 		} else if (!tflag && !sflag && !isutyp(olt) && isutyp(ort)) {
879 			/*
880 			 * The left operand would become unsigned in
881 			 * traditional C.
882 			 */
883 			if (hflag &&
884 			    (ln->tn_op != CON || ln->tn_val->v_quad < 0)) {
885 				/* semantics of %s change in ANSI C; use ... */
886 				warning(118, mp->m_name);
887 			}
888 		} else if (!tflag && !sflag && !isutyp(olt) && !isutyp(ort) &&
889 			   psize(lt) < psize(rt)) {
890 			/*
891 			 * In traditional C the left operand would be extended,
892 			 * possibly with 1, and then shifted.
893 			 */
894 			if (hflag &&
895 			    (ln->tn_op != CON || ln->tn_val->v_quad < 0)) {
896 				/* semantics of %s change in ANSI C; use ... */
897 				warning(118, mp->m_name);
898 			}
899 		}
900 		goto shift;
901 	case SHL:
902 		/*
903 		 * ANSI C does not perform balancing for shift operations,
904 		 * but traditional C does. If the width of the right operand
905 		 * is greather than the width of the left operand, than in
906 		 * traditional C the left operand would be extendet to the
907 		 * width of the right operand. For SHL this may result in
908 		 * different results.
909 		 */
910 		if (psize(lt) < psize(rt)) {
911 			/*
912 			 * XXX If both operands are constant make sure
913 			 * that there is really a differencs between
914 			 * ANSI C and traditional C.
915 			 */
916 			if (hflag)
917 				/* semantics of %s change in ANSI C; use ... */
918 				warning(118, mp->m_name);
919 		}
920 	shift:
921 		if (rn->tn_op == CON) {
922 			if (!isutyp(rt) && rn->tn_val->v_quad < 0) {
923 				/* negative shift */
924 				warning(121);
925 			} else if ((uint64_t)rn->tn_val->v_quad == (uint64_t)size(lt)) {
926 				/* shift equal to size fo object */
927 				warning(267);
928 			} else if ((uint64_t)rn->tn_val->v_quad > (uint64_t)size(lt)) {
929 				/* shift greater than size of object */
930 				warning(122);
931 			}
932 		}
933 		break;
934 	case EQ:
935 	case NE:
936 		/*
937 		 * Accept some things which are allowed with EQ and NE,
938 		 * but not with ordered comparisons.
939 		 */
940 		if (lt == PTR && ((rt == PTR && rst == VOID) || isityp(rt))) {
941 			if (rn->tn_op == CON && rn->tn_val->v_quad == 0)
942 				break;
943 		}
944 		if (rt == PTR && ((lt == PTR && lst == VOID) || isityp(lt))) {
945 			if (ln->tn_op == CON && ln->tn_val->v_quad == 0)
946 				break;
947 		}
948 		/* FALLTHROUGH */
949 	case LT:
950 	case GT:
951 	case LE:
952 	case GE:
953 		if ((lt == PTR || rt == PTR) && lt != rt) {
954 			if (isityp(lt) || isityp(rt)) {
955 				const char *lx = lt == PTR ?
956 				    "pointer" : "integer";
957 				const char *rx = rt == PTR ?
958 				    "pointer" : "integer";
959 				tyname(lbuf, sizeof(lbuf), ltp);
960 				tyname(rbuf, sizeof(rbuf), rtp);
961 				/* illegal comb. of pointer and int., op %s */
962 				warning(123, lx, lbuf, rx, rbuf, mp->m_name);
963 			} else {
964 				incompat(op, lt, rt);
965 				return (0);
966 			}
967 		} else if (lt == PTR && rt == PTR) {
968 			ptrcmpok(op, ln, rn);
969 		}
970 		break;
971 	case QUEST:
972 		if (!issclt(lt)) {
973 			/* first operand must have scalar type, op ? : */
974 			error(170);
975 			return (0);
976 		}
977 		while (rn->tn_op == CVT)
978 			rn = rn->tn_left;
979 		if (rn->tn_op != COLON)
980 			LERROR("typeok()");
981 		break;
982 	case COLON:
983 
984 		if (isatyp(lt) && isatyp(rt))
985 			break;
986 
987 		if (lt == STRUCT && rt == STRUCT && ltp->t_str == rtp->t_str)
988 			break;
989 		if (lt == UNION && rt == UNION && ltp->t_str == rtp->t_str)
990 			break;
991 
992 		/* combination of any pointer and 0, 0L or (void *)0 is ok */
993 		if (lt == PTR && ((rt == PTR && rst == VOID) || isityp(rt))) {
994 			if (rn->tn_op == CON && rn->tn_val->v_quad == 0)
995 				break;
996 		}
997 		if (rt == PTR && ((lt == PTR && lst == VOID) || isityp(lt))) {
998 			if (ln->tn_op == CON && ln->tn_val->v_quad == 0)
999 				break;
1000 		}
1001 
1002 		if ((lt == PTR && isityp(rt)) || (isityp(lt) && rt == PTR)) {
1003 			const char *lx = lt == PTR ?  "pointer" : "integer";
1004 			const char *rx = rt == PTR ?  "pointer" : "integer";
1005 			tyname(lbuf, sizeof(lbuf), ltp);
1006 			tyname(rbuf, sizeof(rbuf), rtp);
1007 			/* illegal comb. of ptr. and int., op %s */
1008 			warning(123, lx, lbuf, rx, rbuf, mp->m_name);
1009 			break;
1010 		}
1011 
1012 		if (lt == VOID || rt == VOID) {
1013 			if (lt != VOID || rt != VOID)
1014 				/* incompatible types in conditional */
1015 				warning(126);
1016 			break;
1017 		}
1018 
1019 		if (lt == PTR && rt == PTR && ((lst == VOID && rst == FUNC) ||
1020 					       (lst == FUNC && rst == VOID))) {
1021 			/* (void *)0 handled above */
1022 			if (sflag)
1023 				/* ANSI C forbids conv. of %s to %s, op %s */
1024 				warning(305, "function pointer", "'void *'",
1025 					mp->m_name);
1026 			break;
1027 		}
1028 
1029 		if (rt == PTR && lt == PTR) {
1030 			if (eqptrtype(lstp, rstp, 1))
1031 				break;
1032 			if (!eqtype(lstp, rstp, 1, 0, NULL))
1033 				illptrc(mp, ltp, rtp);
1034 			break;
1035 		}
1036 
1037 		/* incompatible types in conditional */
1038 		error(126);
1039 		return (0);
1040 
1041 	case ASSIGN:
1042 	case INIT:
1043 	case FARG:
1044 	case RETURN:
1045 		if (!asgntypok(op, arg, ln, rn))
1046 			return (0);
1047 		goto assign;
1048 	case MULASS:
1049 	case DIVASS:
1050 	case MODASS:
1051 		goto assign;
1052 	case ADDASS:
1053 	case SUBASS:
1054 		/* operands have scalar types (checked above) */
1055 		if ((lt == PTR && !isityp(rt)) || rt == PTR) {
1056 			incompat(op, lt, rt);
1057 			return (0);
1058 		}
1059 		goto assign;
1060 	case SHLASS:
1061 		goto assign;
1062 	case SHRASS:
1063 		if (pflag && !isutyp(lt) && !(tflag && isutyp(rt))) {
1064 			/* bitwise operation on s.v. possibly nonportable */
1065 			warning(117);
1066 		}
1067 		goto assign;
1068 	case ANDASS:
1069 	case XORASS:
1070 	case ORASS:
1071 		goto assign;
1072 	assign:
1073 		if (!ln->tn_lvalue) {
1074 			if (ln->tn_op == CVT && ln->tn_cast &&
1075 			    ln->tn_left->tn_op == LOAD) {
1076 				/* a cast to non-ptr does not yield an lvalue */
1077 				if (ln->tn_type->t_tspec == PTR)
1078 					break;
1079 				error(163);
1080 			}
1081 			/* %soperand of %s must be lvalue */
1082 			error(114, "left ", mp->m_name);
1083 			return (0);
1084 		} else if (ltp->t_const || ((lt == STRUCT || lt == UNION) &&
1085 					    conmemb(ltp))) {
1086 			/* %soperand of %s must be modifiable lvalue */
1087 			if (!tflag)
1088 				warning(115, "left ", mp->m_name);
1089 		}
1090 		break;
1091 	case COMMA:
1092 		if (!modtab[ln->tn_op].m_sideeff)
1093 			nulleff(ln);
1094 		break;
1095 		/* LINTED206: (enumeration values not handled in switch) */
1096 	case CON:
1097 	case CASE:
1098 	case PUSH:
1099 	case LOAD:
1100 	case ICALL:
1101 	case CVT:
1102 	case CALL:
1103 	case FSEL:
1104 	case STRING:
1105 	case NAME:
1106 	case LOGOR:
1107 	case LOGAND:
1108 	case OR:
1109 	case XOR:
1110 	case AND:
1111 	case MOD:
1112 	case DIV:
1113 	case MULT:
1114 	case UMINUS:
1115 	case UPLUS:
1116 	case DEC:
1117 	case INC:
1118 	case COMPL:
1119 	case NOT:
1120 	case NOOP:
1121 	case REAL:
1122 	case IMAG:
1123 		break;
1124 	}
1125 
1126 	if (mp->m_badeop &&
1127 	    (ltp->t_isenum || (mp->m_binary && rtp->t_isenum))) {
1128 		chkbeop(op, ln, rn);
1129 	} else if (mp->m_enumop && (ltp->t_isenum && rtp && rtp->t_isenum)) {
1130 		chkeop2(op, arg, ln, rn);
1131 	} else if (mp->m_enumop && (ltp->t_isenum || (rtp && rtp->t_isenum))) {
1132 		chkeop1(op, arg, ln, rn);
1133 	}
1134 
1135 	return (1);
1136 }
1137 
1138 static void
1139 ptrcmpok(op_t op, tnode_t *ln, tnode_t *rn)
1140 {
1141 	type_t	*ltp, *rtp;
1142 	tspec_t	lt, rt;
1143 	const	char *lts, *rts;
1144 
1145 	lt = (ltp = ln->tn_type)->t_subt->t_tspec;
1146 	rt = (rtp = rn->tn_type)->t_subt->t_tspec;
1147 
1148 	if (lt == VOID || rt == VOID) {
1149 		if (sflag && (lt == FUNC || rt == FUNC)) {
1150 			/* (void *)0 already handled in typeok() */
1151 			*(lt == FUNC ? &lts : &rts) = "function pointer";
1152 			*(lt == VOID ? &lts : &rts) = "'void *'";
1153 			/* ANSI C forbids comparison of %s with %s */
1154 			warning(274, lts, rts);
1155 		}
1156 		return;
1157 	}
1158 
1159 	if (!eqtype(ltp->t_subt, rtp->t_subt, 1, 0, NULL)) {
1160 		illptrc(&modtab[op], ltp, rtp);
1161 		return;
1162 	}
1163 
1164 	if (lt == FUNC && rt == FUNC) {
1165 		if (sflag && op != EQ && op != NE)
1166 			/* ANSI C forbids ordered comp. of func ptr */
1167 			warning(125);
1168 	}
1169 }
1170 
1171 /*
1172  * Checks type compatibility for ASSIGN, INIT, FARG and RETURN
1173  * and prints warnings/errors if necessary.
1174  * If the types are (almost) compatible, 1 is returned, otherwise 0.
1175  */
1176 static int
1177 asgntypok(op_t op, int arg, tnode_t *ln, tnode_t *rn)
1178 {
1179 	tspec_t	lt, rt, lst = NOTSPEC, rst = NOTSPEC;
1180 	type_t	*ltp, *rtp, *lstp = NULL, *rstp = NULL;
1181 	mod_t	*mp;
1182 	const	char *lts, *rts;
1183 	char lbuf[128], rbuf[128];
1184 
1185 	if ((lt = (ltp = ln->tn_type)->t_tspec) == PTR)
1186 		lst = (lstp = ltp->t_subt)->t_tspec;
1187 	if ((rt = (rtp = rn->tn_type)->t_tspec) == PTR)
1188 		rst = (rstp = rtp->t_subt)->t_tspec;
1189 	mp = &modtab[op];
1190 
1191 	if (isatyp(lt) && isatyp(rt))
1192 		return (1);
1193 
1194 	if ((lt == STRUCT || lt == UNION) && (rt == STRUCT || rt == UNION))
1195 		/* both are struct or union */
1196 		return (ltp->t_str == rtp->t_str);
1197 
1198 	/* 0, 0L and (void *)0 may be assigned to any pointer */
1199 	if (lt == PTR && ((rt == PTR && rst == VOID) || isityp(rt))) {
1200 		if (rn->tn_op == CON && rn->tn_val->v_quad == 0)
1201 			return (1);
1202 	}
1203 
1204 	if (lt == PTR && rt == PTR && (lst == VOID || rst == VOID)) {
1205 		/* two pointers, at least one pointer to void */
1206 		if (sflag && (lst == FUNC || rst == FUNC)) {
1207 			/* comb. of ptr to func and ptr to void */
1208 			*(lst == FUNC ? &lts : &rts) = "function pointer";
1209 			*(lst == VOID ? &lts : &rts) = "'void *'";
1210 			switch (op) {
1211 			case INIT:
1212 			case RETURN:
1213 				/* ANSI C forbids conversion of %s to %s */
1214 				warning(303, rts, lts);
1215 				break;
1216 			case FARG:
1217 				/* ANSI C forbids conv. of %s to %s, arg #%d */
1218 				warning(304, rts, lts, arg);
1219 				break;
1220 			default:
1221 				/* ANSI C forbids conv. of %s to %s, op %s */
1222 				warning(305, rts, lts, mp->m_name);
1223 				break;
1224 			}
1225 		}
1226 	}
1227 
1228 	if (lt == PTR && rt == PTR && (lst == VOID || rst == VOID ||
1229 				       eqtype(lstp, rstp, 1, 0, NULL))) {
1230 		/* compatible pointer types (qualifiers ignored) */
1231 		if (!tflag &&
1232 		    ((!lstp->t_const && rstp->t_const) ||
1233 		     (!lstp->t_volatile && rstp->t_volatile))) {
1234 			/* left side has not all qualifiers of right */
1235 			tyname(lbuf, sizeof(lbuf), lstp);
1236 			tyname(rbuf, sizeof(rbuf), rstp);
1237 			switch (op) {
1238 			case INIT:
1239 			case RETURN:
1240 				/* incompatible pointer types */
1241 				warning(182, lbuf, rbuf);
1242 				break;
1243 			case FARG:
1244 				/* argument has incompat. ptr. type, arg #%d */
1245 				warning(153, arg, lbuf, rbuf);
1246 				break;
1247 			default:
1248 				/* operands have incompat. ptr. types, op %s */
1249 				warning(128, mp->m_name, lbuf, rbuf);
1250 				break;
1251 			}
1252 		}
1253 		return (1);
1254 	}
1255 
1256 	if ((lt == PTR && isityp(rt)) || (isityp(lt) && rt == PTR)) {
1257 		const char *lx = lt == PTR ? "pointer" : "integer";
1258 		const char *rx = rt == PTR ? "pointer" : "integer";
1259 		tyname(lbuf, sizeof(lbuf), ltp);
1260 		tyname(rbuf, sizeof(rbuf), rtp);
1261 
1262 		switch (op) {
1263 		case INIT:
1264 		case RETURN:
1265 			/* illegal combination of pointer and integer */
1266 			warning(183, lx, lbuf, rx, rbuf);
1267 			break;
1268 		case FARG:
1269 			/* illegal comb. of ptr. and int., arg #%d */
1270 			warning(154, lx, lbuf, rx, rbuf, arg);
1271 			break;
1272 		default:
1273 			/* illegal comb. of ptr. and int., op %s */
1274 			warning(123, lx, lbuf, rx, rbuf, mp->m_name);
1275 			break;
1276 		}
1277 		return (1);
1278 	}
1279 
1280 	if (lt == PTR && rt == PTR) {
1281 		switch (op) {
1282 		case INIT:
1283 		case RETURN:
1284 			illptrc(NULL, ltp, rtp);
1285 			break;
1286 		case FARG:
1287 			/* argument has incompatible pointer type, arg #%d */
1288 			warning(153, arg, tyname(lbuf, sizeof(lbuf), ltp),
1289 			    tyname(rbuf, sizeof(rbuf), rtp));
1290 			break;
1291 		default:
1292 			illptrc(mp, ltp, rtp);
1293 			break;
1294 		}
1295 		return (1);
1296 	}
1297 
1298 	switch (op) {
1299 	case INIT:
1300 		/* initialisation type mismatch */
1301 		error(185);
1302 		break;
1303 	case RETURN:
1304 		/* return value type mismatch */
1305 		error(211);
1306 		break;
1307 	case FARG:
1308 		/* argument is incompatible with prototype, arg #%d */
1309 		warning(155, arg);
1310 		break;
1311 	default:
1312 		incompat(op, lt, rt);
1313 		break;
1314 	}
1315 
1316 	return (0);
1317 }
1318 
1319 /*
1320  * Prints a warning if an operator, which should be senseless for an
1321  * enum type, is applied to an enum type.
1322  */
1323 static void
1324 chkbeop(op_t op, tnode_t *ln, tnode_t *rn)
1325 {
1326 	mod_t	*mp;
1327 
1328 	if (!eflag)
1329 		return;
1330 
1331 	mp = &modtab[op];
1332 
1333 	if (!(ln->tn_type->t_isenum ||
1334 	      (mp->m_binary && rn->tn_type->t_isenum))) {
1335 		return;
1336 	}
1337 
1338 	/*
1339 	 * Enum as offset to a pointer is an exception (otherwise enums
1340 	 * could not be used as array indizes).
1341 	 */
1342 	if (op == PLUS &&
1343 	    ((ln->tn_type->t_isenum && rn->tn_type->t_tspec == PTR) ||
1344 	     (rn->tn_type->t_isenum && ln->tn_type->t_tspec == PTR))) {
1345 		return;
1346 	}
1347 
1348 	/* dubious operation on enum, op %s */
1349 	warning(241, mp->m_name);
1350 
1351 }
1352 
1353 /*
1354  * Prints a warning if an operator is applied to two different enum types.
1355  */
1356 static void
1357 chkeop2(op_t op, int arg, tnode_t *ln, tnode_t *rn)
1358 {
1359 	mod_t	*mp;
1360 
1361 	mp = &modtab[op];
1362 
1363 	if (ln->tn_type->t_enum != rn->tn_type->t_enum) {
1364 		switch (op) {
1365 		case INIT:
1366 			/* enum type mismatch in initialisation */
1367 			warning(210);
1368 			break;
1369 		case FARG:
1370 			/* enum type mismatch, arg #%d */
1371 			warning(156, arg);
1372 			break;
1373 		case RETURN:
1374 			/* return value type mismatch */
1375 			warning(211);
1376 			break;
1377 		default:
1378 			/* enum type mismatch, op %s */
1379 			warning(130, mp->m_name);
1380 			break;
1381 		}
1382 	} else if (Pflag && mp->m_comp && op != EQ && op != NE) {
1383 		if (eflag)
1384 			/* dubious comparisons of enums */
1385 			warning(243, mp->m_name);
1386 	}
1387 }
1388 
1389 /*
1390  * Prints a warning if an operator has both enum end other integer
1391  * types.
1392  */
1393 static void
1394 chkeop1(op_t op, int arg, tnode_t *ln, tnode_t *rn)
1395 {
1396 	char lbuf[64], rbuf[64];
1397 
1398 	if (!eflag)
1399 		return;
1400 
1401 	switch (op) {
1402 	case INIT:
1403 		/*
1404 		 * Initializations with 0 should be allowed. Otherwise,
1405 		 * we should complain about all uninitialized enums,
1406 		 * consequently.
1407 		 */
1408 		if (!rn->tn_type->t_isenum && rn->tn_op == CON &&
1409 		    isityp(rn->tn_type->t_tspec) && rn->tn_val->v_quad == 0) {
1410 			return;
1411 		}
1412 		/* initialisation of '%s' with '%s' */
1413 		warning(277, tyname(lbuf, sizeof(lbuf), ln->tn_type),
1414 		    tyname(rbuf, sizeof(rbuf), rn->tn_type));
1415 		break;
1416 	case FARG:
1417 		/* combination of '%s' and '%s', arg #%d */
1418 		warning(278, tyname(lbuf, sizeof(lbuf), ln->tn_type),
1419 		    tyname(rbuf, sizeof(rbuf), rn->tn_type), arg);
1420 		break;
1421 	case RETURN:
1422 		/* combination of '%s' and '%s' in return */
1423 		warning(279, tyname(lbuf, sizeof(lbuf), ln->tn_type),
1424 		    tyname(rbuf, sizeof(rbuf), rn->tn_type));
1425 		break;
1426 	default:
1427 		/* combination of '%s' and %s, op %s */
1428 		warning(242, tyname(lbuf, sizeof(lbuf), ln->tn_type),
1429 		    tyname(rbuf, sizeof(rbuf), rn->tn_type),
1430 		    modtab[op].m_name);
1431 		break;
1432 	}
1433 }
1434 
1435 /*
1436  * Build and initialize a new node.
1437  */
1438 static tnode_t *
1439 mktnode(op_t op, type_t *type, tnode_t *ln, tnode_t *rn)
1440 {
1441 	tnode_t	*ntn;
1442 	tspec_t	t;
1443 #ifdef notyet
1444 	size_t l;
1445 	uint64_t rnum;
1446 #endif
1447 
1448 	ntn = getnode();
1449 
1450 	ntn->tn_op = op;
1451 	ntn->tn_type = type;
1452 	ntn->tn_left = ln;
1453 	ntn->tn_right = rn;
1454 
1455 	switch (op) {
1456 #ifdef notyet
1457 	case SHR:
1458 		if (rn->tn_op != CON)
1459 			break;
1460 		rnum = rn->tn_val->v_quad;
1461 		l = tsize(ln->tn_type) / CHAR_BIT;
1462 		t = ln->tn_type->t_tspec;
1463 		switch (l) {
1464 		case 8:
1465 			if (rnum >= 56)
1466 				t = UCHAR;
1467 			else if (rnum >= 48)
1468 				t = USHORT;
1469 			else if (rnum >= 32)
1470 				t = UINT;
1471 			break;
1472 		case 4:
1473 			if (rnum >= 24)
1474 				t = UCHAR;
1475 			else if (rnum >= 16)
1476 				t = USHORT;
1477 			break;
1478 		case 2:
1479 			if (rnum >= 8)
1480 				t = UCHAR;
1481 			break;
1482 		default:
1483 			break;
1484 		}
1485 		if (t != ln->tn_type->t_tspec)
1486 			ntn->tn_type->t_tspec = t;
1487 		break;
1488 #endif
1489 	case STAR:
1490 	case FSEL:
1491 		if (ln->tn_type->t_tspec == PTR) {
1492 			t = ln->tn_type->t_subt->t_tspec;
1493 			if (t != FUNC && t != VOID)
1494 				ntn->tn_lvalue = 1;
1495 		} else {
1496 			LERROR("mktnode()");
1497 		}
1498 		break;
1499 	default:
1500 		break;
1501 	}
1502 
1503 	return ntn;
1504 }
1505 
1506 /*
1507  * Performs usual conversion of operands to (unsigned) int.
1508  *
1509  * If tflag is set or the operand is a function argument with no
1510  * type information (no prototype or variable # of args), convert
1511  * float to double.
1512  */
1513 tnode_t *
1514 promote(op_t op, int farg, tnode_t *tn)
1515 {
1516 	tspec_t	t;
1517 	type_t	*ntp;
1518 	u_int	len;
1519 
1520 	t = tn->tn_type->t_tspec;
1521 
1522 	if (!isatyp(t))
1523 		return (tn);
1524 
1525 	if (!tflag) {
1526 		/*
1527 		 * ANSI C requires that the result is always of type INT
1528 		 * if INT can represent all possible values of the previous
1529 		 * type.
1530 		 */
1531 		if (tn->tn_type->t_isfield) {
1532 			len = tn->tn_type->t_flen;
1533 			if (size(INT) > len) {
1534 				t = INT;
1535 			} else {
1536 				if (size(INT) != len)
1537 					LERROR("promote()");
1538 				if (isutyp(t)) {
1539 					t = UINT;
1540 				} else {
1541 					t = INT;
1542 				}
1543 			}
1544 		} else if (t == CHAR || t == UCHAR || t == SCHAR) {
1545 			t = (size(CHAR) < size(INT) || t != UCHAR) ?
1546 				INT : UINT;
1547 		} else if (t == SHORT || t == USHORT) {
1548 			t = (size(SHORT) < size(INT) || t == SHORT) ?
1549 				INT : UINT;
1550 		} else if (t == ENUM) {
1551 			t = INT;
1552 		} else if (farg && t == FLOAT) {
1553 			t = DOUBLE;
1554 		}
1555 	} else {
1556 		/*
1557 		 * In traditional C, keep unsigned and promote FLOAT
1558 		 * to DOUBLE.
1559 		 */
1560 		if (t == UCHAR || t == USHORT) {
1561 			t = UINT;
1562 		} else if (t == CHAR || t == SCHAR || t == SHORT) {
1563 			t = INT;
1564 		} else if (t == FLOAT) {
1565 			t = DOUBLE;
1566 		} else if (t == ENUM) {
1567 			t = INT;
1568 		}
1569 	}
1570 
1571 	if (t != tn->tn_type->t_tspec) {
1572 		ntp = tduptyp(tn->tn_type);
1573 		ntp->t_tspec = t;
1574 		/*
1575 		 * Keep t_isenum so we are later able to check compatibility
1576 		 * of enum types.
1577 		 */
1578 		tn = convert(op, 0, ntp, tn);
1579 	}
1580 
1581 	return (tn);
1582 }
1583 
1584 /*
1585  * Insert conversions which are necessary to give both operands the same
1586  * type. This is done in different ways for traditional C and ANIS C.
1587  */
1588 static void
1589 balance(op_t op, tnode_t **lnp, tnode_t **rnp)
1590 {
1591 	tspec_t	lt, rt, t;
1592 	int	i, u;
1593 	type_t	*ntp;
1594 	static	tspec_t	tl[] = {
1595 		LDOUBLE, DOUBLE, FLOAT, UQUAD, QUAD, ULONG, LONG, UINT, INT,
1596 	};
1597 
1598 	lt = (*lnp)->tn_type->t_tspec;
1599 	rt = (*rnp)->tn_type->t_tspec;
1600 
1601 	if (!isatyp(lt) || !isatyp(rt))
1602 		return;
1603 
1604 	if (!tflag) {
1605 		if (lt == rt) {
1606 			t = lt;
1607 		} else if (lt == LCOMPLEX || rt == LCOMPLEX) {
1608 			t = LCOMPLEX;
1609 		} else if (lt == DCOMPLEX || rt == DCOMPLEX) {
1610 			t = DCOMPLEX;
1611 		} else if (lt == COMPLEX || rt == COMPLEX) {
1612 			t = COMPLEX;
1613 		} else if (lt == FCOMPLEX || rt == FCOMPLEX) {
1614 			t = FCOMPLEX;
1615 		} else if (lt == LDOUBLE || rt == LDOUBLE) {
1616 			t = LDOUBLE;
1617 		} else if (lt == DOUBLE || rt == DOUBLE) {
1618 			t = DOUBLE;
1619 		} else if (lt == FLOAT || rt == FLOAT) {
1620 			t = FLOAT;
1621 		} else {
1622 			/*
1623 			 * If type A has more bits than type B it should
1624 			 * be able to hold all possible values of type B.
1625 			 */
1626 			if (size(lt) > size(rt)) {
1627 				t = lt;
1628 			} else if (size(lt) < size(rt)) {
1629 				t = rt;
1630 			} else {
1631 				for (i = 3; tl[i] != INT; i++) {
1632 					if (tl[i] == lt || tl[i] == rt)
1633 						break;
1634 				}
1635 				if ((isutyp(lt) || isutyp(rt)) &&
1636 				    !isutyp(tl[i])) {
1637 					i--;
1638 				}
1639 				t = tl[i];
1640 			}
1641 		}
1642 	} else {
1643 		/* Keep unsigned in traditional C */
1644 		u = isutyp(lt) || isutyp(rt);
1645 		for (i = 0; tl[i] != INT; i++) {
1646 			if (lt == tl[i] || rt == tl[i])
1647 				break;
1648 		}
1649 		t = tl[i];
1650 		if (u && isityp(t) && !isutyp(t))
1651 			t = utyp(t);
1652 	}
1653 
1654 	if (t != lt) {
1655 		ntp = tduptyp((*lnp)->tn_type);
1656 		ntp->t_tspec = t;
1657 		*lnp = convert(op, 0, ntp, *lnp);
1658 	}
1659 	if (t != rt) {
1660 		ntp = tduptyp((*rnp)->tn_type);
1661 		ntp->t_tspec = t;
1662 		*rnp = convert(op, 0, ntp, *rnp);
1663 	}
1664 }
1665 
1666 /*
1667  * Insert a conversion operator, which converts the type of the node
1668  * to another given type.
1669  * If op is FARG, arg is the number of the argument (used for warnings).
1670  */
1671 tnode_t *
1672 convert(op_t op, int arg, type_t *tp, tnode_t *tn)
1673 {
1674 	tnode_t	*ntn;
1675 	tspec_t	nt, ot, ost = NOTSPEC;
1676 
1677 	nt = tp->t_tspec;
1678 	if ((ot = tn->tn_type->t_tspec) == PTR)
1679 		ost = tn->tn_type->t_subt->t_tspec;
1680 
1681 	if (!tflag && !sflag && op == FARG)
1682 		ptconv(arg, nt, ot, tp, tn);
1683 	if (isityp(nt) && isityp(ot)) {
1684 		iiconv(op, arg, nt, ot, tp, tn);
1685 	} else if (nt == PTR && ((ot == PTR && ost == VOID) || isityp(ot)) &&
1686 		   tn->tn_op == CON && tn->tn_val->v_quad == 0) {
1687 		/* 0, 0L and (void *)0 may be assigned to any pointer. */
1688 	} else if (isityp(nt) && ot == PTR) {
1689 		piconv(op, nt, tp, tn);
1690 	} else if (nt == PTR && ot == PTR) {
1691 		ppconv(op, tn, tp);
1692 	}
1693 
1694 	ntn = getnode();
1695 	ntn->tn_op = CVT;
1696 	ntn->tn_type = tp;
1697 	ntn->tn_cast = op == CVT;
1698 	ntn->tn_right = NULL;
1699 	if (tn->tn_op != CON || nt == VOID) {
1700 		ntn->tn_left = tn;
1701 	} else {
1702 		ntn->tn_op = CON;
1703 		ntn->tn_val = tgetblk(sizeof (val_t));
1704 		cvtcon(op, arg, ntn->tn_type, ntn->tn_val, tn->tn_val);
1705 	}
1706 
1707 	return (ntn);
1708 }
1709 
1710 /*
1711  * Print a warning if a prototype causes a type conversion that is
1712  * different from what would happen to the same argument in the
1713  * absence of a prototype.
1714  *
1715  * Errors/Warnings about illegal type combinations are already printed
1716  * in asgntypok().
1717  */
1718 static void
1719 ptconv(int arg, tspec_t nt, tspec_t ot, type_t *tp, tnode_t *tn)
1720 {
1721 	tnode_t	*ptn;
1722 	char buf[64];
1723 
1724 	if (!isatyp(nt) || !isatyp(ot))
1725 		return;
1726 
1727 	/*
1728 	 * If the type of the formal parameter is char/short, a warning
1729 	 * would be useless, because functions declared the old style
1730 	 * can't expect char/short arguments.
1731 	 */
1732 	if (nt == CHAR || nt == UCHAR || nt == SHORT || nt == USHORT)
1733 		return;
1734 
1735 	/* get default promotion */
1736 	ptn = promote(NOOP, 1, tn);
1737 	ot = ptn->tn_type->t_tspec;
1738 
1739 	/* return if types are the same with and without prototype */
1740 	if (nt == ot || (nt == ENUM && ot == INT))
1741 		return;
1742 
1743 	if (isftyp(nt) != isftyp(ot) || psize(nt) != psize(ot)) {
1744 		/* representation and/or width change */
1745 		if (!isityp(ot) || psize(ot) > psize(INT)) {
1746 			/* conversion to '%s' due to prototype, arg #%d */
1747 			warning(259, tyname(buf, sizeof(buf), tp), arg);
1748 		}
1749 	} else if (hflag) {
1750 		/*
1751 		 * they differ in sign or base type (char, short, int,
1752 		 * long, long long, float, double, long double)
1753 		 *
1754 		 * if they differ only in sign and the argument is a constant
1755 		 * and the msb of the argument is not set, print no warning
1756 		 */
1757 		if (ptn->tn_op == CON && isityp(nt) && styp(nt) == styp(ot) &&
1758 		    msb(ptn->tn_val->v_quad, ot, -1) == 0) {
1759 			/* ok */
1760 		} else {
1761 			/* conversion to '%s' due to prototype, arg #%d */
1762 			warning(259, tyname(buf, sizeof(buf), tp), arg);
1763 		}
1764 	}
1765 }
1766 
1767 /*
1768  * Print warnings for conversions of integer types which my cause
1769  * problems.
1770  */
1771 /* ARGSUSED */
1772 static void
1773 iiconv(op_t op, int arg, tspec_t nt, tspec_t ot, type_t *tp, tnode_t *tn)
1774 {
1775 	char lbuf[64], rbuf[64], opbuf[16];
1776 	if (tn->tn_op == CON)
1777 		return;
1778 
1779 	if (op == CVT)
1780 		return;
1781 
1782 	if (Pflag && psize(nt) > psize(ot) && isutyp(nt) != isutyp(ot)) {
1783 		/* conversion to %s may sign-extend incorrectly (, arg #%d) */
1784 		if (aflag && pflag) {
1785 			if (op == FARG) {
1786 				warning(297, tyname(lbuf, sizeof(lbuf), tp),
1787 				    arg);
1788 			} else {
1789 				warning(131, tyname(lbuf, sizeof(lbuf), tp));
1790 			}
1791 		}
1792 	}
1793 
1794 	if (Pflag && psize(nt) > psize(ot)) {
1795 		switch (tn->tn_op) {
1796 		case PLUS:
1797 		case MINUS:
1798 		case MULT:
1799 		case SHL:
1800 			warning(324,
1801 			    tyname(rbuf, sizeof(rbuf), gettyp(ot)),
1802 			    tyname(lbuf, sizeof(lbuf), tp),
1803 			    prtnode(opbuf, sizeof(opbuf), tn));
1804 			break;
1805 		default:
1806 			break;
1807 		}
1808 	}
1809 
1810 	if (psize(nt) < psize(ot) &&
1811 	    (ot == LONG || ot == ULONG || ot == QUAD || ot == UQUAD ||
1812 	     aflag > 1)) {
1813 		/* conversion from '%s' may lose accuracy */
1814 		if (aflag) {
1815 			if (op == FARG) {
1816 				warning(298,
1817 				    tyname(rbuf, sizeof(rbuf), tn->tn_type),
1818 				    tyname(lbuf, sizeof(lbuf), tp),
1819 				    arg);
1820 			} else {
1821 				warning(132,
1822 				    tyname(rbuf, sizeof(rbuf), tn->tn_type),
1823 				    tyname(lbuf, sizeof(lbuf), tp));
1824 			}
1825 		}
1826 	}
1827 }
1828 
1829 /*
1830  * Print warnings for dubious conversions of pointer to integer.
1831  */
1832 static void
1833 piconv(op_t op, tspec_t nt, type_t *tp, tnode_t *tn)
1834 {
1835 	char buf[64];
1836 
1837 	if (tn->tn_op == CON)
1838 		return;
1839 
1840 	if (op != CVT) {
1841 		/* We got already an error. */
1842 		return;
1843 	}
1844 
1845 	if (psize(nt) < psize(PTR)) {
1846 		if (pflag && size(nt) >= size(PTR)) {
1847 			/* conv. of pointer to %s may lose bits */
1848 			warning(134, tyname(buf, sizeof(buf), tp));
1849 		} else {
1850 			/* conv. of pointer to %s loses bits */
1851 			warning(133, tyname(buf, sizeof(buf), tp));
1852 		}
1853 	}
1854 }
1855 
1856 /*
1857  * Print warnings for questionable pointer conversions.
1858  */
1859 static void
1860 ppconv(op_t op, tnode_t *tn, type_t *tp)
1861 {
1862 	tspec_t nt, ot;
1863 	const	char *nts, *ots;
1864 
1865 	/*
1866 	 * We got already an error (pointers of different types
1867 	 * without a cast) or we will not get a warning.
1868 	 */
1869 	if (op != CVT)
1870 		return;
1871 
1872 	nt = tp->t_subt->t_tspec;
1873 	ot = tn->tn_type->t_subt->t_tspec;
1874 
1875 	if (nt == VOID || ot == VOID) {
1876 		if (sflag && (nt == FUNC || ot == FUNC)) {
1877 			/* (void *)0 already handled in convert() */
1878 			*(nt == FUNC ? &nts : &ots) = "function pointer";
1879 			*(nt == VOID ? &nts : &ots) = "'void *'";
1880 			/* ANSI C forbids conversion of %s to %s */
1881 			warning(303, ots, nts);
1882 		}
1883 		return;
1884 	} else if (nt == FUNC && ot == FUNC) {
1885 		return;
1886 	} else if (nt == FUNC || ot == FUNC) {
1887 		/* questionable conversion of function pointer */
1888 		warning(229);
1889 		return;
1890 	}
1891 
1892 	if (getbound(tp->t_subt) > getbound(tn->tn_type->t_subt)) {
1893 		if (hflag)
1894 			/* possible pointer alignment problem */
1895 			warning(135);
1896 	}
1897 	if (((nt == STRUCT || nt == UNION) &&
1898 	     tp->t_subt->t_str != tn->tn_type->t_subt->t_str) ||
1899 	    psize(nt) != psize(ot)) {
1900 		if (cflag) {
1901 			/* pointer casts may be troublesome */
1902 			warning(247);
1903 		}
1904 	}
1905 }
1906 
1907 /*
1908  * Converts a typed constant in a constant of another type.
1909  *
1910  * op		operator which requires conversion
1911  * arg		if op is FARG, # of argument
1912  * tp		type in which to convert the constant
1913  * nv		new constant
1914  * v		old constant
1915  */
1916 void
1917 cvtcon(op_t op, int arg, type_t *tp, val_t *nv, val_t *v)
1918 {
1919 	char lbuf[64], rbuf[64];
1920 	tspec_t	ot, nt;
1921 	ldbl_t	max = 0.0, min = 0.0;
1922 	int	sz, rchk;
1923 	int64_t	xmask, xmsk1;
1924 	int	osz, nsz;
1925 
1926 	ot = v->v_tspec;
1927 	nt = nv->v_tspec = tp->t_tspec;
1928 	rchk = 0;
1929 
1930 	if (ot == FLOAT || ot == DOUBLE || ot == LDOUBLE) {
1931 		switch (nt) {
1932 		case BOOL:
1933 			max = 1;		min = 0;		break;
1934 		case CHAR:
1935 			max = TARG_CHAR_MAX;	min = TARG_CHAR_MIN;	break;
1936 		case UCHAR:
1937 			max = TARG_UCHAR_MAX;	min = 0;		break;
1938 		case SCHAR:
1939 			max = TARG_SCHAR_MAX;	min = TARG_SCHAR_MIN;	break;
1940 		case SHORT:
1941 			max = TARG_SHRT_MAX;	min = TARG_SHRT_MIN;	break;
1942 		case USHORT:
1943 			max = TARG_USHRT_MAX;	min = 0;		break;
1944 		case ENUM:
1945 		case INT:
1946 			max = TARG_INT_MAX;	min = TARG_INT_MIN;	break;
1947 		case UINT:
1948 			max = (u_int)TARG_UINT_MAX;min = 0;		break;
1949 		case LONG:
1950 			max = TARG_LONG_MAX;	min = TARG_LONG_MIN;	break;
1951 		case ULONG:
1952 			max = (u_long)TARG_ULONG_MAX; min = 0;		break;
1953 		case QUAD:
1954 			max = QUAD_MAX;		min = QUAD_MIN;		break;
1955 		case UQUAD:
1956 			max = (uint64_t)UQUAD_MAX; min = 0;		break;
1957 		case FLOAT:
1958 		case FCOMPLEX:
1959 			max = FLT_MAX;		min = -FLT_MAX;		break;
1960 		case DOUBLE:
1961 		case DCOMPLEX:
1962 			max = DBL_MAX;		min = -DBL_MAX;		break;
1963 		case PTR:
1964 			/* Got already an error because of float --> ptr */
1965 		case LDOUBLE:
1966 		case LCOMPLEX:
1967 			max = LDBL_MAX;		min = -LDBL_MAX;	break;
1968 		default:
1969 			LERROR("cvtcon()");
1970 		}
1971 		if (v->v_ldbl > max || v->v_ldbl < min) {
1972 			if (nt == LDOUBLE)
1973 				LERROR("cvtcon()");
1974 			if (op == FARG) {
1975 				/* conv. of %s to %s is out of rng., arg #%d */
1976 				warning(295, tyname(lbuf, sizeof(lbuf),
1977 				    gettyp(ot)), tyname(rbuf, sizeof(rbuf), tp),
1978 				    arg);
1979 			} else {
1980 				/* conversion of %s to %s is out of range */
1981 				warning(119, tyname(lbuf, sizeof(lbuf),
1982 				    gettyp(ot)),
1983 				    tyname(rbuf, sizeof(rbuf), tp));
1984 			}
1985 			v->v_ldbl = v->v_ldbl > 0 ? max : min;
1986 		}
1987 		if (nt == FLOAT) {
1988 			nv->v_ldbl = (float)v->v_ldbl;
1989 		} else if (nt == DOUBLE) {
1990 			nv->v_ldbl = (double)v->v_ldbl;
1991 		} else if (nt == LDOUBLE) {
1992 			nv->v_ldbl = v->v_ldbl;
1993 		} else {
1994 			nv->v_quad = (nt == PTR || isutyp(nt)) ?
1995 				(int64_t)v->v_ldbl : (int64_t)v->v_ldbl;
1996 		}
1997 	} else {
1998 		if (nt == FLOAT) {
1999 			nv->v_ldbl = (ot == PTR || isutyp(ot)) ?
2000 			       (float)(uint64_t)v->v_quad : (float)v->v_quad;
2001 		} else if (nt == DOUBLE) {
2002 			nv->v_ldbl = (ot == PTR || isutyp(ot)) ?
2003 			       (double)(uint64_t)v->v_quad : (double)v->v_quad;
2004 		} else if (nt == LDOUBLE) {
2005 			nv->v_ldbl = (ot == PTR || isutyp(ot)) ?
2006 			       (ldbl_t)(uint64_t)v->v_quad : (ldbl_t)v->v_quad;
2007 		} else {
2008 			rchk = 1;		/* Check for lost precision. */
2009 			nv->v_quad = v->v_quad;
2010 		}
2011 	}
2012 
2013 	if (v->v_ansiu && isftyp(nt)) {
2014 		/* ANSI C treats constant as unsigned */
2015 		warning(157);
2016 		v->v_ansiu = 0;
2017 	} else if (v->v_ansiu && (isityp(nt) && !isutyp(nt) &&
2018 				  psize(nt) > psize(ot))) {
2019 		/* ANSI C treats constant as unsigned */
2020 		warning(157);
2021 		v->v_ansiu = 0;
2022 	}
2023 
2024 	switch (nt) {
2025 	case FLOAT:
2026 	case FCOMPLEX:
2027 	case DOUBLE:
2028 	case DCOMPLEX:
2029 	case LDOUBLE:
2030 	case LCOMPLEX:
2031 		break;
2032 	default:
2033 		sz = tp->t_isfield ? tp->t_flen : size(nt);
2034 		nv->v_quad = xsign(nv->v_quad, nt, sz);
2035 		break;
2036 	}
2037 
2038 	if (rchk && op != CVT) {
2039 		osz = size(ot);
2040 		nsz = tp->t_isfield ? tp->t_flen : size(nt);
2041 		xmask = qlmasks[nsz] ^ qlmasks[osz];
2042 		xmsk1 = qlmasks[nsz] ^ qlmasks[osz - 1];
2043 		/*
2044 		 * For bitwise operations we are not interested in the
2045 		 * value, but in the bits itself.
2046 		 */
2047 		if (op == ORASS || op == OR || op == XOR) {
2048 			/*
2049 			 * Print a warning if bits which were set are
2050 			 * lost due to the conversion.
2051 			 * This can happen with operator ORASS only.
2052 			 */
2053 			if (nsz < osz && (v->v_quad & xmask) != 0) {
2054 				/* constant truncated by conv., op %s */
2055 				warning(306, modtab[op].m_name);
2056 			}
2057 		} else if (op == ANDASS || op == AND) {
2058 			/*
2059 			 * Print a warning if additional bits are not all 1
2060 			 * and the most significant bit of the old value is 1,
2061 			 * or if at least one (but not all) removed bit was 0.
2062 			 */
2063 			if (nsz > osz &&
2064 			    (nv->v_quad & qbmasks[osz - 1]) != 0 &&
2065 			    (nv->v_quad & xmask) != xmask) {
2066 				/*
2067 				 * extra bits set to 0 in conversion
2068 				 * of '%s' to '%s', op %s
2069 				 */
2070 				warning(309, tyname(lbuf, sizeof(lbuf),
2071 				    gettyp(ot)), tyname(rbuf, sizeof(rbuf), tp),
2072 				    modtab[op].m_name);
2073 			} else if (nsz < osz &&
2074 				   (v->v_quad & xmask) != xmask &&
2075 				   (v->v_quad & xmask) != 0) {
2076 				/* const. truncated by conv., op %s */
2077 				warning(306, modtab[op].m_name);
2078 			}
2079 		} else if ((nt != PTR && isutyp(nt)) &&
2080 			   (ot != PTR && !isutyp(ot)) && v->v_quad < 0) {
2081 			if (op == ASSIGN) {
2082 				/* assignment of negative constant to ... */
2083 				warning(164);
2084 			} else if (op == INIT) {
2085 				/* initialisation of unsigned with neg. ... */
2086 				warning(221);
2087 			} else if (op == FARG) {
2088 				/* conversion of neg. const. to ..., arg #%d */
2089 				warning(296, arg);
2090 			} else if (modtab[op].m_comp) {
2091 				/* we get this warning already in chkcomp() */
2092 			} else {
2093 				/* conversion of negative constant to ... */
2094 				warning(222);
2095 			}
2096 		} else if (nv->v_quad != v->v_quad && nsz <= osz &&
2097 			   (v->v_quad & xmask) != 0 &&
2098 			   (isutyp(ot) || (v->v_quad & xmsk1) != xmsk1)) {
2099 			/*
2100 			 * Loss of significant bit(s). All truncated bits
2101 			 * of unsigned types or all truncated bits plus the
2102 			 * msb of the target for signed types are considered
2103 			 * to be significant bits. Loss of significant bits
2104 			 * means that at least on of the bits was set in an
2105 			 * unsigned type or that at least one, but not all of
2106 			 * the bits was set in an signed type.
2107 			 * Loss of significant bits means that it is not
2108 			 * possible, also not with necessary casts, to convert
2109 			 * back to the original type. A example for a
2110 			 * necessary cast is:
2111 			 *	char c;	int	i; c = 128;
2112 			 *	i = c;			** yields -128 **
2113 			 *	i = (unsigned char)c;	** yields 128 **
2114 			 */
2115 			if (op == ASSIGN && tp->t_isfield) {
2116 				/* precision lost in bit-field assignment */
2117 				warning(166);
2118 			} else if (op == ASSIGN) {
2119 				/* constant truncated by assignment */
2120 				warning(165);
2121 			} else if (op == INIT && tp->t_isfield) {
2122 				/* bit-field initializer does not fit */
2123 				warning(180);
2124 			} else if (op == INIT) {
2125 				/* initializer does not fit */
2126 				warning(178);
2127 			} else if (op == CASE) {
2128 				/* case label affected by conversion */
2129 				warning(196);
2130 			} else if (op == FARG) {
2131 				/* conv. of %s to %s is out of rng., arg #%d */
2132 				warning(295, tyname(lbuf, sizeof(lbuf),
2133 				    gettyp(ot)), tyname(rbuf, sizeof(rbuf), tp),
2134 				    arg);
2135 			} else {
2136 				/* conversion of %s to %s is out of range */
2137 				warning(119, tyname(lbuf, sizeof(lbuf),
2138 				    gettyp(ot)),
2139 				    tyname(rbuf, sizeof(rbuf), tp));
2140 			}
2141 		} else if (nv->v_quad != v->v_quad) {
2142 			if (op == ASSIGN && tp->t_isfield) {
2143 				/* precision lost in bit-field assignment */
2144 				warning(166);
2145 			} else if (op == INIT && tp->t_isfield) {
2146 				/* bit-field initializer out of range */
2147 				warning(11);
2148 			} else if (op == CASE) {
2149 				/* case label affected by conversion */
2150 				warning(196);
2151 			} else if (op == FARG) {
2152 				/* conv. of %s to %s is out of rng., arg #%d */
2153 				warning(295, tyname(lbuf, sizeof(lbuf),
2154 				    gettyp(ot)), tyname(rbuf, sizeof(rbuf), tp),
2155 				    arg);
2156 			} else {
2157 				/* conversion of %s to %s is out of range */
2158 				warning(119, tyname(lbuf, sizeof(lbuf),
2159 				    gettyp(ot)),
2160 				    tyname(rbuf, sizeof(rbuf), tp));
2161 			}
2162 		}
2163 	}
2164 }
2165 
2166 /*
2167  * Called if incompatible types were detected.
2168  * Prints a appropriate warning.
2169  */
2170 static void
2171 incompat(op_t op, tspec_t lt, tspec_t rt)
2172 {
2173 	mod_t	*mp;
2174 	int e = 0;
2175 
2176 	mp = &modtab[op];
2177 
2178 	if (lt == VOID || (mp->m_binary && rt == VOID)) {
2179 		/* void type illegal in expression */
2180 		e = 109;
2181 	} else if (op == ASSIGN) {
2182 		if ((lt == STRUCT || lt == UNION) &&
2183 		    (rt == STRUCT || rt == UNION)) {
2184 			/* assignment of different structures */
2185 			e = 240;
2186 		} else {
2187 			/* assignment type mismatch */
2188 			e = 171;
2189 		}
2190 	} else if (mp->m_binary) {
2191 		/* operands of %s have incompatible types */
2192 		e = 107;
2193 	} else {
2194 		/* operand of %s has incompatible type */
2195 		e = 108;
2196 	}
2197 	switch (e) {
2198 	case 0:
2199 		return;
2200 	case 109:
2201 		error(e);
2202 		return;
2203 	case 108:
2204 	case 107:
2205 		error(e, mp->m_name, basictyname(lt), basictyname(rt));
2206 		return;
2207 	default:
2208 		error(e, basictyname(lt), basictyname(rt));
2209 		return;
2210 	}
2211 }
2212 
2213 /*
2214  * Called if incompatible pointer types are detected.
2215  * Print an appropriate warning.
2216  */
2217 static void
2218 illptrc(mod_t *mp, type_t *ltp, type_t *rtp)
2219 {
2220 	tspec_t	lt, rt;
2221 
2222 	if (ltp->t_tspec != PTR || rtp->t_tspec != PTR)
2223 		LERROR("illptrc()");
2224 
2225 	lt = ltp->t_subt->t_tspec;
2226 	rt = rtp->t_subt->t_tspec;
2227 
2228 	if ((lt == STRUCT || lt == UNION) && (rt == STRUCT || rt == UNION)) {
2229 		if (mp == NULL) {
2230 			/* illegal structure pointer combination */
2231 			warning(244);
2232 		} else {
2233 			/* illegal structure pointer combination, op %s */
2234 			warning(245, mp->m_name);
2235 		}
2236 	} else {
2237 		if (mp == NULL) {
2238 			/* illegal pointer combination */
2239 			warning(184);
2240 		} else {
2241 			/* illegal pointer combination, op %s */
2242 			warning(124, mp->m_name);
2243 		}
2244 	}
2245 }
2246 
2247 /*
2248  * Make sure type (*tpp)->t_subt has at least the qualifiers
2249  * of tp1->t_subt and tp2->t_subt.
2250  */
2251 static void
2252 mrgqual(type_t **tpp, type_t *tp1, type_t *tp2)
2253 {
2254 
2255 	if ((*tpp)->t_tspec != PTR ||
2256 	    tp1->t_tspec != PTR || tp2->t_tspec != PTR) {
2257 		LERROR("mrgqual()");
2258 	}
2259 
2260 	if ((*tpp)->t_subt->t_const ==
2261 	    (tp1->t_subt->t_const | tp2->t_subt->t_const) &&
2262 	    (*tpp)->t_subt->t_volatile ==
2263 	    (tp1->t_subt->t_volatile | tp2->t_subt->t_volatile)) {
2264 		return;
2265 	}
2266 
2267 	*tpp = tduptyp(*tpp);
2268 	(*tpp)->t_subt = tduptyp((*tpp)->t_subt);
2269 	(*tpp)->t_subt->t_const =
2270 		tp1->t_subt->t_const | tp2->t_subt->t_const;
2271 	(*tpp)->t_subt->t_volatile =
2272 		tp1->t_subt->t_volatile | tp2->t_subt->t_volatile;
2273 }
2274 
2275 /*
2276  * Returns 1 if the given structure or union has a constant member
2277  * (maybe recursively).
2278  */
2279 static int
2280 conmemb(type_t *tp)
2281 {
2282 	sym_t	*m;
2283 	tspec_t	t;
2284 
2285 	if ((t = tp->t_tspec) != STRUCT && t != UNION)
2286 		LERROR("conmemb()");
2287 	for (m = tp->t_str->memb; m != NULL; m = m->s_nxt) {
2288 		tp = m->s_type;
2289 		if (tp->t_const)
2290 			return (1);
2291 		if ((t = tp->t_tspec) == STRUCT || t == UNION) {
2292 			if (conmemb(m->s_type))
2293 				return (1);
2294 		}
2295 	}
2296 	return (0);
2297 }
2298 
2299 /*
2300  * Create a new node for one of the operators POINT and ARROW.
2301  */
2302 static tnode_t *
2303 bldstr(op_t op, tnode_t *ln, tnode_t *rn)
2304 {
2305 	tnode_t	*ntn, *ctn;
2306 	int	nolval;
2307 
2308 	if (rn->tn_op != NAME)
2309 		LERROR("bldstr()");
2310 	if (rn->tn_sym->s_value.v_tspec != INT)
2311 		LERROR("bldstr()");
2312 	if (rn->tn_sym->s_scl != MOS && rn->tn_sym->s_scl != MOU)
2313 		LERROR("bldstr()");
2314 
2315 	/*
2316 	 * Remember if the left operand is an lvalue (structure members
2317 	 * are lvalues if and only if the structure itself is an lvalue).
2318 	 */
2319 	nolval = op == POINT && !ln->tn_lvalue;
2320 
2321 	if (op == POINT) {
2322 		ln = bldamper(ln, 1);
2323 	} else if (ln->tn_type->t_tspec != PTR) {
2324 		if (!tflag || !isityp(ln->tn_type->t_tspec))
2325 			LERROR("bldstr()");
2326 		ln = convert(NOOP, 0, tincref(gettyp(VOID), PTR), ln);
2327 	}
2328 
2329 #if PTRDIFF_IS_LONG
2330 	ctn = getinode(LONG, rn->tn_sym->s_value.v_quad / CHAR_BIT);
2331 #else
2332 	ctn = getinode(INT, rn->tn_sym->s_value.v_quad / CHAR_BIT);
2333 #endif
2334 
2335 	ntn = mktnode(PLUS, tincref(rn->tn_type, PTR), ln, ctn);
2336 	if (ln->tn_op == CON)
2337 		ntn = fold(ntn);
2338 
2339 	if (rn->tn_type->t_isfield) {
2340 		ntn = mktnode(FSEL, ntn->tn_type->t_subt, ntn, NULL);
2341 	} else {
2342 		ntn = mktnode(STAR, ntn->tn_type->t_subt, ntn, NULL);
2343 	}
2344 
2345 	if (nolval)
2346 		ntn->tn_lvalue = 0;
2347 
2348 	return (ntn);
2349 }
2350 
2351 /*
2352  * Create a node for INCAFT, INCBEF, DECAFT and DECBEF.
2353  */
2354 static tnode_t *
2355 bldincdec(op_t op, tnode_t *ln)
2356 {
2357 	tnode_t	*cn, *ntn;
2358 
2359 	if (ln == NULL)
2360 		LERROR("bldincdec()");
2361 
2362 	if (ln->tn_type->t_tspec == PTR) {
2363 		cn = plength(ln->tn_type);
2364 	} else {
2365 		cn = getinode(INT, (int64_t)1);
2366 	}
2367 	ntn = mktnode(op, ln->tn_type, ln, cn);
2368 
2369 	return (ntn);
2370 }
2371 
2372 /*
2373  * Create a node for REAL, IMAG
2374  */
2375 static tnode_t *
2376 bldri(op_t op, tnode_t *ln)
2377 {
2378 	tnode_t	*cn, *ntn;
2379 	char buf[64];
2380 
2381 	if (ln == NULL)
2382 		LERROR("bldincdec()");
2383 
2384 	switch (ln->tn_type->t_tspec) {
2385 	case LCOMPLEX:
2386 		cn = getinode(LDOUBLE, (int64_t)1);
2387 		break;
2388 	case DCOMPLEX:
2389 		cn = getinode(DOUBLE, (int64_t)1);
2390 		break;
2391 	case FCOMPLEX:
2392 		cn = getinode(FLOAT, (int64_t)1);
2393 		break;
2394 	default:
2395 		error(276, op == REAL ? "real" : "imag",
2396 		    tyname(buf, sizeof(buf), ln->tn_type));
2397 		return NULL;
2398 	}
2399 	ntn = mktnode(op, cn->tn_type, ln, cn);
2400 	ntn->tn_lvalue = 1;
2401 
2402 	return (ntn);
2403 }
2404 /*
2405  * Create a tree node for the & operator
2406  */
2407 static tnode_t *
2408 bldamper(tnode_t *tn, int noign)
2409 {
2410 	tnode_t	*ntn;
2411 	tspec_t	t;
2412 
2413 	if (!noign && ((t = tn->tn_type->t_tspec) == ARRAY || t == FUNC)) {
2414 		/* & before array or function: ignored */
2415 		if (tflag)
2416 			warning(127);
2417 		return (tn);
2418 	}
2419 
2420 	/* eliminate &* */
2421 	if (tn->tn_op == STAR &&
2422 	    tn->tn_left->tn_type->t_tspec == PTR &&
2423 	    tn->tn_left->tn_type->t_subt == tn->tn_type) {
2424 		return (tn->tn_left);
2425 	}
2426 
2427 	ntn = mktnode(AMPER, tincref(tn->tn_type, PTR), tn, NULL);
2428 
2429 	return (ntn);
2430 }
2431 
2432 /*
2433  * Create a node for operators PLUS and MINUS.
2434  */
2435 static tnode_t *
2436 bldplmi(op_t op, tnode_t *ln, tnode_t *rn)
2437 {
2438 	tnode_t	*ntn, *ctn;
2439 	type_t	*tp;
2440 
2441 	/* If pointer and integer, then pointer to the lhs. */
2442 	if (rn->tn_type->t_tspec == PTR && isityp(ln->tn_type->t_tspec)) {
2443 		ntn = ln;
2444 		ln = rn;
2445 		rn = ntn;
2446 	}
2447 
2448 	if (ln->tn_type->t_tspec == PTR && rn->tn_type->t_tspec != PTR) {
2449 
2450 		if (!isityp(rn->tn_type->t_tspec))
2451 			LERROR("bldplmi()");
2452 
2453 		ctn = plength(ln->tn_type);
2454 		if (rn->tn_type->t_tspec != ctn->tn_type->t_tspec)
2455 			rn = convert(NOOP, 0, ctn->tn_type, rn);
2456 		rn = mktnode(MULT, rn->tn_type, rn, ctn);
2457 		if (rn->tn_left->tn_op == CON)
2458 			rn = fold(rn);
2459 		ntn = mktnode(op, ln->tn_type, ln, rn);
2460 
2461 	} else if (rn->tn_type->t_tspec == PTR) {
2462 
2463 		if (ln->tn_type->t_tspec != PTR || op != MINUS)
2464 			LERROR("bldplmi()");
2465 #if PTRDIFF_IS_LONG
2466 		tp = gettyp(LONG);
2467 #else
2468 		tp = gettyp(INT);
2469 #endif
2470 		ntn = mktnode(op, tp, ln, rn);
2471 		if (ln->tn_op == CON && rn->tn_op == CON)
2472 			ntn = fold(ntn);
2473 		ctn = plength(ln->tn_type);
2474 		balance(NOOP, &ntn, &ctn);
2475 		ntn = mktnode(DIV, tp, ntn, ctn);
2476 
2477 	} else {
2478 
2479 		ntn = mktnode(op, ln->tn_type, ln, rn);
2480 
2481 	}
2482 	return (ntn);
2483 }
2484 
2485 /*
2486  * Create a node for operators SHL and SHR.
2487  */
2488 static tnode_t *
2489 bldshft(op_t op, tnode_t *ln, tnode_t *rn)
2490 {
2491 	tspec_t	t;
2492 	tnode_t	*ntn;
2493 
2494 	if ((t = rn->tn_type->t_tspec) != INT && t != UINT)
2495 		rn = convert(CVT, 0, gettyp(INT), rn);
2496 	ntn = mktnode(op, ln->tn_type, ln, rn);
2497 	return (ntn);
2498 }
2499 
2500 /*
2501  * Create a node for COLON.
2502  */
2503 static tnode_t *
2504 bldcol(tnode_t *ln, tnode_t *rn)
2505 {
2506 	tspec_t	lt, rt, pdt;
2507 	type_t	*rtp;
2508 	tnode_t	*ntn;
2509 
2510 	lt = ln->tn_type->t_tspec;
2511 	rt = rn->tn_type->t_tspec;
2512 #if PTRDIFF_IS_LONG
2513 	pdt = LONG;
2514 #else
2515 	pdt = INT;
2516 #endif
2517 
2518 	/*
2519 	 * Arithmetic types are balanced, all other type combinations
2520 	 * still need to be handled.
2521 	 */
2522 	if (isatyp(lt) && isatyp(rt)) {
2523 		rtp = ln->tn_type;
2524 	} else if (lt == VOID || rt == VOID) {
2525 		rtp = gettyp(VOID);
2526 	} else if (lt == STRUCT || lt == UNION) {
2527 		/* Both types must be identical. */
2528 		if (rt != STRUCT && rt != UNION)
2529 			LERROR("bldcol()");
2530 		if (ln->tn_type->t_str != rn->tn_type->t_str)
2531 			LERROR("bldcol()");
2532 		if (incompl(ln->tn_type)) {
2533 			/* unknown operand size, op %s */
2534 			error(138, modtab[COLON].m_name);
2535 			return (NULL);
2536 		}
2537 		rtp = ln->tn_type;
2538 	} else if (lt == PTR && isityp(rt)) {
2539 		if (rt != pdt) {
2540 			rn = convert(NOOP, 0, gettyp(pdt), rn);
2541 			rt = pdt;
2542 		}
2543 		rtp = ln->tn_type;
2544 	} else if (rt == PTR && isityp(lt)) {
2545 		if (lt != pdt) {
2546 			ln = convert(NOOP, 0, gettyp(pdt), ln);
2547 			lt = pdt;
2548 		}
2549 		rtp = rn->tn_type;
2550 	} else if (lt == PTR && ln->tn_type->t_subt->t_tspec == VOID) {
2551 		if (rt != PTR)
2552 			LERROR("bldcol()");
2553 		rtp = rn->tn_type;
2554 		mrgqual(&rtp, ln->tn_type, rn->tn_type);
2555 	} else if (rt == PTR && rn->tn_type->t_subt->t_tspec == VOID) {
2556 		if (lt != PTR)
2557 			LERROR("bldcol()");
2558 		rtp = ln->tn_type;
2559 		mrgqual(&rtp, ln->tn_type, rn->tn_type);
2560 	} else {
2561 		if (lt != PTR || rt != PTR)
2562 			LERROR("bldcol()");
2563 		/*
2564 		 * XXX For now we simply take the left type. This is
2565 		 * probably wrong, if one type contains a functionprototype
2566 		 * and the other one, at the same place, only an old style
2567 		 * declaration.
2568 		 */
2569 		rtp = ln->tn_type;
2570 		mrgqual(&rtp, ln->tn_type, rn->tn_type);
2571 	}
2572 
2573 	ntn = mktnode(COLON, rtp, ln, rn);
2574 
2575 	return (ntn);
2576 }
2577 
2578 /*
2579  * Create a node for an assignment operator (both = and op= ).
2580  */
2581 static tnode_t *
2582 bldasgn(op_t op, tnode_t *ln, tnode_t *rn)
2583 {
2584 	tspec_t	lt, rt;
2585 	tnode_t	*ntn, *ctn;
2586 
2587 	if (ln == NULL || rn == NULL)
2588 		LERROR("bldasgn()");
2589 
2590 	lt = ln->tn_type->t_tspec;
2591 	rt = rn->tn_type->t_tspec;
2592 
2593 	if ((op == ADDASS || op == SUBASS) && lt == PTR) {
2594 		if (!isityp(rt))
2595 			LERROR("bldasgn()");
2596 		ctn = plength(ln->tn_type);
2597 		if (rn->tn_type->t_tspec != ctn->tn_type->t_tspec)
2598 			rn = convert(NOOP, 0, ctn->tn_type, rn);
2599 		rn = mktnode(MULT, rn->tn_type, rn, ctn);
2600 		if (rn->tn_left->tn_op == CON)
2601 			rn = fold(rn);
2602 	}
2603 
2604 	if ((op == ASSIGN || op == RETURN) && (lt == STRUCT || rt == STRUCT)) {
2605 		if (rt != lt || ln->tn_type->t_str != rn->tn_type->t_str)
2606 			LERROR("bldasgn()");
2607 		if (incompl(ln->tn_type)) {
2608 			if (op == RETURN) {
2609 				/* cannot return incomplete type */
2610 				error(212);
2611 			} else {
2612 				/* unknown operand size, op %s */
2613 				error(138, modtab[op].m_name);
2614 			}
2615 			return (NULL);
2616 		}
2617 	}
2618 
2619 	if (op == SHLASS) {
2620 		if (psize(lt) < psize(rt)) {
2621 			if (hflag)
2622 				/* semantics of %s change in ANSI C; use ... */
2623 				warning(118, "<<=");
2624 		}
2625 	} else if (op != SHRASS) {
2626 		if (op == ASSIGN || lt != PTR) {
2627 			if (lt != rt ||
2628 			    (ln->tn_type->t_isfield && rn->tn_op == CON)) {
2629 				rn = convert(op, 0, ln->tn_type, rn);
2630 				rt = lt;
2631 			}
2632 		}
2633 	}
2634 
2635 	ntn = mktnode(op, ln->tn_type, ln, rn);
2636 
2637 	return (ntn);
2638 }
2639 
2640 /*
2641  * Get length of type tp->t_subt.
2642  */
2643 static tnode_t *
2644 plength(type_t *tp)
2645 {
2646 	int	elem, elsz;
2647 	tspec_t	st;
2648 
2649 	if (tp->t_tspec != PTR)
2650 		LERROR("plength()");
2651 	tp = tp->t_subt;
2652 
2653 	elem = 1;
2654 	elsz = 0;
2655 
2656 	while (tp->t_tspec == ARRAY) {
2657 		elem *= tp->t_dim;
2658 		tp = tp->t_subt;
2659 	}
2660 
2661 	switch (tp->t_tspec) {
2662 	case FUNC:
2663 		/* pointer to function is not allowed here */
2664 		error(110);
2665 		break;
2666 	case VOID:
2667 		/* cannot do pointer arithmetic on operand of ... */
2668 		(void)gnuism(136);
2669 		break;
2670 	case STRUCT:
2671 	case UNION:
2672 		if ((elsz = tp->t_str->size) == 0)
2673 			/* cannot do pointer arithmetic on operand of ... */
2674 			error(136);
2675 		break;
2676 	case ENUM:
2677 		if (incompl(tp)) {
2678 			/* cannot do pointer arithmetic on operand of ... */
2679 			warning(136);
2680 		}
2681 		/* FALLTHROUGH */
2682 	default:
2683 		if ((elsz = size(tp->t_tspec)) == 0) {
2684 			/* cannot do pointer arithmetic on operand of ... */
2685 			error(136);
2686 		} else if (elsz == -1) {
2687 			LERROR("plength()");
2688 		}
2689 		break;
2690 	}
2691 
2692 	if (elem == 0 && elsz != 0) {
2693 		/* cannot do pointer arithmetic on operand of ... */
2694 		error(136);
2695 	}
2696 
2697 	if (elsz == 0)
2698 		elsz = CHAR_BIT;
2699 
2700 #if PTRDIFF_IS_LONG
2701 	st = LONG;
2702 #else
2703 	st = INT;
2704 #endif
2705 
2706 	return (getinode(st, (int64_t)(elem * elsz / CHAR_BIT)));
2707 }
2708 
2709 /*
2710  * XXX
2711  * Note: There appear to be a number of bugs in detecting overflow in
2712  * this function. An audit and a set of proper regression tests are needed.
2713  *     --Perry Metzger, Nov. 16, 2001
2714  */
2715 /*
2716  * Do only as much as necessary to compute constant expressions.
2717  * Called only if the operator allows folding and (both) operands
2718  * are constants.
2719  */
2720 static tnode_t *
2721 fold(tnode_t *tn)
2722 {
2723 	val_t	*v;
2724 	tspec_t	t;
2725 	int	utyp, ovfl;
2726 	int64_t	sl, sr = 0, q = 0, mask;
2727 	uint64_t ul, ur = 0;
2728 	tnode_t	*cn;
2729 
2730 	v = xcalloc(1, sizeof (val_t));
2731 	v->v_tspec = t = tn->tn_type->t_tspec;
2732 
2733 	utyp = t == PTR || isutyp(t);
2734 	ul = sl = tn->tn_left->tn_val->v_quad;
2735 	if (modtab[tn->tn_op].m_binary)
2736 		ur = sr = tn->tn_right->tn_val->v_quad;
2737 
2738 	mask = qlmasks[size(t)];
2739 	ovfl = 0;
2740 
2741 	switch (tn->tn_op) {
2742 	case UPLUS:
2743 		q = sl;
2744 		break;
2745 	case UMINUS:
2746 		q = -sl;
2747 		if (sl != 0 && msb(q, t, -1) == msb(sl, t, -1))
2748 			ovfl = 1;
2749 		break;
2750 	case COMPL:
2751 		q = ~sl;
2752 		break;
2753 	case MULT:
2754 		if (utyp) {
2755 			q = ul * ur;
2756 			if (q != (q & mask))
2757 				ovfl = 1;
2758 			else if ((ul != 0) && ((q / ul) != ur))
2759 				ovfl = 1;
2760 		} else {
2761 			q = sl * sr;
2762 			if (msb(q, t, -1) != (msb(sl, t, -1) ^ msb(sr, t, -1)))
2763 				ovfl = 1;
2764 		}
2765 		break;
2766 	case DIV:
2767 		if (sr == 0) {
2768 			/* division by 0 */
2769 			error(139);
2770 			q = utyp ? UQUAD_MAX : QUAD_MAX;
2771 		} else {
2772 			q = utyp ? (int64_t)(ul / ur) : sl / sr;
2773 		}
2774 		break;
2775 	case MOD:
2776 		if (sr == 0) {
2777 			/* modulus by 0 */
2778 			error(140);
2779 			q = 0;
2780 		} else {
2781 			q = utyp ? (int64_t)(ul % ur) : sl % sr;
2782 		}
2783 		break;
2784 	case PLUS:
2785 		q = utyp ? (int64_t)(ul + ur) : sl + sr;
2786 		if (msb(sl, t, -1)  != 0 && msb(sr, t, -1) != 0) {
2787 			if (msb(q, t, -1) == 0)
2788 				ovfl = 1;
2789 		} else if (msb(sl, t, -1) == 0 && msb(sr, t, -1) == 0) {
2790 			if (msb(q, t, -1) != 0)
2791 				ovfl = 1;
2792 		}
2793 		break;
2794 	case MINUS:
2795 		q = utyp ? (int64_t)(ul - ur) : sl - sr;
2796 		if (msb(sl, t, -1) != 0 && msb(sr, t, -1) == 0) {
2797 			if (msb(q, t, -1) == 0)
2798 				ovfl = 1;
2799 		} else if (msb(sl, t, -1) == 0 && msb(sr, t, -1) != 0) {
2800 			if (msb(q, t, -1) != 0)
2801 				ovfl = 1;
2802 		}
2803 		break;
2804 	case SHL:
2805 		q = utyp ? (int64_t)(ul << sr) : sl << sr;
2806 		break;
2807 	case SHR:
2808 		/*
2809 		 * The sign must be explicitly extended because
2810 		 * shifts of signed values are implementation dependent.
2811 		 */
2812 		q = ul >> sr;
2813 		q = xsign(q, t, size(t) - (int)sr);
2814 		break;
2815 	case LT:
2816 		q = utyp ? ul < ur : sl < sr;
2817 		break;
2818 	case LE:
2819 		q = utyp ? ul <= ur : sl <= sr;
2820 		break;
2821 	case GE:
2822 		q = utyp ? ul >= ur : sl >= sr;
2823 		break;
2824 	case GT:
2825 		q = utyp ? ul > ur : sl > sr;
2826 		break;
2827 	case EQ:
2828 		q = utyp ? ul == ur : sl == sr;
2829 		break;
2830 	case NE:
2831 		q = utyp ? ul != ur : sl != sr;
2832 		break;
2833 	case AND:
2834 		q = utyp ? (int64_t)(ul & ur) : sl & sr;
2835 		break;
2836 	case XOR:
2837 		q = utyp ? (int64_t)(ul ^ ur) : sl ^ sr;
2838 		break;
2839 	case OR:
2840 		q = utyp ? (int64_t)(ul | ur) : sl | sr;
2841 		break;
2842 	default:
2843 		LERROR("fold()");
2844 	}
2845 
2846 	/* XXX does not work for quads. */
2847 	if (ovfl || ((uint64_t)(q | mask) != ~(uint64_t)0 &&
2848 	    (q & ~mask) != 0)) {
2849 		if (hflag)
2850 			/* integer overflow detected, op %s */
2851 			warning(141, modtab[tn->tn_op].m_name);
2852 	}
2853 
2854 	v->v_quad = xsign(q, t, -1);
2855 
2856 	cn = getcnode(tn->tn_type, v);
2857 
2858 	return (cn);
2859 }
2860 
2861 /*
2862  * Same for operators whose operands are compared with 0 (test context).
2863  */
2864 static tnode_t *
2865 foldtst(tnode_t *tn)
2866 {
2867 	int	l, r = 0;
2868 	val_t	*v;
2869 
2870 	v = xcalloc(1, sizeof (val_t));
2871 	v->v_tspec = tn->tn_type->t_tspec;
2872 	if (tn->tn_type->t_tspec != INT)
2873 		LERROR("foldtst()");
2874 
2875 	if (isftyp(tn->tn_left->tn_type->t_tspec)) {
2876 		l = tn->tn_left->tn_val->v_ldbl != 0.0;
2877 	} else {
2878 		l = tn->tn_left->tn_val->v_quad != 0;
2879 	}
2880 
2881 	if (modtab[tn->tn_op].m_binary) {
2882 		if (isftyp(tn->tn_right->tn_type->t_tspec)) {
2883 			r = tn->tn_right->tn_val->v_ldbl != 0.0;
2884 		} else {
2885 			r = tn->tn_right->tn_val->v_quad != 0;
2886 		}
2887 	}
2888 
2889 	switch (tn->tn_op) {
2890 	case NOT:
2891 		if (hflag && !ccflg)
2892 			/* constant argument to NOT */
2893 			warning(239);
2894 		v->v_quad = !l;
2895 		break;
2896 	case LOGAND:
2897 		v->v_quad = l && r;
2898 		break;
2899 	case LOGOR:
2900 		v->v_quad = l || r;
2901 		break;
2902 	default:
2903 		LERROR("foldtst()");
2904 	}
2905 
2906 	return (getcnode(tn->tn_type, v));
2907 }
2908 
2909 /*
2910  * Same for operands with floating point type.
2911  */
2912 static tnode_t *
2913 foldflt(tnode_t *tn)
2914 {
2915 	val_t	*v;
2916 	tspec_t	t;
2917 	ldbl_t	l, r = 0;
2918 
2919 	fpe = 0;
2920 	v = xcalloc(1, sizeof (val_t));
2921 	v->v_tspec = t = tn->tn_type->t_tspec;
2922 
2923 	if (!isftyp(t))
2924 		LERROR("foldflt()");
2925 
2926 	if (t != tn->tn_left->tn_type->t_tspec)
2927 		LERROR("foldflt()");
2928 	if (modtab[tn->tn_op].m_binary && t != tn->tn_right->tn_type->t_tspec)
2929 		LERROR("foldflt()");
2930 
2931 	l = tn->tn_left->tn_val->v_ldbl;
2932 	if (modtab[tn->tn_op].m_binary)
2933 		r = tn->tn_right->tn_val->v_ldbl;
2934 
2935 	switch (tn->tn_op) {
2936 	case UPLUS:
2937 		v->v_ldbl = l;
2938 		break;
2939 	case UMINUS:
2940 		v->v_ldbl = -l;
2941 		break;
2942 	case MULT:
2943 		v->v_ldbl = l * r;
2944 		break;
2945 	case DIV:
2946 		if (r == 0.0) {
2947 			/* division by 0 */
2948 			error(139);
2949 			if (t == FLOAT) {
2950 				v->v_ldbl = l < 0 ? -FLT_MAX : FLT_MAX;
2951 			} else if (t == DOUBLE) {
2952 				v->v_ldbl = l < 0 ? -DBL_MAX : DBL_MAX;
2953 			} else {
2954 				v->v_ldbl = l < 0 ? -LDBL_MAX : LDBL_MAX;
2955 			}
2956 		} else {
2957 			v->v_ldbl = l / r;
2958 		}
2959 		break;
2960 	case PLUS:
2961 		v->v_ldbl = l + r;
2962 		break;
2963 	case MINUS:
2964 		v->v_ldbl = l - r;
2965 		break;
2966 	case LT:
2967 		v->v_quad = l < r;
2968 		break;
2969 	case LE:
2970 		v->v_quad = l <= r;
2971 		break;
2972 	case GE:
2973 		v->v_quad = l >= r;
2974 		break;
2975 	case GT:
2976 		v->v_quad = l > r;
2977 		break;
2978 	case EQ:
2979 		v->v_quad = l == r;
2980 		break;
2981 	case NE:
2982 		v->v_quad = l != r;
2983 		break;
2984 	default:
2985 		LERROR("foldflt()");
2986 	}
2987 
2988 	if (!fpe && isnan((double)v->v_ldbl))
2989 		LERROR("foldflt()");
2990 	if (fpe || !finite((double)v->v_ldbl) ||
2991 	    (t == FLOAT &&
2992 	     (v->v_ldbl > FLT_MAX || v->v_ldbl < -FLT_MAX)) ||
2993 	    (t == DOUBLE &&
2994 	     (v->v_ldbl > DBL_MAX || v->v_ldbl < -DBL_MAX))) {
2995 		/* floating point overflow detected, op %s */
2996 		warning(142, modtab[tn->tn_op].m_name);
2997 		if (t == FLOAT) {
2998 			v->v_ldbl = v->v_ldbl < 0 ? -FLT_MAX : FLT_MAX;
2999 		} else if (t == DOUBLE) {
3000 			v->v_ldbl = v->v_ldbl < 0 ? -DBL_MAX : DBL_MAX;
3001 		} else {
3002 			v->v_ldbl = v->v_ldbl < 0 ? -LDBL_MAX: LDBL_MAX;
3003 		}
3004 	    fpe = 0;
3005 	}
3006 
3007 	return (getcnode(tn->tn_type, v));
3008 }
3009 
3010 
3011 /*
3012  * Create a constant node for sizeof.
3013  */
3014 tnode_t *
3015 bldszof(type_t *tp)
3016 {
3017 	tspec_t	st;
3018 #if SIZEOF_IS_ULONG
3019 	st = ULONG;
3020 #else
3021 	st = UINT;
3022 #endif
3023 	return getinode(st, tsize(tp) / CHAR_BIT);
3024 }
3025 
3026 /*
3027  * Create a constant node for offsetof.
3028  */
3029 tnode_t *
3030 bldoffsetof(type_t *tp, sym_t *sym)
3031 {
3032 	tspec_t	st;
3033 #if SIZEOF_IS_ULONG
3034 	st = ULONG;
3035 #else
3036 	st = UINT;
3037 #endif
3038 	tspec_t t = tp->t_tspec;
3039 	if (t != STRUCT && t != UNION)
3040 		error(111, "offsetof");
3041 
3042 	// XXX: wrong size, no checking for sym fixme
3043 	return getinode(st, tsize(tp) / CHAR_BIT);
3044 }
3045 
3046 int64_t
3047 tsize(type_t *tp)
3048 {
3049 	int	elem, elsz, flex;
3050 
3051 	elem = 1;
3052 	flex = 0;
3053 	while (tp->t_tspec == ARRAY) {
3054 		flex = 1;	/* allow c99 flex arrays [] [0] */
3055 		elem *= tp->t_dim;
3056 		tp = tp->t_subt;
3057 	}
3058 	if (elem == 0) {
3059 		if (!flex) {
3060 			/* cannot take size of incomplete type */
3061 			error(143);
3062 			elem = 1;
3063 		}
3064 	}
3065 	switch (tp->t_tspec) {
3066 	case FUNC:
3067 		/* cannot take size of function */
3068 		error(144);
3069 		elsz = 1;
3070 		break;
3071 	case STRUCT:
3072 	case UNION:
3073 		if (incompl(tp)) {
3074 			/* cannot take size of incomplete type */
3075 			error(143);
3076 			elsz = 1;
3077 		} else {
3078 			elsz = tp->t_str->size;
3079 		}
3080 		break;
3081 	case ENUM:
3082 		if (incompl(tp)) {
3083 			/* cannot take size of incomplete type */
3084 			warning(143);
3085 		}
3086 		/* FALLTHROUGH */
3087 	default:
3088 		if (tp->t_isfield) {
3089 			/* cannot take size of bit-field */
3090 			error(145);
3091 		}
3092 		if (tp->t_tspec == VOID) {
3093 			/* cannot take size of void */
3094 			error(146);
3095 			elsz = 1;
3096 		} else {
3097 			elsz = size(tp->t_tspec);
3098 			if (elsz <= 0)
3099 				LERROR("bldszof()");
3100 		}
3101 		break;
3102 	}
3103 
3104 	return (int64_t)(elem * elsz);
3105 }
3106 
3107 /*
3108  */
3109 tnode_t *
3110 bldalof(type_t *tp)
3111 {
3112 	tspec_t	st;
3113 
3114 	switch (tp->t_tspec) {
3115 	case ARRAY:
3116 		break;
3117 
3118 	case FUNC:
3119 		/* cannot take align of function */
3120 		error(144);
3121 		return 0;
3122 
3123 	case STRUCT:
3124 	case UNION:
3125 		if (incompl(tp)) {
3126 			/* cannot take align of incomplete type */
3127 			error(143);
3128 			return 0;
3129 		}
3130 		break;
3131 	case ENUM:
3132 		break;
3133 	default:
3134 		if (tp->t_isfield) {
3135 			/* cannot take align of bit-field */
3136 			error(145);
3137 			return 0;
3138 		}
3139 		if (tp->t_tspec == VOID) {
3140 			/* cannot take alignsize of void */
3141 			error(146);
3142 			return 0;
3143 		}
3144 		break;
3145 	}
3146 
3147 #if SIZEOF_IS_ULONG
3148 	st = ULONG;
3149 #else
3150 	st = UINT;
3151 #endif
3152 
3153 	return getinode(st, (int64_t)getbound(tp));
3154 }
3155 
3156 /*
3157  * Type casts.
3158  */
3159 tnode_t *
3160 cast(tnode_t *tn, type_t *tp)
3161 {
3162 	tspec_t	nt, ot;
3163 
3164 	if (tn == NULL)
3165 		return (NULL);
3166 
3167 	tn = cconv(tn);
3168 
3169 	nt = tp->t_tspec;
3170 	ot = tn->tn_type->t_tspec;
3171 
3172 	if (nt == VOID) {
3173 		/*
3174 		 * XXX ANSI C requires scalar types or void (Plauger&Brodie).
3175 		 * But this seams really questionable.
3176 		 */
3177 	} else if (nt == UNION) {
3178 		char buf[256], buf1[256];
3179 		sym_t *m;
3180 		str_t *str = tp->t_str;
3181 		if (!Sflag) {
3182 			error(328);
3183 			return NULL;
3184 		}
3185 		for (m = str->memb; m != NULL; m = m->s_nxt) {
3186 			if (sametype(m->s_type, tn->tn_type)) {
3187 				tn = getnode();
3188 				tn->tn_op = CVT;
3189 				tn->tn_type = tp;
3190 				tn->tn_cast = 1;
3191 				tn->tn_right = NULL;
3192 				return tn;
3193 			}
3194 		}
3195 		error(329, tyname(buf, sizeof(buf), tn->tn_type),
3196 		    tyname(buf1, sizeof(buf1), tp));
3197 		return NULL;
3198 	} else if (nt == STRUCT || nt == ARRAY || nt == FUNC) {
3199 		/* invalid cast expression */
3200 		error(147);
3201 		return (NULL);
3202 	} else if (ot == STRUCT || ot == UNION) {
3203 		/* invalid cast expression */
3204 		error(147);
3205 		return (NULL);
3206 	} else if (ot == VOID) {
3207 		/* improper cast of void expression */
3208 		error(148);
3209 		return (NULL);
3210 	} else if (isityp(nt) && issclt(ot)) {
3211 		/* ok */
3212 	} else if (isftyp(nt) && isatyp(ot)) {
3213 		/* ok */
3214 	} else if (nt == PTR && isityp(ot)) {
3215 		/* ok */
3216 	} else if (nt == PTR && ot == PTR) {
3217 		if (!tp->t_subt->t_const && tn->tn_type->t_subt->t_const) {
3218 			if (hflag)
3219 				/* cast discards 'const' from ... */
3220 				warning(275);
3221 		}
3222 	} else {
3223 		/* invalid cast expression */
3224 		error(147);
3225 		return (NULL);
3226 	}
3227 
3228 	tn = convert(CVT, 0, tp, tn);
3229 	tn->tn_cast = 1;
3230 
3231 	return (tn);
3232 }
3233 
3234 /*
3235  * Create the node for a function argument.
3236  * All necessary conversions and type checks are done in funccall(), because
3237  * in funcarg() we have no information about expected argument types.
3238  */
3239 tnode_t *
3240 funcarg(tnode_t *args, tnode_t *arg)
3241 {
3242 	tnode_t	*ntn;
3243 
3244 	/*
3245 	 * If there was a serious error in the expression for the argument,
3246 	 * create a dummy argument so the positions of the remaining arguments
3247 	 * will not change.
3248 	 */
3249 	if (arg == NULL)
3250 		arg = getinode(INT, (int64_t)0);
3251 
3252 	ntn = mktnode(PUSH, arg->tn_type, arg, args);
3253 
3254 	return (ntn);
3255 }
3256 
3257 /*
3258  * Create the node for a function call. Also check types of
3259  * function arguments and insert conversions, if necessary.
3260  */
3261 tnode_t *
3262 funccall(tnode_t *func, tnode_t *args)
3263 {
3264 	tnode_t	*ntn;
3265 	op_t	fcop;
3266 
3267 	if (func == NULL)
3268 		return (NULL);
3269 
3270 	if (func->tn_op == NAME && func->tn_type->t_tspec == FUNC) {
3271 		fcop = CALL;
3272 	} else {
3273 		fcop = ICALL;
3274 	}
3275 
3276 	/*
3277 	 * after cconv() func will always be a pointer to a function
3278 	 * if it is a valid function designator.
3279 	 */
3280 	func = cconv(func);
3281 
3282 	if (func->tn_type->t_tspec != PTR ||
3283 	    func->tn_type->t_subt->t_tspec != FUNC) {
3284 		char buf[256];
3285 		/* illegal function */
3286 		error(149, tyname(buf, sizeof(buf), func->tn_type));
3287 		return (NULL);
3288 	}
3289 
3290 	args = chkfarg(func->tn_type->t_subt, args);
3291 
3292 	ntn = mktnode(fcop, func->tn_type->t_subt->t_subt, func, args);
3293 
3294 	return (ntn);
3295 }
3296 
3297 /*
3298  * Check types of all function arguments and insert conversions,
3299  * if necessary.
3300  */
3301 static tnode_t *
3302 chkfarg(type_t *ftp, tnode_t *args)
3303 {
3304 	tnode_t	*arg;
3305 	sym_t	*asym;
3306 	tspec_t	at;
3307 	int	narg, npar, n, i;
3308 
3309 	/* get # of args in the prototype */
3310 	npar = 0;
3311 	for (asym = ftp->t_args; asym != NULL; asym = asym->s_nxt)
3312 		npar++;
3313 
3314 	/* get # of args in function call */
3315 	narg = 0;
3316 	for (arg = args; arg != NULL; arg = arg->tn_right)
3317 		narg++;
3318 
3319 	asym = ftp->t_args;
3320 	if (ftp->t_proto && npar != narg && !(ftp->t_vararg && npar < narg)) {
3321 		/* argument mismatch: %d arg%s passed, %d expected */
3322 		error(150, narg, narg > 1 ? "s" : "", npar);
3323 		asym = NULL;
3324 	}
3325 
3326 	for (n = 1; n <= narg; n++) {
3327 
3328 		/*
3329 		 * The rightmost argument is at the top of the argument
3330 		 * subtree.
3331 		 */
3332 		for (i = narg, arg = args; i > n; i--, arg = arg->tn_right)
3333 			continue;
3334 
3335 		/* some things which are always not allowd */
3336 		if ((at = arg->tn_left->tn_type->t_tspec) == VOID) {
3337 			/* void expressions may not be arguments, arg #%d */
3338 			error(151, n);
3339 			return (NULL);
3340 		} else if ((at == STRUCT || at == UNION) &&
3341 			   incompl(arg->tn_left->tn_type)) {
3342 			/* argument cannot have unknown size, arg #%d */
3343 			error(152, n);
3344 			return (NULL);
3345 		} else if (isityp(at) && arg->tn_left->tn_type->t_isenum &&
3346 			   incompl(arg->tn_left->tn_type)) {
3347 			/* argument cannot have unknown size, arg #%d */
3348 			warning(152, n);
3349 		}
3350 
3351 		/* class conversions (arg in value context) */
3352 		arg->tn_left = cconv(arg->tn_left);
3353 
3354 		if (asym != NULL) {
3355 			arg->tn_left = parg(n, asym->s_type, arg->tn_left);
3356 		} else {
3357 			arg->tn_left = promote(NOOP, 1, arg->tn_left);
3358 		}
3359 		arg->tn_type = arg->tn_left->tn_type;
3360 
3361 		if (asym != NULL)
3362 			asym = asym->s_nxt;
3363 	}
3364 
3365 	return (args);
3366 }
3367 
3368 /*
3369  * Compare the type of an argument with the corresponding type of a
3370  * prototype parameter. If it is a valid combination, but both types
3371  * are not the same, insert a conversion to convert the argument into
3372  * the type of the parameter.
3373  */
3374 static tnode_t *
3375 parg(	int	n,		/* pos of arg */
3376 	type_t	*tp,		/* expected type (from prototype) */
3377 	tnode_t	*tn)		/* argument */
3378 {
3379 	tnode_t	*ln;
3380 	int	dowarn;
3381 
3382 	ln = xcalloc(1, sizeof (tnode_t));
3383 	ln->tn_type = tduptyp(tp);
3384 	ln->tn_type->t_const = 0;
3385 	ln->tn_lvalue = 1;
3386 	if (typeok(FARG, n, ln, tn)) {
3387 		if (!eqtype(tp, tn->tn_type, 1, 0, (dowarn = 0, &dowarn)) || dowarn)
3388 			tn = convert(FARG, n, tp, tn);
3389 	}
3390 	free(ln);
3391 	return (tn);
3392 }
3393 
3394 /*
3395  * Return the value of an integral constant expression.
3396  * If the expression is not constant or its type is not an integer
3397  * type, an error message is printed.
3398  */
3399 val_t *
3400 constant(tnode_t *tn, int required)
3401 {
3402 	val_t	*v;
3403 
3404 	if (tn != NULL)
3405 		tn = cconv(tn);
3406 	if (tn != NULL)
3407 		tn = promote(NOOP, 0, tn);
3408 
3409 	v = xcalloc(1, sizeof (val_t));
3410 
3411 	if (tn == NULL) {
3412 		if (nerr == 0)
3413 			LERROR("constant()");
3414 		v->v_tspec = INT;
3415 		v->v_quad = 1;
3416 		return (v);
3417 	}
3418 
3419 	v->v_tspec = tn->tn_type->t_tspec;
3420 
3421 	if (tn->tn_op == CON) {
3422 		if (tn->tn_type->t_tspec != tn->tn_val->v_tspec)
3423 			LERROR("constant()");
3424 		if (isityp(tn->tn_val->v_tspec)) {
3425 			v->v_ansiu = tn->tn_val->v_ansiu;
3426 			v->v_quad = tn->tn_val->v_quad;
3427 			return (v);
3428 		}
3429 		v->v_quad = tn->tn_val->v_ldbl;
3430 	} else {
3431 		v->v_quad = 1;
3432 	}
3433 
3434 	/* integral constant expression expected */
3435 	if (required)
3436 		error(55);
3437 	else
3438 		c99ism(318);
3439 
3440 	if (!isityp(v->v_tspec))
3441 		v->v_tspec = INT;
3442 
3443 	return (v);
3444 }
3445 
3446 /*
3447  * Perform some tests on expressions which can't be done in build() and
3448  * functions called by build(). These tests must be done here because
3449  * we need some information about the context in which the operations
3450  * are performed.
3451  * After all tests are performed, expr() frees the memory which is used
3452  * for the expression.
3453  */
3454 void
3455 expr(tnode_t *tn, int vctx, int tctx, int dofreeblk)
3456 {
3457 
3458 	if (tn == NULL && nerr == 0)
3459 		LERROR("expr()");
3460 
3461 	if (tn == NULL) {
3462 		tfreeblk();
3463 		return;
3464 	}
3465 
3466 	/* expr() is also called in global initialisations */
3467 	if (dcs->d_ctx != EXTERN)
3468 		chkreach();
3469 
3470 	chkmisc(tn, vctx, tctx, !tctx, 0, 0, 0);
3471 	if (tn->tn_op == ASSIGN) {
3472 		if (hflag && tctx)
3473 			/* assignment in conditional context */
3474 			warning(159);
3475 	} else if (tn->tn_op == CON) {
3476 		if (hflag && tctx && !ccflg)
3477 			/* constant in conditional context */
3478 			warning(161);
3479 	}
3480 	if (!modtab[tn->tn_op].m_sideeff) {
3481 		/*
3482 		 * for left operands of COMMA this warning is already
3483 		 * printed
3484 		 */
3485 		if (tn->tn_op != COMMA && !vctx && !tctx)
3486 			nulleff(tn);
3487 	}
3488 	if (dflag)
3489 		displexpr(tn, 0);
3490 
3491 	/* free the tree memory */
3492 	if (dofreeblk)
3493 		tfreeblk();
3494 }
3495 
3496 static void
3497 nulleff(tnode_t *tn)
3498 {
3499 
3500 	if (!hflag)
3501 		return;
3502 
3503 	while (!modtab[tn->tn_op].m_sideeff) {
3504 		if (tn->tn_op == CVT && tn->tn_type->t_tspec == VOID) {
3505 			tn = tn->tn_left;
3506 		} else if (tn->tn_op == LOGAND || tn->tn_op == LOGOR) {
3507 			/*
3508 			 * && and || have a side effect if the right operand
3509 			 * has a side effect.
3510 			 */
3511 			tn = tn->tn_right;
3512 		} else if (tn->tn_op == QUEST) {
3513 			/*
3514 			 * ? has a side effect if at least one of its right
3515 			 * operands has a side effect
3516 			 */
3517 			tn = tn->tn_right;
3518 		} else if (tn->tn_op == COLON || tn->tn_op == COMMA) {
3519 			/*
3520 			 * : has a side effect if at least one of its operands
3521 			 * has a side effect
3522 			 */
3523 			if (modtab[tn->tn_left->tn_op].m_sideeff) {
3524 				tn = tn->tn_left;
3525 			} else if (modtab[tn->tn_right->tn_op].m_sideeff) {
3526 				tn = tn->tn_right;
3527 			} else {
3528 				break;
3529 			}
3530 		} else {
3531 			break;
3532 		}
3533 	}
3534 	if (!modtab[tn->tn_op].m_sideeff)
3535 		/* expression has null effect */
3536 		warning(129);
3537 }
3538 
3539 /*
3540  * Dump an expression to stdout
3541  * only used for debugging
3542  */
3543 static void
3544 displexpr(tnode_t *tn, int offs)
3545 {
3546 	uint64_t uq;
3547 
3548 	if (tn == NULL) {
3549 		(void)printf("%*s%s\n", offs, "", "NULL");
3550 		return;
3551 	}
3552 	(void)printf("%*sop %s  ", offs, "", modtab[tn->tn_op].m_name);
3553 
3554 	if (tn->tn_op == NAME) {
3555 		(void)printf("%s: %s ",
3556 			     tn->tn_sym->s_name, scltoa(tn->tn_sym->s_scl));
3557 	} else if (tn->tn_op == CON && isftyp(tn->tn_type->t_tspec)) {
3558 		(void)printf("%#g ", (double)tn->tn_val->v_ldbl);
3559 	} else if (tn->tn_op == CON && isityp(tn->tn_type->t_tspec)) {
3560 		uq = tn->tn_val->v_quad;
3561 		(void)printf("0x %08lx %08lx ", (long)(uq >> 32) & 0xffffffffl,
3562 			     (long)uq & 0xffffffffl);
3563 	} else if (tn->tn_op == CON) {
3564 		if (tn->tn_type->t_tspec != PTR)
3565 			LERROR("displexpr()");
3566 		(void)printf("0x%0*lx ", (int)(sizeof (void *) * CHAR_BIT / 4),
3567 			     (u_long)tn->tn_val->v_quad);
3568 	} else if (tn->tn_op == STRING) {
3569 		if (tn->tn_strg->st_tspec == CHAR) {
3570 			(void)printf("\"%s\"", tn->tn_strg->st_cp);
3571 		} else {
3572 			char	*s;
3573 			size_t	n;
3574 			n = MB_CUR_MAX * (tn->tn_strg->st_len + 1);
3575 			s = xmalloc(n);
3576 			(void)wcstombs(s, tn->tn_strg->st_wcp, n);
3577 			(void)printf("L\"%s\"", s);
3578 			free(s);
3579 		}
3580 		(void)printf(" ");
3581 	} else if (tn->tn_op == FSEL) {
3582 		(void)printf("o=%d, l=%d ", tn->tn_type->t_foffs,
3583 			     tn->tn_type->t_flen);
3584 	}
3585 	(void)printf("%s\n", ttos(tn->tn_type));
3586 	if (tn->tn_op == NAME || tn->tn_op == CON || tn->tn_op == STRING)
3587 		return;
3588 	displexpr(tn->tn_left, offs + 2);
3589 	if (modtab[tn->tn_op].m_binary ||
3590 	    (tn->tn_op == PUSH && tn->tn_right != NULL)) {
3591 		displexpr(tn->tn_right, offs + 2);
3592 	}
3593 }
3594 
3595 /*
3596  * Called by expr() to recursively perform some tests.
3597  */
3598 /* ARGSUSED */
3599 void
3600 chkmisc(tnode_t *tn, int vctx, int tctx, int eqwarn, int fcall, int rvdisc,
3601 	int szof)
3602 {
3603 	tnode_t	*ln, *rn;
3604 	mod_t	*mp;
3605 	int	nrvdisc, cvctx, ctctx;
3606 	op_t	op;
3607 	scl_t	sc;
3608 	dinfo_t	*di;
3609 
3610 	if (tn == NULL)
3611 		return;
3612 
3613 	ln = tn->tn_left;
3614 	rn = tn->tn_right;
3615 	mp = &modtab[op = tn->tn_op];
3616 
3617 	switch (op) {
3618 	case AMPER:
3619 		if (ln->tn_op == NAME && (reached || rchflg)) {
3620 			if (!szof)
3621 				setsflg(ln->tn_sym);
3622 			setuflg(ln->tn_sym, fcall, szof);
3623 		}
3624 		if (ln->tn_op == STAR && ln->tn_left->tn_op == PLUS)
3625 			/* check the range of array indices */
3626 			chkaidx(ln->tn_left, 1);
3627 		break;
3628 	case LOAD:
3629 		if (ln->tn_op == STAR && ln->tn_left->tn_op == PLUS)
3630 			/* check the range of array indices */
3631 			chkaidx(ln->tn_left, 0);
3632 		/* FALLTHROUGH */
3633 	case PUSH:
3634 	case INCBEF:
3635 	case DECBEF:
3636 	case INCAFT:
3637 	case DECAFT:
3638 	case ADDASS:
3639 	case SUBASS:
3640 	case MULASS:
3641 	case DIVASS:
3642 	case MODASS:
3643 	case ANDASS:
3644 	case ORASS:
3645 	case XORASS:
3646 	case SHLASS:
3647 	case SHRASS:
3648 	case REAL:
3649 	case IMAG:
3650 		if (ln->tn_op == NAME && (reached || rchflg)) {
3651 			sc = ln->tn_sym->s_scl;
3652 			/*
3653 			 * Look if there was a asm statement in one of the
3654 			 * compound statements we are in. If not, we don't
3655 			 * print a warning.
3656 			 */
3657 			for (di = dcs; di != NULL; di = di->d_nxt) {
3658 				if (di->d_asm)
3659 					break;
3660 			}
3661 			if (sc != EXTERN && sc != STATIC &&
3662 			    !ln->tn_sym->s_set && !szof && di == NULL) {
3663 				/* %s may be used before set */
3664 				warning(158, ln->tn_sym->s_name);
3665 				setsflg(ln->tn_sym);
3666 			}
3667 			setuflg(ln->tn_sym, 0, 0);
3668 		}
3669 		break;
3670 	case ASSIGN:
3671 		if (ln->tn_op == NAME && !szof && (reached || rchflg)) {
3672 			setsflg(ln->tn_sym);
3673 			if (ln->tn_sym->s_scl == EXTERN)
3674 				outusg(ln->tn_sym);
3675 		}
3676 		if (ln->tn_op == STAR && ln->tn_left->tn_op == PLUS)
3677 			/* check the range of array indices */
3678 			chkaidx(ln->tn_left, 0);
3679 		break;
3680 	case CALL:
3681 		if (ln->tn_op != AMPER || ln->tn_left->tn_op != NAME)
3682 			LERROR("chkmisc(op=%s != %s || %s != %s)",
3683 			    getopname(ln->tn_op), getopname(AMPER),
3684 			    getopname(ln->tn_left->tn_op), getopname(NAME));
3685 		if (!szof)
3686 			outcall(tn, vctx || tctx, rvdisc);
3687 		break;
3688 	case EQ:
3689 		/* equality operator "==" found where "=" was exp. */
3690 		if (hflag && eqwarn)
3691 			warning(160);
3692 		break;
3693 	case CON:
3694 	case NAME:
3695 	case STRING:
3696 		return;
3697 		/* LINTED206: (enumeration values not handled in switch) */
3698 	case OR:
3699 	case XOR:
3700 	case NE:
3701 	case GE:
3702 	case GT:
3703 	case LE:
3704 	case LT:
3705 	case SHR:
3706 	case SHL:
3707 	case MINUS:
3708 	case PLUS:
3709 	case MOD:
3710 	case DIV:
3711 	case MULT:
3712 	case STAR:
3713 	case UMINUS:
3714 	case UPLUS:
3715 	case DEC:
3716 	case INC:
3717 	case COMPL:
3718 	case NOT:
3719 	case POINT:
3720 	case ARROW:
3721 	case NOOP:
3722 	case AND:
3723 	case FARG:
3724 	case CASE:
3725 	case INIT:
3726 	case RETURN:
3727 	case ICALL:
3728 	case CVT:
3729 	case COMMA:
3730 	case FSEL:
3731 	case COLON:
3732 	case QUEST:
3733 	case LOGOR:
3734 	case LOGAND:
3735 		break;
3736 	}
3737 
3738 	cvctx = mp->m_vctx;
3739 	ctctx = mp->m_tctx;
3740 	/*
3741 	 * values of operands of ':' are not used if the type of at least
3742 	 * one of the operands (for gcc compatibility) is void
3743 	 * XXX test/value context of QUEST should probably be used as
3744 	 * context for both operands of COLON
3745 	 */
3746 	if (op == COLON && tn->tn_type->t_tspec == VOID)
3747 		cvctx = ctctx = 0;
3748 	nrvdisc = op == CVT && tn->tn_type->t_tspec == VOID;
3749 	chkmisc(ln, cvctx, ctctx, mp->m_eqwarn, op == CALL, nrvdisc, szof);
3750 
3751 	switch (op) {
3752 	case PUSH:
3753 		if (rn != NULL)
3754 			chkmisc(rn, 0, 0, mp->m_eqwarn, 0, 0, szof);
3755 		break;
3756 	case LOGAND:
3757 	case LOGOR:
3758 		chkmisc(rn, 0, 1, mp->m_eqwarn, 0, 0, szof);
3759 		break;
3760 	case COLON:
3761 		chkmisc(rn, cvctx, ctctx, mp->m_eqwarn, 0, 0, szof);
3762 		break;
3763 	case COMMA:
3764 		chkmisc(rn, vctx, tctx, mp->m_eqwarn, 0, 0, szof);
3765 		break;
3766 	default:
3767 		if (mp->m_binary)
3768 			chkmisc(rn, 1, 0, mp->m_eqwarn, 0, 0, szof);
3769 		break;
3770 	}
3771 
3772 }
3773 
3774 /*
3775  * Checks the range of array indices, if possible.
3776  * amper is set if only the address of the element is used. This
3777  * means that the index is allowd to refere to the first element
3778  * after the array.
3779  */
3780 static void
3781 chkaidx(tnode_t *tn, int amper)
3782 {
3783 	int	dim;
3784 	tnode_t	*ln, *rn;
3785 	int	elsz;
3786 	int64_t	con;
3787 
3788 	ln = tn->tn_left;
3789 	rn = tn->tn_right;
3790 
3791 	/* We can only check constant indices. */
3792 	if (rn->tn_op != CON)
3793 		return;
3794 
3795 	/* Return if the left node does not stem from an array. */
3796 	if (ln->tn_op != AMPER)
3797 		return;
3798 	if (ln->tn_left->tn_op != STRING && ln->tn_left->tn_op != NAME)
3799 		return;
3800 	if (ln->tn_left->tn_type->t_tspec != ARRAY)
3801 		return;
3802 
3803 	/*
3804 	 * For incomplete array types, we can print a warning only if
3805 	 * the index is negative.
3806 	 */
3807 	if (incompl(ln->tn_left->tn_type) && rn->tn_val->v_quad >= 0)
3808 		return;
3809 
3810 	/* Get the size of one array element */
3811 	if ((elsz = length(ln->tn_type->t_subt, NULL)) == 0)
3812 		return;
3813 	elsz /= CHAR_BIT;
3814 
3815 	/* Change the unit of the index from bytes to element size. */
3816 	if (isutyp(rn->tn_type->t_tspec)) {
3817 		con = (uint64_t)rn->tn_val->v_quad / elsz;
3818 	} else {
3819 		con = rn->tn_val->v_quad / elsz;
3820 	}
3821 
3822 	dim = ln->tn_left->tn_type->t_dim + (amper ? 1 : 0);
3823 
3824 	if (!isutyp(rn->tn_type->t_tspec) && con < 0) {
3825 		/* array subscript cannot be negative: %ld */
3826 		warning(167, (long)con);
3827 	} else if (dim > 0 && (uint64_t)con >= (uint64_t)dim) {
3828 		/* array subscript cannot be > %d: %ld */
3829 		warning(168, dim - 1, (long)con);
3830 	}
3831 }
3832 
3833 /*
3834  * Check for ordered comparisons of unsigned values with 0.
3835  */
3836 static void
3837 chkcomp(op_t op, tnode_t *ln, tnode_t *rn)
3838 {
3839 	char buf[64];
3840 	tspec_t	lt, rt;
3841 	mod_t	*mp;
3842 
3843 	lt = ln->tn_type->t_tspec;
3844 	rt = rn->tn_type->t_tspec;
3845 	mp = &modtab[op];
3846 
3847 	if (ln->tn_op != CON && rn->tn_op != CON)
3848 		return;
3849 
3850 	if (!isityp(lt) || !isityp(rt))
3851 		return;
3852 
3853 	if ((hflag || pflag) && lt == CHAR && rn->tn_op == CON &&
3854 	    (rn->tn_val->v_quad < 0 ||
3855 	     rn->tn_val->v_quad > (int)~(~0U << (CHAR_BIT - 1)))) {
3856 		/* nonportable character comparison, op %s */
3857 		warning(230, mp->m_name);
3858 		return;
3859 	}
3860 	if ((hflag || pflag) && rt == CHAR && ln->tn_op == CON &&
3861 	    (ln->tn_val->v_quad < 0 ||
3862 	     ln->tn_val->v_quad > (int)~(~0U << (CHAR_BIT - 1)))) {
3863 		/* nonportable character comparison, op %s */
3864 		warning(230, mp->m_name);
3865 		return;
3866 	}
3867 	if (isutyp(lt) && !isutyp(rt) &&
3868 	    rn->tn_op == CON && rn->tn_val->v_quad <= 0) {
3869 		if (rn->tn_val->v_quad < 0) {
3870 			/* comparison of %s with %s, op %s */
3871 			warning(162, tyname(buf, sizeof(buf), ln->tn_type),
3872 			    "negative constant", mp->m_name);
3873 		} else if (op == LT || op == GE || (hflag && op == LE)) {
3874 			/* comparison of %s with %s, op %s */
3875 			warning(162, tyname(buf, sizeof(buf), ln->tn_type),
3876 			    "0", mp->m_name);
3877 		}
3878 		return;
3879 	}
3880 	if (isutyp(rt) && !isutyp(lt) &&
3881 	    ln->tn_op == CON && ln->tn_val->v_quad <= 0) {
3882 		if (ln->tn_val->v_quad < 0) {
3883 			/* comparison of %s with %s, op %s */
3884 			warning(162, "negative constant",
3885 			    tyname(buf, sizeof(buf), rn->tn_type), mp->m_name);
3886 		} else if (op == GT || op == LE || (hflag && op == GE)) {
3887 			/* comparison of %s with %s, op %s */
3888 			warning(162, "0", tyname(buf, sizeof(buf), rn->tn_type),
3889 			    mp->m_name);
3890 		}
3891 		return;
3892 	}
3893 }
3894 
3895 /*
3896  * Takes an expression an returns 0 if this expression can be used
3897  * for static initialisation, otherwise -1.
3898  *
3899  * Constant initialisation expressions must be constant or an address
3900  * of a static object with an optional offset. In the first case,
3901  * the result is returned in *offsp. In the second case, the static
3902  * object is returned in *symp and the offset in *offsp.
3903  *
3904  * The expression can consist of PLUS, MINUS, AMPER, NAME, STRING and
3905  * CON. Type conversions are allowed if they do not change binary
3906  * representation (including width).
3907  */
3908 int
3909 conaddr(tnode_t *tn, sym_t **symp, ptrdiff_t *offsp)
3910 {
3911 	sym_t	*sym;
3912 	ptrdiff_t offs1, offs2;
3913 	tspec_t	t, ot;
3914 
3915 	switch (tn->tn_op) {
3916 	case MINUS:
3917 		if (tn->tn_right->tn_op == CVT)
3918 			return conaddr(tn->tn_right, symp, offsp);
3919 		else if (tn->tn_right->tn_op != CON)
3920 			return (-1);
3921 		/* FALLTHROUGH */
3922 	case PLUS:
3923 		offs1 = offs2 = 0;
3924 		if (tn->tn_left->tn_op == CON) {
3925 			offs1 = (ptrdiff_t)tn->tn_left->tn_val->v_quad;
3926 			if (conaddr(tn->tn_right, &sym, &offs2) == -1)
3927 				return (-1);
3928 		} else if (tn->tn_right->tn_op == CON) {
3929 			offs2 = (ptrdiff_t)tn->tn_right->tn_val->v_quad;
3930 			if (tn->tn_op == MINUS)
3931 				offs2 = -offs2;
3932 			if (conaddr(tn->tn_left, &sym, &offs1) == -1)
3933 				return (-1);
3934 		} else {
3935 			return (-1);
3936 		}
3937 		*symp = sym;
3938 		*offsp = offs1 + offs2;
3939 		break;
3940 	case AMPER:
3941 		if (tn->tn_left->tn_op == NAME) {
3942 			*symp = tn->tn_left->tn_sym;
3943 			*offsp = 0;
3944 		} else if (tn->tn_left->tn_op == STRING) {
3945 			/*
3946 			 * If this would be the front end of a compiler we
3947 			 * would return a label instead of 0.
3948 			 */
3949 			*offsp = 0;
3950 		}
3951 		break;
3952 	case CVT:
3953 		t = tn->tn_type->t_tspec;
3954 		ot = tn->tn_left->tn_type->t_tspec;
3955 		if ((!isityp(t) && t != PTR) || (!isityp(ot) && ot != PTR))
3956 			return (-1);
3957 #ifdef notdef
3958 		/*
3959 		 * consider:
3960 		 * 	struct foo {
3961 		 *	    unsigned char a;
3962 		 *      } f = {
3963 		 *          (u_char)(u_long)(&(((struct foo *)0)->a))
3964 		 *	};
3965 		 * since psize(u_long) != psize(u_char) this fails.
3966 		 */
3967 		else if (psize(t) != psize(ot))
3968 			return (-1);
3969 #endif
3970 		if (conaddr(tn->tn_left, symp, offsp) == -1)
3971 			return (-1);
3972 		break;
3973 	default:
3974 		return (-1);
3975 	}
3976 	return (0);
3977 }
3978 
3979 /*
3980  * Concatenate two string constants.
3981  */
3982 strg_t *
3983 catstrg(strg_t *strg1, strg_t *strg2)
3984 {
3985 	size_t	len1, len2, len;
3986 
3987 	if (strg1->st_tspec != strg2->st_tspec) {
3988 		/* cannot concatenate wide and regular string literals */
3989 		error(292);
3990 		return (strg1);
3991 	}
3992 
3993 	len1 = strg1->st_len;
3994 	len2 = strg2->st_len + 1;	/* + NUL */
3995 	len = len1 + len2;
3996 
3997 #define COPY(F) \
3998     do { \
3999 	strg1->F = xrealloc(strg1->F, len * sizeof(*strg1->F)); \
4000 	(void)memcpy(strg1->F + len1, strg2->F, len2 * sizeof(*strg1->F)); \
4001 	free(strg2->F); \
4002     } while (/*CONSTCOND*/0)
4003 
4004 	if (strg1->st_tspec == CHAR)
4005 		COPY(st_cp);
4006 	else
4007 		COPY(st_wcp);
4008 
4009 	strg1->st_len = len - 1; /* - NUL */;
4010 	free(strg2);
4011 
4012 	return (strg1);
4013 }
4014 
4015 /*
4016  * Print a warning if the given node has operands which should be
4017  * parenthesized.
4018  *
4019  * XXX Does not work if an operand is a constant expression. Constant
4020  * expressions are already folded.
4021  */
4022 static void
4023 precconf(tnode_t *tn)
4024 {
4025 	tnode_t	*ln, *rn;
4026 	op_t	lop, rop = NOOP;
4027 	int	lparn, rparn = 0;
4028 	mod_t	*mp;
4029 	int	dowarn;
4030 
4031 	if (!hflag)
4032 		return;
4033 
4034 	mp = &modtab[tn->tn_op];
4035 
4036 	lparn = 0;
4037 	for (ln = tn->tn_left; ln->tn_op == CVT; ln = ln->tn_left)
4038 		lparn |= ln->tn_parn;
4039 	lparn |= ln->tn_parn;
4040 	lop = ln->tn_op;
4041 
4042 	if (mp->m_binary) {
4043 		rparn = 0;
4044 		for (rn = tn->tn_right; tn->tn_op == CVT; rn = rn->tn_left)
4045 			rparn |= rn->tn_parn;
4046 		rparn |= rn->tn_parn;
4047 		rop = rn->tn_op;
4048 	}
4049 
4050 	dowarn = 0;
4051 
4052 	switch (tn->tn_op) {
4053 	case SHL:
4054 	case SHR:
4055 		if (!lparn && (lop == PLUS || lop == MINUS)) {
4056 			dowarn = 1;
4057 		} else if (!rparn && (rop == PLUS || rop == MINUS)) {
4058 			dowarn = 1;
4059 		}
4060 		break;
4061 	case LOGOR:
4062 		if (!lparn && lop == LOGAND) {
4063 			dowarn = 1;
4064 		} else if (!rparn && rop == LOGAND) {
4065 			dowarn = 1;
4066 		}
4067 		break;
4068 	case AND:
4069 	case XOR:
4070 	case OR:
4071 		if (!lparn && lop != tn->tn_op) {
4072 			if (lop == PLUS || lop == MINUS) {
4073 				dowarn = 1;
4074 			} else if (lop == AND || lop == XOR) {
4075 				dowarn = 1;
4076 			}
4077 		}
4078 		if (!dowarn && !rparn && rop != tn->tn_op) {
4079 			if (rop == PLUS || rop == MINUS) {
4080 				dowarn = 1;
4081 			} else if (rop == AND || rop == XOR) {
4082 				dowarn = 1;
4083 			}
4084 		}
4085 		break;
4086 		/* LINTED206: (enumeration values not handled in switch) */
4087 	case DECAFT:
4088 	case XORASS:
4089 	case SHLASS:
4090 	case NOOP:
4091 	case ARROW:
4092 	case ORASS:
4093 	case POINT:
4094 	case NAME:
4095 	case NOT:
4096 	case COMPL:
4097 	case CON:
4098 	case INC:
4099 	case STRING:
4100 	case DEC:
4101 	case INCBEF:
4102 	case DECBEF:
4103 	case INCAFT:
4104 	case FSEL:
4105 	case CALL:
4106 	case COMMA:
4107 	case CVT:
4108 	case ICALL:
4109 	case LOAD:
4110 	case PUSH:
4111 	case RETURN:
4112 	case INIT:
4113 	case CASE:
4114 	case FARG:
4115 	case SUBASS:
4116 	case ADDASS:
4117 	case MODASS:
4118 	case DIVASS:
4119 	case MULASS:
4120 	case ASSIGN:
4121 	case COLON:
4122 	case QUEST:
4123 	case LOGAND:
4124 	case NE:
4125 	case EQ:
4126 	case GE:
4127 	case GT:
4128 	case LE:
4129 	case LT:
4130 	case MINUS:
4131 	case PLUS:
4132 	case MOD:
4133 	case DIV:
4134 	case MULT:
4135 	case AMPER:
4136 	case STAR:
4137 	case UMINUS:
4138 	case SHRASS:
4139 	case UPLUS:
4140 	case ANDASS:
4141 	case REAL:
4142 	case IMAG:
4143 		break;
4144 	}
4145 
4146 	if (dowarn) {
4147 		/* precedence confusion possible: parenthesize! */
4148 		warning(169);
4149 	}
4150 
4151 }
4152