[unix-history] / usr / src / usr.bin / pascal / src / stkrval.c

/* Copyright (c) 1979 Regents of the University of California */

static	char sccsid[] = "@(#)stkrval.c 1.3 %G%";

#include "whoami.h"
#include "0.h"
#include "tree.h"
#include "opcode.h"
#include "objfmt.h"
#ifdef PC
#   include "pcops.h"
#endif PC

/*
 * stkrval Rvalue - an expression, and coerce it to be a stack quantity.
 *
 * Contype is the type that the caller would prefer, nand is important
 * if constant sets or constant strings are involved, the latter
 * because of string padding.
 */
/*
 * for the obj version, this is a copy of rvalue hacked to use fancy new
 * push-onto-stack-and-convert opcodes.
 * for the pc version, i just call rvalue and convert if i have to,
 * based on the return type of rvalue.
 */
struct nl *
stkrval(r, contype , required )
	register int *r;
	struct nl *contype;
	long	required;
{
	register struct nl *p;
	register struct nl *q;
	register char *cp, *cp1;
	register int c, w;
	int **pt;
	long l;
	double f;

	if (r == NIL)
		return (NIL);
	if (nowexp(r))
		return (NIL);
	/*
	 * The root of the tree tells us what sort of expression we have.
	 */
	switch (r[0]) {

	/*
	 * The constant nil
	 */
	case T_NIL:
#		ifdef OBJ
		    put(2, O_CON14, 0);
#		endif OBJ
#		ifdef PC
		    putleaf( P2ICON , 0 , 0 , P2INT , 0 );
#		endif PC
		return (nl+TNIL);

	case T_FCALL:
	case T_VAR:
		p = lookup(r[2]);
		if (p == NIL || p->class == BADUSE)
			return (NIL);
		switch (p->class) {
		case VAR:
			/*
			  if a variable is
			 * qualified then get
			 * the rvalue by a
			 * stklval and an ind.
			 */
			if (r[3] != NIL)
				goto ind;
			q = p->type;
			if (q == NIL)
				return (NIL);
			if (classify(q) == TSTR)
				return(stklval(r, NOFLAGS));
#			ifdef OBJ
			    w = width(q);
			    switch (w) {
			    case 8:
				    put(2, O_RV8 | bn << 8+INDX, p->value[0]);
				    return(q);
			    case 4:
				    put(2, O_RV4 | bn << 8+INDX, p->value[0]);
				    return(q);
			    case 2:
				    put(2, O_RV24 | bn << 8+INDX, p->value[0]);
				    return(q);
			    case 1:
				    put(2, O_RV14 | bn << 8+INDX, p->value[0]);
				    return(q);
			    default:
				    put(3, O_RV | bn << 8+INDX, p->value[0], w);
				    return(q);
			     }
#			endif OBJ
#			ifdef PC
			     return rvalue( r , contype , required );
#			endif PC

		case WITHPTR:
		case REF:
			/*
			 * A stklval for these
			 * is actually what one
			 * might consider a rvalue.
			 */
ind:
			q = stklval(r, NOFLAGS);
			if (q == NIL)
				return (NIL);
			if (classify(q) == TSTR)
				return(q);
#			ifdef OBJ
			    w = width(q);
			    switch (w) {
				    case 8:
					    put(1, O_IND8);
					    return(q);
				    case 4:
					    put(1, O_IND4);
					    return(q);
				    case 2:
					    put(1, O_IND24);
					    return(q);
				    case 1:
					    put(1, O_IND14);
					    return(q);
				    default:
					    put(2, O_IND, w);
					    return(q);
			    }
#			endif OBJ
#			ifdef PC
			    if ( required == RREQ ) {
				putop( P2UNARY P2MUL , p2type( q ) );
			    }
			    return q;
#			endif PC

		case CONST:
			if (r[3] != NIL) {
				error("%s is a constant and cannot be qualified", r[2]);
				return (NIL);
			}
			q = p->type;
			if (q == NIL)
				return (NIL);
			if (q == nl+TSTR) {
				/*
				 * Find the size of the string
				 * constant if needed.
				 */
				cp = p->ptr[0];
cstrng:
				cp1 = cp;
				for (c = 0; *cp++; c++)
					continue;
				w = 0;
				if (contype != NIL && !opt('s')) {
					if (width(contype) < c && classify(contype) == TSTR) {
						error("Constant string too long");
						return (NIL);
					}
					w = width(contype) - c;
				}
#				ifdef OBJ
				    put(2, O_LVCON, lenstr(cp1, w));
				    putstr(cp1, w);
#				endif OBJ
#				ifdef PC
				    putCONG( cp1 , c + w , LREQ );
#				endif PC
				/*
				 * Define the string temporarily
				 * so later people can know its
				 * width.
				 * cleaned out by stat.
				 */
				q = defnl(0, STR, 0, c);
				q->type = q;
				return (q);
			}
			if (q == nl+T1CHAR) {
#			    ifdef OBJ
				put(2, O_CONC4, p->value[0]);
#			    endif OBJ
#			    ifdef PC
				putleaf( P2ICON , p -> value[0] , 0 , P2CHAR , 0 );
#			    endif PC
			    return(q);
			}
			/*
			 * Every other kind of constant here
			 */
#			ifdef OBJ
			    switch (width(q)) {
			    case 8:
#ifndef DEBUG
				    put(2, O_CON8, p->real);
				    return(q);
#else
				    if (hp21mx) {
					    f = p->real;
					    conv(&f);
					    l = f.plong;
					    put(2, O_CON4, l);
				    } else
					    put(2, O_CON8, p->real);
				    return(q);
#endif
			    case 4:
				    put(2, O_CON4, p->range[0]);
				    return(q);
			    case 2:
				    put(2, O_CON24, (short)p->range[0]);
				    return(q);
			    case 1:
				    put(2, O_CON14, (short)p->range[0]);
				    return(q);
			    default:
				    panic("stkrval");
			    }
#			endif OBJ
#			ifdef PC
			    return rvalue( r , contype , required );
#			endif PC

		case FUNC:
		case FFUNC:
			/*
			 * Function call
			 */
			pt = (int **)r[3];
			if (pt != NIL) {
				switch (pt[1][0]) {
				case T_PTR:
				case T_ARGL:
				case T_ARY:
				case T_FIELD:
					error("Can't qualify a function result value");
					return (NIL);
				}
			}
#			ifdef OBJ
			    q = p->type;
			    if (classify(q) == TSTR) {
				    c = width(q);
				    put(2, O_LVCON, even(c+1));
				    putstr("", c);
				    put(1, O_SDUP4);
				    p = funccod(r);
				    put(2, O_AS, c);
				    return(p);
			    }
			    p = funccod(r);
			    if (width(p) <= 2)
				    put(1, O_STOI);
#			endif OBJ
#			ifdef PC
			    p = pcfunccod( r );
#			endif PC
			return (p);

		case TYPE:
			error("Type names (e.g. %s) allowed only in declarations", p->symbol);
			return (NIL);

		case PROC:
		case FPROC:
			error("Procedure %s found where expression required", p->symbol);
			return (NIL);
		default:
			panic("stkrvid");
		}
	case T_PLUS:
	case T_MINUS:
	case T_NOT:
	case T_AND:
	case T_OR:
	case T_DIVD:
	case T_MULT:
	case T_SUB:
	case T_ADD:
	case T_MOD:
	case T_DIV:
	case T_EQ:
	case T_NE:
	case T_GE:
	case T_LE:
	case T_GT:
	case T_LT:
	case T_IN:
		p = rvalue(r, contype , required );
#		ifdef OBJ
		    if (width(p) <= 2)
			    put(1, O_STOI);
#		endif OBJ
		return (p);
	case T_CSET:
		p = rvalue(r, contype , required );
		return (p);
	default:
		if (r[2] == NIL)
			return (NIL);
		switch (r[0]) {
		default:
			panic("stkrval3");

		/*
		 * An octal number
		 */
		case T_BINT:
			f = a8tol(r[2]);
			goto conint;
	
		/*
		 * A decimal number
		 */
		case T_INT:
			f = atof(r[2]);
conint:
			if (f > MAXINT || f < MININT) {
				error("Constant too large for this implementation");
				return (NIL);
			}
			l = f;
			if (bytes(l, l) <= 2) {
#			    ifdef OBJ
				put(2, O_CON24, (short)l);
#			    endif OBJ
#			    ifdef PC
				putleaf( P2ICON , (short) l , 0 , P2INT , 0 );
#			    endif PC
				return(nl+T4INT);
			}
#			ifdef OBJ
			    put(2, O_CON4, l); 
#			endif OBJ
#			ifdef PC
			    putleaf( P2ICON , l , 0 , P2INT , 0 );
#			endif PC
			return (nl+T4INT);
	
		/*
		 * A floating point number
		 */
		case T_FINT:
#		   	ifdef OBJ
			    put(2, O_CON8, atof(r[2]));
#			endif OBJ
#			ifdef PC
			    putCON8( atof( r[2] ) );
#			endif PC
			return (nl+TDOUBLE);
	
		/*
		 * Constant strings.  Note that constant characters
		 * are constant strings of length one; there is
		 * no constant string of length one.
		 */
		case T_STRNG:
			cp = r[2];
			if (cp[1] == 0) {
#				ifdef OBJ
				    put(2, O_CONC4, cp[0]);
#				endif OBJ
#				ifdef PC
				    putleaf( P2ICON , cp[0] , 0 , P2CHAR , 0 );
#				endif PC
				return(nl+T1CHAR);
			}
			goto cstrng;
		}
	
	}
}
Commit	Line	Data
28e6b83a PK	1	/* Copyright (c) 1979 Regents of the University of California */
28e6b83a PK	2
c4e911b6	3	static char sccsid[] = "@(#)stkrval.c 1.3 %G%";
28e6b83a PK	4
	5	#include "whoami.h"
	6	#include "0.h"
	7	#include "tree.h"
	8	#include "opcode.h"
	9	#include "objfmt.h"
	10	#ifdef PC
	11	# include "pcops.h"
	12	#endif PC
	13
	14	/*
	15	* stkrval Rvalue - an expression, and coerce it to be a stack quantity.
	16	*
	17	* Contype is the type that the caller would prefer, nand is important
	18	* if constant sets or constant strings are involved, the latter
	19	* because of string padding.
	20	*/
	21	/*
	22	* for the obj version, this is a copy of rvalue hacked to use fancy new
	23	* push-onto-stack-and-convert opcodes.
	24	* for the pc version, i just call rvalue and convert if i have to,
	25	* based on the return type of rvalue.
	26	*/
	27	struct nl *
	28	stkrval(r, contype , required )
	29	register int *r;
	30	struct nl *contype;
	31	long required;
	32	{
	33	register struct nl *p;
	34	register struct nl *q;
	35	register char cp, cp1;
	36	register int c, w;
	37	int **pt;
	38	long l;
	39	double f;
	40
	41	if (r == NIL)
	42	return (NIL);
	43	if (nowexp(r))
	44	return (NIL);
	45	/*
	46	* The root of the tree tells us what sort of expression we have.
	47	*/
	48	switch (r[0]) {
	49
	50	/*
	51	* The constant nil
	52	*/
	53	case T_NIL:
	54	# ifdef OBJ
	55	put(2, O_CON14, 0);
	56	# endif OBJ
	57	# ifdef PC
	58	putleaf( P2ICON , 0 , 0 , P2INT , 0 );
	59	# endif PC
	60	return (nl+TNIL);
	61
	62	case T_FCALL:
	63	case T_VAR:
	64	p = lookup(r[2]);
	65	if (p == NIL \|\| p->class == BADUSE)
	66	return (NIL);
	67	switch (p->class) {
68	case VAR:
69	/*
70	if a variable is
71	* qualified then get
72	* the rvalue by a
73	* stklval and an ind.
74	*/
75	if (r[3] != NIL)
76	goto ind;
77	q = p->type;
78	if (q == NIL)
79	return (NIL);
80	if (classify(q) == TSTR)
81	return(stklval(r, NOFLAGS));
82	# ifdef OBJ
83	w = width(q);
84	switch (w) {
85	case 8:
86	put(2, O_RV8 \| bn << 8+INDX, p->value[0]);
87	return(q);
88	case 4:
89	put(2, O_RV4 \| bn << 8+INDX, p->value[0]);
90	return(q);
91	case 2:
92	put(2, O_RV24 \| bn << 8+INDX, p->value[0]);
93	return(q);
94	case 1:
95	put(2, O_RV14 \| bn << 8+INDX, p->value[0]);
96	return(q);
97	default:
98	put(3, O_RV \| bn << 8+INDX, p->value[0], w);
99	return(q);
100	}
101	# endif OBJ
102	# ifdef PC
103	return rvalue( r , contype , required );
104	# endif PC
105
106	case WITHPTR:
107	case REF:
108	/*
109	* A stklval for these
110	* is actually what one
111	* might consider a rvalue.
112	*/
113	ind:
114	q = stklval(r, NOFLAGS);
115	if (q == NIL)
116	return (NIL);
117	if (classify(q) == TSTR)
118	return(q);
119	# ifdef OBJ
120	w = width(q);
121	switch (w) {
122	case 8:
123	put(1, O_IND8);
124	return(q);
125	case 4:
126	put(1, O_IND4);
127	return(q);
128	case 2:
129	put(1, O_IND24);
130	return(q);
131	case 1:
132	put(1, O_IND14);
133	return(q);
134	default:
135	put(2, O_IND, w);
136	return(q);
137	}
138	# endif OBJ
139	# ifdef PC
140	if ( required == RREQ ) {
141	putop( P2UNARY P2MUL , p2type( q ) );
142	}
143	return q;
144	# endif PC
145
146	case CONST:
147	if (r[3] != NIL) {
148	error("%s is a constant and cannot be qualified", r[2]);
149	return (NIL);
150	}
151	q = p->type;
152	if (q == NIL)
153	return (NIL);
154	if (q == nl+TSTR) {
155	/*
156	* Find the size of the string
157	* constant if needed.
158	*/
159	cp = p->ptr[0];
160	cstrng:
161	cp1 = cp;
162	for (c = 0; *cp++; c++)
163	continue;
164	w = 0;
165	if (contype != NIL && !opt('s')) {
166	if (width(contype) < c && classify(contype) == TSTR) {
167	error("Constant string too long");
168	return (NIL);
169	}
170	w = width(contype) - c;
171	}
172	# ifdef OBJ
173	put(2, O_LVCON, lenstr(cp1, w));
174	putstr(cp1, w);
175	# endif OBJ
176	# ifdef PC
177	putCONG( cp1 , c + w , LREQ );
178	# endif PC
179	/*
180	* Define the string temporarily
181	* so later people can know its
182	* width.
183	* cleaned out by stat.
184	*/
185	q = defnl(0, STR, 0, c);
186	q->type = q;
187	return (q);
188	}
189	if (q == nl+T1CHAR) {
190	# ifdef OBJ
191	put(2, O_CONC4, p->value[0]);
192	# endif OBJ
193	# ifdef PC
194	putleaf( P2ICON , p -> value[0] , 0 , P2CHAR , 0 );
195	# endif PC
196	return(q);
197	}
198	/*
199	* Every other kind of constant here
200	*/
201	# ifdef OBJ
202	switch (width(q)) {
203	case 8:
204	#ifndef DEBUG
205	put(2, O_CON8, p->real);
206	return(q);
207	#else
208	if (hp21mx) {
209	f = p->real;
210	conv(&f);
211	l = f.plong;
212	put(2, O_CON4, l);
213	} else
214	put(2, O_CON8, p->real);
215	return(q);
216	#endif
217	case 4:
218	put(2, O_CON4, p->range[0]);
219	return(q);
220	case 2:
221	put(2, O_CON24, (short)p->range[0]);
222	return(q);
223	case 1:
224	put(2, O_CON14, (short)p->range[0]);
225	return(q);
226	default:
227	panic("stkrval");
228	}
229	# endif OBJ
230	# ifdef PC
231	return rvalue( r , contype , required );
232	# endif PC
233
234	case FUNC:
c4e911b6	235	case FFUNC:
28e6b83a PK	236	/*
	237	* Function call
	238	*/
	239	pt = (int **)r[3];
	240	if (pt != NIL) {
	241	switch (pt[1][0]) {
	242	case T_PTR:
	243	case T_ARGL:
	244	case T_ARY:
	245	case T_FIELD:
	246	error("Can't qualify a function result value");
	247	return (NIL);
	248	}
	249	}
	250	# ifdef OBJ
	251	q = p->type;
	252	if (classify(q) == TSTR) {
	253	c = width(q);
	254	put(2, O_LVCON, even(c+1));
	255	putstr("", c);
	256	put(1, O_SDUP4);
	257	p = funccod(r);
	258	put(2, O_AS, c);
	259	return(p);
	260	}
	261	p = funccod(r);
	262	if (width(p) <= 2)
	263	put(1, O_STOI);
	264	# endif OBJ
	265	# ifdef PC
	266	p = pcfunccod( r );
	267	# endif PC
	268	return (p);
	269
	270	case TYPE:
	271	error("Type names (e.g. %s) allowed only in declarations", p->symbol);
	272	return (NIL);
	273
	274	case PROC:
c4e911b6	275	case FPROC:
28e6b83a PK	276	error("Procedure %s found where expression required", p->symbol);
	277	return (NIL);
	278	default:
	279	panic("stkrvid");
	280	}
28e6b83a PK	281	case T_PLUS:
	282	case T_MINUS:
	283	case T_NOT:
	284	case T_AND:
	285	case T_OR:
	286	case T_DIVD:
	287	case T_MULT:
	288	case T_SUB:
	289	case T_ADD:
	290	case T_MOD:
	291	case T_DIV:
	292	case T_EQ:
	293	case T_NE:
	294	case T_GE:
	295	case T_LE:
	296	case T_GT:
	297	case T_LT:
	298	case T_IN:
	299	p = rvalue(r, contype , required );
	300	# ifdef OBJ
	301	if (width(p) <= 2)
	302	put(1, O_STOI);
	303	# endif OBJ
	304	return (p);
a26d837a PK	305	case T_CSET:
	306	p = rvalue(r, contype , required );
	307	return (p);
28e6b83a PK	308	default:
	309	if (r[2] == NIL)
	310	return (NIL);
	311	switch (r[0]) {
	312	default:
	313	panic("stkrval3");
	314
	315	/*
	316	* An octal number
	317	*/
	318	case T_BINT:
	319	f = a8tol(r[2]);
	320	goto conint;
	321
	322	/*
	323	* A decimal number
	324	*/
	325	case T_INT:
	326	f = atof(r[2]);
	327	conint:
	328	if (f > MAXINT \|\| f < MININT) {
	329	error("Constant too large for this implementation");
	330	return (NIL);
	331	}
	332	l = f;
	333	if (bytes(l, l) <= 2) {
	334	# ifdef OBJ
	335	put(2, O_CON24, (short)l);
	336	# endif OBJ
	337	# ifdef PC
	338	putleaf( P2ICON , (short) l , 0 , P2INT , 0 );
	339	# endif PC
	340	return(nl+T4INT);
	341	}
	342	# ifdef OBJ
	343	put(2, O_CON4, l);
	344	# endif OBJ
	345	# ifdef PC
	346	putleaf( P2ICON , l , 0 , P2INT , 0 );
	347	# endif PC
	348	return (nl+T4INT);
	349
	350	/*
	351	* A floating point number
	352	*/
	353	case T_FINT:
	354	# ifdef OBJ
	355	put(2, O_CON8, atof(r[2]));
	356	# endif OBJ
	357	# ifdef PC
	358	putCON8( atof( r[2] ) );
	359	# endif PC
	360	return (nl+TDOUBLE);
	361
	362	/*
	363	* Constant strings. Note that constant characters
	364	* are constant strings of length one; there is
	365	* no constant string of length one.
	366	*/
	367	case T_STRNG:
	368	cp = r[2];
	369	if (cp[1] == 0) {
	370	# ifdef OBJ
	371	put(2, O_CONC4, cp[0]);
372	# endif OBJ
373	# ifdef PC
374	putleaf( P2ICON , cp[0] , 0 , P2CHAR , 0 );
375	# endif PC
376	return(nl+T1CHAR);
377	}
378	goto cstrng;
379	}
380
381	}
382	}