![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to put.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / usr.bin / f77 / src / f77pass1|
Return to put.c CVS log | Up to [CSRG BSD Unix] / 43BSD / usr.bin / f77 / src / f77pass1 |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)put.c 5.1 (Berkeley) 6/7/85";
9: #endif not lint
10:
11: /*
12: * put.c
13: *
14: * Intermediate code generation procedures common to both
15: * Johnson (Portable) and Ritchie families of second passes
16: *
17: * University of Utah CS Dept modification history:
18: *
19: * $Log: put.c,v $
20: * Revision 3.2 85/05/04 15:41:24 mckusick
21: * Fix alignment problem -- change code to match comment...
22: *
23: * Revision 3.2 85/04/29 21:36:07 donn
24: * Fix alignment problem -- change code to match comment...
25: *
26: * Revision 3.1 85/02/27 19:12:04 donn
27: * Changed to use pcc.h instead of pccdefs.h.
28: *
29: * Revision 2.1 84/07/19 12:04:21 donn
30: * Changed comment headers for UofU.
31: *
32: * Revision 1.2 84/04/02 14:40:21 donn
33: * Added fixes from Conrad Huang at UCSF for calculating the length of a
34: * concatenation of strings correctly.
35: *
36: */
37:
38: #include "defs.h"
39:
40: #if FAMILY == PCC
41: # include <pcc.h>
42: #else
43: # include "dmrdefs.h"
44: #endif
45:
46: /*
47: char *ops [ ] =
48: {
49: "??", "+", "-", "*", "/", "**", "-",
50: "OR", "AND", "EQV", "NEQV", "NOT",
51: "CONCAT",
52: "<", "==", ">", "<=", "!=", ">=",
53: " of ", " ofC ", " = ", " += ", " *= ", " CONV ", " << ", " % ",
54: " , ", " ? ", " : "
55: " abs ", " min ", " max ", " addr ", " indirect ",
56: " bitor ", " bitand ", " bitxor ", " bitnot ", " >> ", " () "
57: };
58: */
59:
60: int ops2 [ ] =
61: {
62: PCC_ERROR, PCC_PLUS, PCC_MINUS, PCC_MUL, PCC_DIV, PCC_ERROR, PCC_UMINUS,
63: PCC_OROR, PCC_ANDAND, PCC_EQ, PCC_NE, PCC_NOT,
64: PCC_ERROR,
65: PCC_LT, PCC_EQ, PCC_GT, PCC_LE, PCC_NE, PCC_GE,
66: PCC_CALL, PCC_CALL, PCC_ASSIGN, PCC_PLUSEQ, PCC_MULEQ, PCC_SCONV, PCC_LS, PCC_MOD,
67: PCC_COMOP, PCC_QUEST, PCC_COLON,
68: PCC_ERROR, PCC_ERROR, PCC_ERROR, PCC_ERROR, PCC_DEREF,
69: PCC_OR, PCC_AND, PCC_ER, PCC_COMPL, PCC_RS, PCC_ERROR
70: };
71:
72:
73: int types2 [ ] =
74: {
75: PCC_ERROR, PCCT_INT|PCCTM_PTR, PCCT_SHORT, PCCT_LONG, PCCT_FLOAT, PCCT_DOUBLE,
76: #if TARGET == INTERDATA
77: PCC_ERROR, PCC_ERROR, PCCT_LONG, PCCT_CHAR, PCCT_INT, PCC_ERROR
78: #else
79: PCCT_FLOAT, PCCT_DOUBLE, PCCT_LONG, PCCT_CHAR, PCCT_INT, PCC_ERROR
80: #endif
81: };
82:
83:
84: setlog()
85: {
86: types2[TYLOGICAL] = types2[tylogical];
87: typesize[TYLOGICAL] = typesize[tylogical];
88: typealign[TYLOGICAL] = typealign[tylogical];
89: }
90:
91:
92: putex1(p)
93: expptr p;
94: {
95: putx( fixtype(p) );
96:
97: if (!optimflag)
98: {
99: templist = hookup(templist, holdtemps);
100: holdtemps = NULL;
101: }
102: }
103:
104:
105:
106:
107:
108: putassign(lp, rp)
109: expptr lp, rp;
110: {
111: putx( fixexpr( mkexpr(OPASSIGN, lp, rp) ));
112: }
113:
114:
115:
116:
117: puteq(lp, rp)
118: expptr lp, rp;
119: {
120: putexpr( mkexpr(OPASSIGN, lp, rp) );
121: }
122:
123:
124:
125:
126: /* put code for a *= b */
127:
128: putsteq(a, b)
129: expptr a, b;
130: {
131: putx( fixexpr( mkexpr(OPSTAREQ, cpexpr(a), cpexpr(b)) ));
132: }
133:
134:
135:
136:
137:
138: Addrp realpart(p)
139: register Addrp p;
140: {
141: register Addrp q;
142:
143: q = (Addrp) cpexpr(p);
144: if( ISCOMPLEX(p->vtype) )
145: q->vtype += (TYREAL-TYCOMPLEX);
146: return(q);
147: }
148:
149:
150:
151:
152: expptr imagpart(p)
153: register expptr p;
154: {
155: register Addrp q;
156: expptr mkrealcon();
157:
158: if (ISCONST(p))
159: {
160: if (ISCOMPLEX(p->constblock.vtype))
161: return(mkrealcon(p->constblock.vtype == TYCOMPLEX ?
162: TYREAL : TYDREAL,
163: p->constblock.const.cd[1]));
164: else if (p->constblock.vtype == TYDREAL)
165: return(mkrealcon(TYDREAL, 0.0));
166: else
167: return(mkrealcon(TYREAL, 0.0));
168: }
169: else if (p->tag == TADDR)
170: {
171: if( ISCOMPLEX(p->addrblock.vtype) )
172: {
173: q = (Addrp) cpexpr(p);
174: q->vtype += (TYREAL-TYCOMPLEX);
175: q->memoffset = mkexpr(OPPLUS, q->memoffset,
176: ICON(typesize[q->vtype]));
177: return( (expptr) q );
178: }
179: else
180: return( mkrealcon( ISINT(p->addrblock.vtype) ?
181: TYDREAL : p->addrblock.vtype , 0.0));
182: }
183: else
184: badtag("imagpart", p->tag);
185: }
186:
187:
188:
189:
190: ncat(p)
191: register expptr p;
192: {
193: if(p->tag==TEXPR && p->exprblock.opcode==OPCONCAT)
194: return( ncat(p->exprblock.leftp) + ncat(p->exprblock.rightp) );
195: else return(1);
196: }
197:
198:
199:
200:
201: ftnint lencat(p)
202: register expptr p;
203: {
204: if(p->tag==TEXPR && p->exprblock.opcode==OPCONCAT)
205: return( lencat(p->exprblock.leftp) + lencat(p->exprblock.rightp) );
206: else if( p->headblock.vleng!=NULL && ISICON(p->headblock.vleng) )
207: return(p->headblock.vleng->constblock.const.ci);
208: else if(p->tag==TADDR && p->addrblock.varleng!=0)
209: return(p->addrblock.varleng);
210: else if(p->tag==TTEMP && p->tempblock.varleng!=0)
211: return(p->tempblock.varleng);
212: else
213: {
214: err("impossible element in concatenation");
215: return(0);
216: }
217: }
218:
219: Addrp putconst(p)
220: register Constp p;
221: {
222: register Addrp q;
223: struct Literal *litp, *lastlit;
224: int i, k, type;
225: int litflavor;
226:
227: if( p->tag != TCONST )
228: badtag("putconst", p->tag);
229:
230: q = ALLOC(Addrblock);
231: q->tag = TADDR;
232: type = p->vtype;
233: q->vtype = ( type==TYADDR ? TYINT : type );
234: q->vleng = (expptr) cpexpr(p->vleng);
235: q->vstg = STGCONST;
236: q->memno = newlabel();
237: q->memoffset = ICON(0);
238:
239: /* check for value in literal pool, and update pool if necessary */
240:
241: switch(type = p->vtype)
242: {
243: case TYCHAR:
244: if(p->vleng->constblock.const.ci > XL)
245: break; /* too long for literal table */
246: litflavor = 1;
247: goto loop;
248:
249: case TYREAL:
250: case TYDREAL:
251: litflavor = 2;
252: goto loop;
253:
254: case TYLOGICAL:
255: type = tylogical;
256: case TYSHORT:
257: case TYLONG:
258: litflavor = 3;
259:
260: loop:
261: lastlit = litpool + nliterals;
262: for(litp = litpool ; litp<lastlit ; ++litp)
263: if(type == litp->littype) switch(litflavor)
264: {
265: case 1:
266: if(p->vleng->constblock.const.ci != litp->litval.litcval.litclen)
267: break;
268: if(! eqn( (int) p->vleng->constblock.const.ci, p->const.ccp,
269: litp->litval.litcval.litcstr) )
270: break;
271:
272: ret:
273: q->memno = litp->litnum;
274: frexpr(p);
275: return(q);
276:
277: case 2:
278: if(p->const.cd[0] == litp->litval.litdval)
279: goto ret;
280: break;
281:
282: case 3:
283: if(p->const.ci == litp->litval.litival)
284: goto ret;
285: break;
286: }
287: if(nliterals < MAXLITERALS)
288: {
289: ++nliterals;
290: litp->littype = type;
291: litp->litnum = q->memno;
292: switch(litflavor)
293: {
294: case 1:
295: litp->litval.litcval.litclen =
296: p->vleng->constblock.const.ci;
297: cpn( (int) litp->litval.litcval.litclen,
298: p->const.ccp,
299: litp->litval.litcval.litcstr);
300: break;
301:
302: case 2:
303: litp->litval.litdval = p->const.cd[0];
304: break;
305:
306: case 3:
307: litp->litval.litival = p->const.ci;
308: break;
309: }
310: }
311: default:
312: break;
313: }
314:
315: preven(typealign[ type==TYCHAR ? TYLONG : type ]);
316: prlabel(asmfile, q->memno);
317:
318: k = 1;
319: switch(type)
320: {
321: case TYLOGICAL:
322: case TYSHORT:
323: case TYLONG:
324: prconi(asmfile, type, p->const.ci);
325: break;
326:
327: case TYCOMPLEX:
328: k = 2;
329: case TYREAL:
330: type = TYREAL;
331: goto flpt;
332:
333: case TYDCOMPLEX:
334: k = 2;
335: case TYDREAL:
336: type = TYDREAL;
337:
338: flpt:
339: for(i = 0 ; i < k ; ++i)
340: prconr(asmfile, type, p->const.cd[i]);
341: break;
342:
343: case TYCHAR:
344: putstr(asmfile, p->const.ccp,
345: (int) (p->vleng->constblock.const.ci) );
346: break;
347:
348: case TYADDR:
349: prcona(asmfile, p->const.ci);
350: break;
351:
352: default:
353: badtype("putconst", p->vtype);
354: }
355:
356: frexpr(p);
357: return( q );
358: }
359:
360: /*
361: * put out a character string constant. begin every one on
362: * a long integer boundary, and pad with nulls
363: */
364: putstr(fp, s, n)
365: FILEP fp;
366: register char *s;
367: register int n;
368: {
369: int b[SZLONG];
370: register int i;
371:
372: i = 0;
373: while(--n >= 0)
374: {
375: b[i++] = *s++;
376: if(i == SZLONG)
377: {
378: prchars(fp, b);
379: prchars(fp, b+SZSHORT);
380: i = 0;
381: }
382: }
383:
384: while(i < SZLONG)
385: b[i++] = '\0';
386: prchars(fp, b);
387: prchars(fp, b+SZSHORT);
388: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.