![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to 6.i CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests|
Return to 6.i CVS log | Up to [Research Unix] / researchv10no / cmd / ccom / vax / tests |
1.1 root 1: /* local.c */
2: extern struct _iobuf {
3: int _cnt;
4: char *_ptr;
5: char *_base;
6: short _flag;
7: char _file;
8: } _iob[20];
9: struct _iobuf *fopen();
10: struct _iobuf *fdopen();
11: struct _iobuf *freopen();
12: long ftell();
13: char *fgets();
14: struct _iobuf *fopen();
15: struct _iobuf *fdopen();
16: struct _iobuf *freopen();
17: long ftell();
18: char *fgets();
19: char *hash();
20: char *savestr();
21: char *tstr();
22: extern int tstrused;
23: extern char *tstrbuf[];
24: extern char **curtstr;
25: extern int nerrors;
26: typedef union ndu NODE;
27: typedef unsigned int TWORD;
28: typedef long CONSZ;
29:
30:
31: extern int dope[];
32: extern char *opst[];
33:
34: union ndu {
35: struct {
36: int op;
37: int goal;
38: TWORD type;
39: int cst[(6+4)];
40: char * name;
41: char pad[8 -sizeof(char *)];
42: NODE *left;
43: NODE *right;
44: }in;
45:
46: struct {
47: int op;
48: int goal;
49: TWORD type;
50: int cst[(6+4)];
51: char * name;
52: char pad[8 -sizeof(char *)];
53: CONSZ lval;
54: int rval;
55: }tn;
56:
57: struct {
58: int op;
59: int goal;
60: TWORD type;
61: int cst[(6+4)];
62: int label;
63: int lop;
64: }bn;
65: struct {
66: int op;
67: int goal;
68: TWORD type;
69: int cst[(6+4)];
70: int stsize;
71: short stalign;
72: short argsize;
73: }stn;
74: struct {
75: int op;
76: int goal;
77: TWORD type;
78: int cdim;
79: int csiz;
80: }fn;
81:
82: struct {
83:
84: int op;
85: int goal;
86: TWORD type;
87: int cdim;
88: int csiz;
89: double dval;
90: }fpn;
91: };
92:
93: extern char *scnames();
94: typedef long OFFSZ;
95: struct symtab {
96: char *sname;
97: TWORD stype;
98: char sclass;
99: char slevel;
100: char sflags;
101: int offset;
102: short dimoff;
103: short sizoff;
104: short suse;
105: struct symtab *scopelink;
106: };
107: struct sw {
108: CONSZ sval;
109: int slab;
110: };
111: extern struct sw swtab[];
112: extern struct sw *swp;
113: extern int swx;
114: extern int ftnno;
115: extern int blevel;
116: extern int instruct, stwart;
117: extern int lineno, nerrors;
118: typedef union {
119: int intval;
120: NODE * nodep;
121: } YYSTYPE;
122: extern YYSTYPE yylval;
123: extern CONSZ lastcon;
124: extern CONSZ ccast();
125: extern double dcon;
126: extern char ftitle[];
127: extern struct symtab stab[];
128: extern int curftn;
129: extern int strftn;
130: extern char *locnames[];
131: extern int curloc;
132: extern int curclass;
133: extern int curdim;
134: extern int dimtab[];
135: extern int paramstk[];
136: extern int paramno;
137: extern int argstk[];
138: extern int argsoff[];
139: extern TWORD argty[];
140: extern int argno;
141: extern int autooff, argoff, strucoff;
142: extern int regvar;
143: extern int nextrvar;
144: extern int brkflag;
145: extern char yytext[];
146: extern int strflg;
147: extern OFFSZ inoff;
148: extern int reached;
149: extern int idname;
150: extern NODE node[];
151: extern NODE *lastfree;
152: extern int cflag, hflag, pflag;
153: extern int brklab;
154: extern int contlab;
155: extern int flostat;
156: extern int retlab;
157: extern int retstat;
158: extern int asavbc[], *psavbc;
159:
160: extern NODE
161: *aadjust(),
162: *bcon(),
163: *bdty(),
164: *block(),
165: *bpsize(),
166: *buildtree(),
167: *clocal(),
168: *conval(),
169: *convert(),
170: *dclstruct(),
171: *doszof(),
172: *getstr(),
173: *makety(),
174: *mkty(),
175: *oconvert(),
176: *offcon(),
177: *optim(),
178: *pconvert(),
179: *ptmatch(),
180: *pvconvert(),
181: *rstruct(),
182: *sconvert(),
183: *strargs(),
184: *stref(),
185: *talloc(),
186: *tymatch(),
187: *tymerge(),
188: *unconvert(),
189: *xicolon();
190: OFFSZ tsize(),
191: psize();
192: TWORD types(),
193: ctype();
194: char *exname(), *exdcon();
195: int minrvar = 11;
196: int wloop_level = 1 ;
197: int floop_level = 1 ;
198: int maxboff;
199: int maxtemp;
200: extern int gdebug;
201: main( argc, argv ) char *argv[];
202: {
203: extern int proflag;
204:
205:
206: int r;
207: r = mainp1( argc, argv );
208: return( r );
209: }
210: beg_file()
211: {
212:
213: register char *p, *s;
214: char *tempnam();
215:
216: p = ftitle + strlen( ftitle ) - 2;
217: s = p - 14;
218: while ( p > s && *p != '"' && *p != '/' )
219: --p;
220: regvar = minrvar;
221: if (gdebug)
222: dbline();
223: }
224: NODE *
225: treecpy(p)
226: register NODE *p;
227: {
228:
229: register NODE *q;
230: q = talloc();
231: *q = *p;
232: switch ( (dope[q->in.op]&016))
233: {
234: case 010:
235: q->in.right = treecpy(p->in.right);
236: case 04:
237: q->in.left = treecpy(p->in.left);
238: }
239: return (q);
240: }
241: NODE *
242: clocal(p) NODE *p;
243: {
244: register NODE *l,*ll,*temp;
245: if( p->in.op == (2+ 11) )
246: {
247:
248: l = p->in.left;
249: if( l->in.op == 6 )
250: {
251: ll = l->in.left;
252: if( ll->in.op != 11 && ll->in.op != 2+ 14 )
253: {
254: if( (l->in.right)->in.op == 11 )
255: {
256: temp = l->in.right;
257: l->in.right = l->in.left;
258: l->in.left = temp;
259: }
260: }
261: }
262: }
263: return(p);
264: }
265: cisreg( t ) TWORD t;
266: {
267: if( t==4 || t==14 || ((t&(03<<5 ))== 040) || t==2 || t==12
268: || t==3 || t==13 )
269: {
270: if( regvar >= 6 )
271: {
272: nextrvar = regvar--;
273: if( regvar < minrvar ) minrvar = regvar;
274: return(1);
275: }
276: }
277: return(0);
278: }
279: opbigsz( op )
280: {
281:
282: switch( op )
283: {
284: default:
285: return( 32 );
286: case 6:
287: case 8:
288: case 17:
289: case 14:
290: case 19:
291: case 77:
292: case 2+ 8:
293: return( 8 );
294: }
295: }
296: branch(n)
297: int n;
298: {
299: if (!reached)
300: return;
301: dbline();
302: genubr(n);
303: }
304:
305: static int tablelabel;
306: struct sw heapsw[250 ];
307:
308:
309: genswitch(p,n) register struct sw *p;
310: {
311:
312: register i;
313: register CONSZ j, range;
314: register dlab, swlab;
315: range = p[n].sval-p[1].sval;
316: if( ( range>0 && range<=(3* n ) && n >=4) )
317: {
318: swlab = getlab();
319: dlab = ((p->slab >= 0) ? p->slab : getlab());
320: dswbegin( n, p[1].sval, range, swlab, dlab );
321: for( i=1,j=p[1].sval; i<=n; j++)
322: {
323: if( j == p[i].sval )
324: {
325: dswcase( p[i].slab );
326: j = p[i++].sval;
327: }
328: else
329: {
330: dswcase( dlab );
331: }
332: }
333:
334: locctr( 0 );
335: if( p->slab >= 0 ) genubr( dlab );
336: else deflab( dlab );
337: return;
338: }
339: if( (n>8) )
340: {
341: heapsw[0].slab = dlab = (p->slab >= 0 ? p->slab : getlab());
342: makeheap(p, n, 1);
343: walkheap(1, n);
344: if( p->slab >= 0 )
345: genubr( dlab );
346: else
347: deflab( dlab );
348: return;
349: }
350:
351: for( i=1; i<=n; ++i ) sswtest( p[i].sval, p[i].slab );
352: if( p->slab>=0 ) genubr( p->slab );
353: }
354: makeheap(p, m, n)
355: register struct sw *p;
356: {
357: register int q;
358: q = select(m);
359: heapsw[n] = p[q];
360: if( q>1 ) makeheap(p, q-1, 2*n);
361: if( q<m ) makeheap(p+q, m-q, 2*n+1);
362: }
363: select(m) {
364: register int l,i,k;
365: for(i=1; ; i*=2)
366: if( (i-1) > m ) break;
367: l = ((k = i/2 - 1) + 1)/2;
368: return( l + (m-k < l ? m-k : l));
369: }
370: walkheap(start, limit)
371: {
372: int label;
373: if( start > limit ) return;
374: sswtest( heapsw[start].sval, heapsw[start].slab );
375: if( (2*start) > limit ) {
376: genubr( heapsw[0].slab );
377: return;
378: }
379: if( (2*start+1) <= limit ) {
380: label = getlab();
381: hswelse( label );
382: } else
383: hswelse( heapsw[0].slab );
384: walkheap( 2*start, limit);
385: if( (2*start+1) <= limit ) {
386: deflab( label );
387: walkheap( 2*start+1, limit);
388: }
389: }
390: dswbegin( numb, first, range, labl, dlab )
391: CONSZ first, range;
392: int numb, labl, dlab;
393: {
394: printf(" casel r0,$%ld,$%ld\n", first, range );
395: printf("L%d:\n", labl );
396: tablelabel = labl;
397: }
398: dswcase( l )
399: int l;
400: {
401: printf(" .word L%d-L%d\n", l, tablelabel );
402: }
403: sswtest( val, lab )
404: CONSZ val;
405: int lab;
406: {
407: printf( " cmpl r0,$%ld\n jeql L%d\n", val, lab );
408: }
409: hswelse( lab )
410: int lab;
411: {
412: printf(" jgtr L%d\n", lab );
413: }
414: OFFSZ inoff;
415: static inwd;
416: static long word;
417: zecode( n )
418: int n;
419: {
420:
421: if (n <= 0) return;
422: printf( " .space %d\n", 4*n );
423: inoff += n*32;
424: }
425: vfdzero( n ){
426:
427: sz_incode( (CONSZ)0, n );
428: }
429: incode (p, sz)
430: NODE *p;
431: {
432: sz_incode(p->tn.lval, sz);
433: }
434: sz_incode( val, sz )
435: CONSZ val;
436: {
437:
438:
439:
440: if((sz+inwd) > 32) cerror("incode: field > long");
441:
442: word |= ((unsigned)(val<<(32-sz))) >> (32-sz-inwd);
443: inwd += sz;
444: inoff += sz;
445:
446: if( inwd == 32 )
447: {
448: genlong( word );
449: word = inwd = 0;
450: }
451: }
452: fincode( d, sz )
453: double d;
454: int sz;
455: {
456:
457:
458:
459: union { float f; double d; int i[2]; } cheat;
460: if (sz == 64)
461: {
462: cheat.d = d;
463: printf("\t.long\t0x%x,0x%x\t# %.20e\n", cheat.i[0], cheat.i[1],
464: cheat.d);
465: }
466: else
467: {
468: cheat.f = d;
469: printf("\t.long\t0x%x\t# %.20e\n", cheat.i[0], cheat.f);
470: }
471: inoff += sz;
472: }
473: int ftlab1, ftlab2;
474: int proflag;
475: int ent_mask[] = {
476: 0,0,0,0,0, 0xfc0, 0xf80, 0xf00, 0xe00, 0xc00, 0x800, 0};
477: efcode()
478: {
479:
480: long spoff;
481: genret( strftn, strftn, retlab );
482: printf( " .set L.R%d,0x%x\n", ftnno, ent_mask[minrvar] );
483: spoff = maxboff;
484: if( spoff >= ((0 )/8) ) spoff -= ((0 )/8);
485: spoff += maxtemp;
486: spoff /= 8;
487: deflab( ftlab1 );
488: if( spoff!=0 )
489: if( spoff < 64 )
490: printf( " subl2 $%ld,sp\n", spoff );
491: else
492: printf( " movab -%ld(sp),sp\n", spoff);
493: genubr( ftlab2 );
494: regvar = minrvar = 11;
495: if (gdebug)
496: dbfunend(getlab());
497: }
498: bfcode( a, n )
499: int a[], n;
500: {
501:
502: register i;
503:
504: printf( " .word L.R%d\n", ftnno);
505: genubr( ftlab1 = getlab() );
506: deflab( ftlab2 = getlab() );
507: retlab = getlab();
508: if( proflag )
509: {
510: i = getlab();
511: printf(" movab L%d,r0\n", i);
512: printf(" jsb mcount\n");
513: printf(" .data\n");
514: printf(" .align 2\n");
515: printf("L%d: .long 0\n", i);
516: printf(" .text\n");
517: }
518: if (gdebug)
519: {
520: dbfunbeg(&stab[curftn]);
521: dbnargs(n);
522: for (i = 0; i < n; ++i)
523: dbfunarg(&stab[a[i]]);
524: }
525: }
526: defnam( psym )
527: register struct symtab *psym;
528: {
529:
530:
531:
532: if (psym->sclass == 5)
533: printf( " .globl %s\n", exname(psym->sname) );
534: printf("%s:\n", exname(psym->sname));
535: }
536: commdec(id)
537: int id;
538: {
539: register struct symtab *psym;
540: OFFSZ n;
541: psym = &stab[id];
542: psym->sflags |= 0200;
543: n = tsize(psym->stype, psym->dimoff, psym->sizoff) / 8;
544: if (psym->sclass == 3)
545: if (psym->slevel)
546: printf(" .lcomm L%d,%ld\n", psym->offset, n);
547: else
548: printf(" .lcomm %s,%ld\n", exname(psym->sname), n);
549: else if (psym->sclass == 2)
550: printf(" .comm %s,%ld\n", exname(psym->sname), n);
551: else
552: cerror("Non-static/external in common");
553: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.