![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to pftn.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jerq / sgs / comp|
Return to pftn.c CVS log | Up to [Research Unix] / researchv9 / jerq / sgs / comp |
1.1 root 1: /* @(#) pftn.c: 1.6.1.1 6/26/84 */
2:
3: # include "mfile1.h"
4:
5: unsigned int maxoffset;
6:
7: struct instk
8: {
9: int in_sz; /* size of array element */
10: int in_x; /* current index for structure member in initializations */
11: int in_n; /* number of initializations seen */
12: int in_s; /* sizoff */
13: int in_d; /* dimoff */
14: TWORD in_t; /* type */
15: int in_id; /* stab index */
16: int in_fl; /* flag which says if this level is controlled by {} */
17: OFFSZ in_off; /* offset of the beginning of this level */
18: }instack[10],*pstk;
19:
20: struct symtab *relook();
21:
22: int ddebug = 0;
23:
24: struct symtab * mknonuniq();
25:
26: defid( q, class )
27: register NODE *q;
28: {
29: register struct symtab *p;
30: extern struct symtab *scopestack[];
31: int idp;
32: register TWORD type;
33: register TWORD stp;
34: register scl;
35: register dsym, ddef;
36: register slev, temp;
37:
38: if( q == NIL ) return; /* an error was detected */
39: if( q < node || q >= &node[TREESZ] ) cerror( "defid call" );
40: idp = q->tn.rval;
41: if( idp < 0 ) cerror( "tyreduce" );
42: p = &stab[idp];
43: # ifndef NODBG
44: if( ddebug )
45: {
46: printf( "defid( %s (%d), ", p->sname, idp );
47: tprint( q->in.type );
48: printf( ", %s, (%d,%d) ), level %d\n", scnames(class),
49: q->fn.cdim, q->fn.csiz, blevel );
50: }
51: # endif
52: fixtype( q, class );
53: type = q->in.type;
54: class = fixclass( class, type );
55: stp = p->stype;
56: slev = p->slevel;
57: # ifndef NODBG
58: if( ddebug )
59: {
60: printf( " modified to " );
61: tprint( type );
62: printf( ", %s\n", scnames(class) );
63: printf( " previous def'n: " );
64: tprint( stp );
65: printf( ", %s, (%d,%d) ), level %d\n", scnames(p->sclass),
66: p->dimoff, p->sizoff, slev );
67: }
68: # endif
69: if( stp == FTN && p->sclass == SNULL )goto enter;
70: /* name encountered as function, not yet defined */
71: /* BUG here! can't incompatibly declare func. in inner block */
72: if( stp == UNDEF|| stp == FARG )
73: {
74: if( blevel==1 && stp!=FARG ) switch( class )
75: {
76: default:
77: if(!(class&FIELD)) uerror(
78: "declared argument %s is missing", p->sname );
79: case MOS:
80: case STNAME:
81: case MOU:
82: case UNAME:
83: case MOE:
84: case ENAME:
85: case TYPEDEF:
86: ;
87: }
88: goto enter;
89: }
90: if( type != stp ) goto mismatch;
91: /* test (and possibly adjust) dimensions */
92: dsym = p->dimoff;
93: ddef = q->fn.cdim;
94: for( temp=type; temp&TMASK; temp = DECREF(temp) )
95: {
96: if( ISARY(temp) )
97: {
98: if( dimtab[dsym] == 0 ) dimtab[dsym] = dimtab[ddef];
99: else if( dimtab[ddef]!=0 && dimtab[dsym] != dimtab[ddef] )
100: {
101: goto mismatch;
102: }
103: ++dsym;
104: ++ddef;
105: }
106: }
107: /* check that redeclarations are to the same structure */
108: if( (temp==STRTY||temp==UNIONTY||temp==ENUMTY) && p->sizoff != q->fn.csiz
109: && class!=STNAME && class!=UNAME && class!=ENAME )
110: {
111: goto mismatch;
112: }
113: scl = ( p->sclass );
114: # ifndef NODBG
115: if( ddebug )
116: {
117: printf( " previous class: %s\n", scnames(scl) );
118: }
119: # endif
120: if( class&FIELD )
121: {
122: /* redefinition */
123: if( !falloc( p, class&FLDSIZ, 1, NIL ) )
124: {
125: /* successful allocation */
126: psave( idp );
127: return;
128: }
129: /* blew it: resume at end of switch... */
130: }
131: else switch( class )
132: {
133: case EXTERN:
134: switch( scl )
135: {
136: case STATIC:
137: case USTATIC:
138: if( slev==0 ) return;
139: break;
140: case EXTDEF:
141: case EXTERN:
142: case FORTRAN:
143: case UFORTRAN:
144: return;
145: }
146: break;
147: case STATIC:
148: if( scl==USTATIC || (scl==EXTERN && blevel==0) )
149: {
150: p->sclass = STATIC;
151: if( ISFTN(type) ) curftn = idp;
152: return;
153: }
154: break;
155: case USTATIC:
156: if( scl==STATIC || scl==USTATIC ) return;
157: break;
158: case LABEL:
159: if( scl == ULABEL )
160: {
161: p->sclass = LABEL;
162: deflab( p->offset );
163: return;
164: }
165: break;
166: case TYPEDEF:
167: if( scl == class ) return;
168: break;
169: case UFORTRAN:
170: if( scl == UFORTRAN || scl == FORTRAN ) return;
171: break;
172: case FORTRAN:
173: if( scl == UFORTRAN )
174: {
175: p->sclass = FORTRAN;
176: if( ISFTN(type) ) curftn = idp;
177: return;
178: }
179: break;
180: case MOU:
181: case MOS:
182: if( scl == class )
183: {
184: if( oalloc( p, &strucoff ) ) break;
185: if( class == MOU ) strucoff = 0;
186: psave( idp );
187: return;
188: }
189: break;
190: case MOE:
191: if( scl == class )
192: {
193: if( p->offset!= strucoff++ ) break;
194: psave( idp );
195: }
196: break;
197: case EXTDEF:
198: if( scl == EXTERN )
199: {
200: p->sclass = EXTDEF;
201: if( ISFTN(type) ) curftn = idp;
202: return;
203: }
204: break;
205: case STNAME:
206: case UNAME:
207: case ENAME:
208: if( scl != class ) break;
209: if( dimtab[p->sizoff] == 0 )
210: return; /* previous entry just a mention */
211: break;
212: case ULABEL:
213: if( scl == LABEL || scl == ULABEL ) return;
214: case PARAM:
215: case AUTO:
216: case REGISTER:
217: ; /* mismatch.. */
218: }
219: mismatch:
220: /* allow nonunique structure/union member names */
221: if( class==MOU || class==MOS || class & FIELD )
222: {
223: /* make a new entry */
224: register * memp;
225: p->sflags |= SNONUNIQ; /* old entry is nonunique */
226: /* determine if name has occurred in this structure/union */
227: for( memp = ¶mstk[paramno-1];
228: /* while */ *memp>=0 && stab[*memp].sclass != STNAME
229: && stab[*memp].sclass != UNAME;
230: /* iterate */ --memp)
231: {
232: if( stab[*memp].sflags & SNONUNIQ )
233: {
234: if ( p->sname != stab[*memp].sname )
235: continue;
236: uerror("redeclaration of: %s",
237: p->sname);
238: break;
239: }
240: }
241: p = mknonuniq( &idp ); /* update p and idp to new entry */
242: goto enter;
243: }
244: if( blevel > slev && class != EXTERN && class != FORTRAN &&
245: class != UFORTRAN && !( class == LABEL && slev >= 2 ) )
246: {
247: q->tn.rval = idp = hide( p );
248: p = &stab[idp];
249: goto enter;
250: }
251: uerror( "redeclaration of %s", p->sname );
252: if( class==EXTDEF && ISFTN(type) ) curftn = idp;
253: return;
254: enter: /* make a new entry */
255: # ifndef NODBG
256: if( ddebug ) printf( " new entry made\n" );
257: # endif
258: if( type == UNDEF ) uerror("void type for %s",p->sname);
259: p->stype = type;
260: p->sclass = class;
261: p->slevel = blevel;
262: p->offset = NOOFFSET;
263: p->suse = lineno;
264: if( class == STNAME || class == UNAME || class == ENAME )
265: {
266: p->sizoff = curdim;
267: dstash( 0 ); /* size */
268: dstash( -1 ); /* index to members of str or union */
269: dstash( ALSTRUCT ); /* alignment */
270: dstash( idp ); /* name index */
271: }
272: else
273: {
274: switch( BTYPE(type) )
275: {
276: case STRTY:
277: case UNIONTY:
278: case ENUMTY:
279: p->sizoff = q->fn.csiz;
280: break;
281: default:
282: p->sizoff = BTYPE(type);
283: }
284: }
285: /* copy dimensions */
286: p->dimoff = q->fn.cdim;
287: /* allocate offsets */
288: if( class&FIELD )
289: {
290: falloc( p, class&FLDSIZ, 0, NIL ); /* new entry */
291: psave( idp );
292: }
293: else switch( class )
294: {
295: case AUTO:
296: oalloc( p, &autooff );
297: break;
298: case STATIC:
299: case EXTDEF:
300: p->offset = getlab();
301: if( ISFTN(type) ) curftn = idp;
302: break;
303: case ULABEL:
304: case LABEL:
305: p->offset = getlab();
306: if( class == LABEL )
307: {
308: locctr( PROG );
309: deflab( p->offset );
310: }
311: break;
312: case EXTERN:
313: case UFORTRAN:
314: case FORTRAN:
315: p->offset = getlab();
316: break;
317: case MOU:
318: case MOS:
319: oalloc( p, &strucoff );
320: if( class == MOU ) strucoff = 0;
321: psave( idp );
322: break;
323: case MOE:
324: p->offset = strucoff++;
325: psave( idp );
326: break;
327: case REGISTER:
328: /* nextrvar is left set by cisreg when it returns 1 */
329: p->offset = nextrvar;
330: if( blevel == 1 ) p->sflags |= SSET;
331: break;
332: }
333: /* user-supplied routine to fix up new definitions */
334:
335: # ifdef FIXDEF
336: #ifdef TMPSRET /* don't try to put out sdb stuff for .stfake! */
337: if (strcmp(p->sname, ".stfake"))
338: #endif
339: FIXDEF(p);
340: # endif
341: if (blevel >= MAXNEST)
342: {
343: cerror("too many nesting levels");
344: /*NOTREACHED*/
345: }
346: p->scopelink = scopestack[slev = p->slevel];
347: scopestack[slev] = p;
348: /* change level of outerscope identifiers first appearing in
349: /* inner scopes
350: */
351: switch( class )
352: {
353: case ULABEL:
354: case LABEL:
355: p->slevel = 2;
356: break;
357: case EXTERN:
358: case UFORTRAN:
359: case FORTRAN:
360: p->slevel = 0;
361: break;
362: }
363: # ifndef NODBG
364: if( ddebug )
365: printf( " dimoff, sizoff, offset: %d, %d, %d\n",
366: p->dimoff, p->sizoff, p->offset );
367: # endif
368: }
369:
370: asave( i )
371: {
372: if( argno >= ARGSZ )
373: {
374: cerror( "too many arguments");
375: }
376: argstk[ argno++ ] = i;
377: }
378:
379: psave( i )
380: {
381: if( paramno >= PARAMSZ )
382: {
383: cerror( "parameter stack overflow");
384: }
385: paramstk[ paramno++ ] = i;
386: }
387:
388: /* maximium size of outgoing arguments */
389: int maxarg;
390:
391: ftnend()
392: {
393: /* end of function */
394: if( retlab != NOLAB )
395: {
396: /* inside a real function */
397:
398: efcode();
399: # ifdef SDB
400: {
401: register i;
402: register struct symtab *p;
403: register TWORD t;
404: for( i=0; i<argno; ++i )
405: {
406: /* use the saved types */
407: p = &stab[argstk[i]];
408: t = p->stype;
409: p->stype = argty[i];
410: if( p->sclass == REGISTER )
411: {
412: p->sclass = PARAM;
413: p->offset = argsoff[i];
414: }
415: /*ppstab(p);*/
416: p->stype = t;
417: }
418: }
419: # endif
420: # ifndef TWOPASS
421: p2bend();
422: # endif
423: }
424: checkst(0);
425: retstat = 0;
426: tcheck();
427: curclass = SNULL;
428: brklab = contlab = retlab = NOLAB;
429: flostat = 0;
430: strftn = 0;
431: argno = 0;
432: if( nerrors == 0 )
433: {
434: if( psavbc != & asavbc[0] ) cerror("bcsave error");
435: if( paramno != 0 ) cerror("parameter reset error");
436: if( swx != 0 ) cerror( "switch error");
437: }
438: psavbc = &asavbc[0];
439: paramno = 0;
440: autooff = AUTOINIT;
441: maxarg = 0;
442: reached = 1;
443: swx = 0;
444: swp = swtab;
445: locctr(DATA);
446: }
447:
448: dclargs()
449: {
450: register i, j;
451: register struct symtab *p;
452: register NODE *q;
453: register TWORD temp;
454: extern TWORD simpstr();
455:
456: argoff = ARGINIT;
457:
458: # ifndef NODBG
459: if( ddebug > 2) printf("dclargs()\n");
460: # endif
461: for( i=0; i<argno; ++i )
462: {
463: if( (j = argstk[i]) < 0 ) continue;
464: p = &stab[j];
465: # ifndef NODBG
466: if( ddebug > 2 )
467: {
468: printf("\t%s (%d) ",p->sname, j);
469: tprint(p->stype);
470: printf("\n");
471: }
472: # endif
473: if( p->stype == FARG )
474: {
475: q = block(FREE,NIL,NIL,INT,0,INT);
476: q->tn.rval = j;
477: defid( q, PARAM );
478: }
479: if( p->sclass == REGISTER )
480: {
481: /* must set aside space, fill argsoff */
482: int tmp = p->offset;
483: p->offset = NOOFFSET;
484: p->sclass = PARAM;
485: oalloc( p, &argoff );
486: argsoff[i] = p->offset;
487: argty[i] = p->stype;
488: p->sclass = REGISTER;
489: p->offset = tmp;
490: }
491: else
492: {
493: oalloc( p, &argoff ); /* always set aside space */
494: argsoff[i] = p->offset;
495: argty[i] = p->stype;
496: }
497: }
498: autooff = AUTOINIT;
499: # ifdef CENDARG
500: CENDARG();
501: # endif
502: locctr(PROG);
503: defalign(ALPROC);
504: ++ftnno;
505: p = &stab[curftn];
506:
507: if( p->slevel>1 && p->sclass == STATIC ) deflab( p->offset );
508: else defnam( p );
509: temp = p->stype;
510: temp = DECREF( temp );
511:
512: /* optimization: functions returning short structs */
513: /* strftn != 0 if function returns structure */
514: strftn = (temp==STRTY) || (temp==UNIONTY);
515: if( strftn && simpstr( p->dimoff, p->sizoff ) != STRTY )
516: strftn = 0;
517:
518: bfcode( argstk, argno );
519: # ifndef NOREGARGS
520: regargs();
521: # endif
522: /* code for the case where returning a structure uses a static */
523: if( strftn )
524: {
525: # ifdef STATSRET
526: /* scalars ok */
527: /* define something the proper size */
528: i = tsize( temp, p->dimoff, p->sizoff);
529: # ifdef SRETNAME
530: SRETNAME(i);
531: # else
532: locctr( DATA );
533: defalign( talign( temp, p->sizoff ) );
534: deflab ( strftn = getlab() );
535: zecode( (i+SZINT-1)/SZINT ); /* set aside integer zeros */
536: locctr( PROG );
537: # endif
538: # endif
539: # ifdef TMPSRET
540: /* code to stash auxiliary reg (return addr for struct) into auto */
541: idname = lookup(hash(".stfake"), 0);
542: q = bdty(NAME, NIL, idname);
543: q->tn.type = PTR|STRTY;
544: ++blevel; defid(q, AUTO); --blevel; /* sleazy, aren't we? */
545: ecomp(buildtree(ASSIGN, buildtree(NAME, NIL, NIL),
546: block(REG, NIL, (NODE *)AUXREG, PTR|STRTY,
547: q->fn.cdim, q->fn.csiz)));
548: q->tn.op = FREE;
549: # endif
550: }
551: }
552:
553: # ifndef NOREGARGS
554: regargs()
555: {
556: register i;
557: register NODE *p, *q;
558: register struct symtab *s;
559: /* output the copy assignements for register arguments */
560: for( i=0; i<argno; ++i )
561: {
562: s = &stab[argstk[i]];
563: if( s->sclass == REGISTER )
564: {
565: int temp;
566: idname = argstk[i];
567: p = buildtree( NAME, NIL, NIL );
568: temp = s->offset;
569: s->offset = argsoff[i];
570: s->sclass = PARAM;
571: q = buildtree( NAME, NIL, NIL );
572: p = buildtree( ASSIGN, p, q );
573: ecomp( p );
574: s->offset = temp;
575: s->sclass = REGISTER;
576: }
577: }
578: }
579: # endif
580:
581: NODE *
582: rstruct( idn, soru )
583: register idn,soru;
584: {
585: /* reference to a struct or union, with no definition */
586: register struct symtab *p;
587: register NODE *q;
588: p = &stab[idn];
589: switch( p->stype )
590: {
591: case UNDEF:
592: def:
593: q = block( FREE, NIL, NIL, 0, 0, 0 );
594: q->tn.rval = idn;
595: q->in.type = (soru&INSTRUCT) ? STRTY : ( (soru&INUNION) ? UNIONTY : ENUMTY );
596: defid( q, (soru&INSTRUCT) ? STNAME : ( (soru&INUNION) ? UNAME : ENAME ) );
597: break;
598: case STRTY:
599: if( soru & INSTRUCT ) break;
600: goto def;
601: case UNIONTY:
602: if( soru & INUNION ) break;
603: goto def;
604: case ENUMTY:
605: if( !(soru&(INUNION|INSTRUCT)) ) break;
606: goto def;
607: }
608: stwart = instruct;
609: return( mkty( p->stype, 0, p->sizoff ) );
610: }
611:
612: moedef( idn )
613: register idn;
614: {
615: register NODE *q;
616:
617: q = block( FREE, NIL, NIL, MOETY, 0, 0 );
618: q->tn.rval = idn;
619: if( idn>=0 ) defid( q, MOE );
620: }
621:
622: bstruct( idn, soru )
623: register idn,soru;
624: {
625: /* begining of structure or union declaration */
626: register NODE *q;
627:
628: psave( instruct );
629: psave( curclass );
630: psave( strucoff );
631: strucoff = 0;
632: instruct = soru;
633: q = block( FREE, NIL, NIL, 0, 0, 0 );
634: q->tn.rval = idn;
635: if( instruct==INSTRUCT )
636: {
637: curclass = MOS;
638: q->in.type = STRTY;
639: if( idn >= 0 ) defid( q, STNAME );
640: }
641: else if( instruct == INUNION )
642: {
643: curclass = MOU;
644: q->in.type = UNIONTY;
645: if( idn >= 0 ) defid( q, UNAME );
646: }
647: else
648: {
649: /* enum */
650: curclass = MOE;
651: q->in.type = ENUMTY;
652: if( idn >= 0 ) defid( q, ENAME );
653: }
654: psave( idn = q->tn.rval );
655: /* the "real" definition is where the members are seen */
656: if( idn >= 0 ) stab[idn].suse = lineno;
657: return( paramno-4 );
658: }
659:
660: # ifndef ENUMSIZE
661: # define ENUMSIZE(h,l) INT
662: # endif
663:
664: NODE *
665: dclstruct( oparam )
666: register oparam;
667: {
668: register struct symtab *p;
669: register i, al, sa, j, sz, szindex;
670: register TWORD temp;
671: register high, low;
672:
673: /* paramstack contains:
674: ** paramstack[ oparam ] = previous instruct
675: ** paramstack[ oparam+1 ] = previous class
676: ** paramstk[ oparam+2 ] = previous strucoff
677: ** paramstk[ oparam+3 ] = structure name
678: **
679: ** paramstk[ oparam+4, ... ] = member stab indices
680: **
681: */
682:
683:
684: if( (i=paramstk[oparam+3]) < 0 )
685: {
686: szindex = curdim;
687: dstash( 0 ); /* size */
688: dstash( -1 ); /* index to member names */
689: dstash( ALSTRUCT ); /* alignment */
690: dstash( -lineno ); /* name of structure */
691: }
692: else
693: {
694: szindex = stab[i].sizoff;
695: }
696:
697:
698: # ifndef NODBG
699: if( ddebug )
700: {
701: printf( "dclstruct( %szindex = %d\n",
702: (i>=0)? stab[i].sname : "??", szindex );
703: }
704: # endif
705: temp = (instruct&INSTRUCT)?STRTY:((instruct&INUNION)?UNIONTY:ENUMTY);
706: stwart = instruct = paramstk[ oparam ];
707: curclass = paramstk[ oparam+1 ];
708: dimtab[ szindex+1 ] = curdim;
709: al = ALSTRUCT;
710:
711: high = low = 0;
712:
713: for( i = oparam+4; i< paramno; ++i )
714: {
715: dstash( j=paramstk[i] );
716: if( j<0 || j>= SYMTSZ ) cerror( "gummy structure member" );
717: p = &stab[j];
718: if( temp == ENUMTY )
719: {
720: if( p->offset < low ) low = p->offset;
721: if( p->offset > high ) high = p->offset;
722: p->sizoff = szindex;
723: continue;
724: }
725: sa = talign( p->stype, p->sizoff );
726: if( p->sclass & FIELD )
727: {
728: sz = p->sclass&FLDSIZ;
729: }
730: else
731: {
732: sz = tsize( p->stype, p->dimoff, p->sizoff );
733: }
734: if( sz == 0 )
735: {
736: werror( "structure member has size 0: %s", p->sname );
737: }
738: if( sz > strucoff ) strucoff = sz; /* for use with unions */
739: SETOFF( al, sa );
740: /* al, the alignment, to the LCM of the members' alignments */
741: }
742: dstash( -1 ); /* endmarker */
743: SETOFF( strucoff, al );
744:
745: if( temp == ENUMTY )
746: {
747: register TWORD ty;
748:
749: ty = ENUMSIZE(high,low);
750: strucoff = tsize( ty, 0, (int)ty );
751: dimtab[ szindex+2 ] = al = talign( ty, (int)ty );
752: }
753:
754: if( strucoff == 0 ) uerror( "zero sized structure" );
755: dimtab[ szindex ] = strucoff;
756: dimtab[ szindex+2 ] = al;
757: dimtab[ szindex+3 ] = paramstk[ oparam+3 ]; /* name index */
758:
759: #ifdef FIXSTRUCT
760: FIXSTRUCT( szindex, oparam ); /* local hook for debugging */
761: #endif
762:
763: # ifndef NODBG
764: if( ddebug>1 )
765: {
766: printf( "\tdimtab[%d,%d,%d,%d] = %d,%d,%d,%d\n",
767: szindex,szindex+1,szindex+2,szindex+3,
768: dimtab[szindex],dimtab[szindex+1],dimtab[szindex+2],
769: dimtab[szindex+3] );
770: for( i = dimtab[szindex+1]; dimtab[i] >= 0; ++i )
771: {
772: printf( "\tmember %s(%d)\n", stab[dimtab[i]].sname, dimtab[i] );
773: }
774: }
775: # endif
776:
777: strucoff = paramstk[ oparam+2 ];
778: paramno = oparam;
779:
780: return( mkty( temp, 0, szindex ) );
781: }
782:
783: /* VARARGS */
784: yyerror( s ) char *s;
785:
786: {
787: /* error printing routine in parser */
788: uerror( s );
789:
790: }
791:
792: yyaccpt()
793: {
794: ftnend();
795: }
796:
797: ftnarg( idn )
798: register idn;
799: {
800: register struct symtab *p;
801: p = &stab[idn];
802: switch( p->stype )
803: {
804:
805: case UNDEF:
806: /* this parameter, entered at scan */
807: break;
808: case FARG:
809: uerror("redeclaration of formal parameter, %s",p->sname);
810: /* fall thru */
811: case FTN:
812: /* the name of this function matches parm */
813: /* fall thru */
814: default:
815: idn = hide(p);
816: p = &stab[idn];
817: break;
818: case TNULL:
819: /* unused entry, fill it */
820: ;
821: }
822: p->stype = FARG;
823: p->sclass = PARAM;
824: asave( idn );
825: }
826:
827: talign( ty, s)
828: register unsigned ty;
829: register s;
830: {
831: /* compute the alignment of an object with type ty, sizeoff index s */
832:
833: register i;
834: # ifdef FUNNYFLDS
835: if( s<0 && ty!=INT && ty!=CHAR && ty!=SHORT && ty!=UNSIGNED && ty!=UCHAR && ty!=USHORT
836: #ifdef LONGFIELDS
837: && ty!=LONG && ty!=ULONG
838: #endif
839: )
840: {
841: return( fldal( ty ) );
842: }
843: # endif
844:
845: for( i=0; i<=(SZINT-BTSHIFT-1); i+=TSHIFT )
846: {
847: switch( (ty>>i)&TMASK )
848: {
849:
850: case FTN:
851: cerror( "compiler takes alignment of function");
852: case PTR:
853: return( ALPOINT );
854: case ARY:
855: continue;
856: case 0:
857: break;
858: }
859: }
860:
861: switch( BTYPE(ty) )
862: {
863:
864: case UNIONTY:
865: case ENUMTY:
866: case STRTY:
867: return( dimtab[ s+2 ] );
868: case CHAR:
869: case UCHAR:
870: return( ALCHAR );
871: case FLOAT:
872: return( ALFLOAT );
873: case DOUBLE:
874: return( ALDOUBLE );
875: case LONG:
876: case ULONG:
877: return( ALLONG );
878: case SHORT:
879: case USHORT:
880: return( ALSHORT );
881: default:
882: return( ALINT );
883: }
884: }
885:
886: OFFSZ
887: tsize( ty, d, s )
888: register TWORD ty;
889: {
890: /* compute the size associated with type ty,
891: ** dimoff d, and sizoff s
892: */
893: /* BETTER NOT BE CALLED WHEN t, d, and s REFER TO A BIT FIELD... */
894:
895: register i;
896: register OFFSZ mult;
897:
898: mult = 1;
899:
900: for( i=0; i<=(SZINT-BTSHIFT-1); i+=TSHIFT )
901: {
902: switch( (ty>>i)&TMASK )
903: {
904:
905: case FTN:
906: cerror( "compiler takes size of function");
907: case PTR:
908: return( SZPOINT * mult );
909: case ARY:
910: mult *= dimtab[ d++ ];
911: continue;
912: case 0:
913: break;
914:
915: }
916: }
917:
918: if( dimtab[s]==0 )
919: {
920: uerror( "unknown size");
921: return( SZINT );
922: }
923: return( dimtab[ s ] * mult );
924: }
925:
926: inforce( n )
927: register OFFSZ n;
928: {
929: /* force inoff to have the value n */
930: /* inoff is updated to have the value n */
931: register OFFSZ wb;
932: register rest;
933: /* rest is used to do a lot of conversion to ints... */
934:
935: if( inoff == n ) return;
936: if( inoff > n )
937: {
938: cerror( "initialization alignment error");
939: }
940:
941: wb = inoff;
942: SETOFF( wb, SZINT );
943:
944: /* wb now has the next higher word boundary */
945: if( wb >= n )
946: {
947: /* in the same word */
948: rest = n - inoff;
949: vfdzero( rest );
950: return;
951: }
952:
953: /* otherwise, extend inoff to be word aligned */
954:
955: rest = wb - inoff;
956: vfdzero( rest );
957:
958: /* now, skip full words until near to n */
959:
960: rest = (n-inoff)/SZINT;
961: zecode( rest );
962:
963: /* now, the remainder of the last word */
964:
965: rest = n-inoff;
966: vfdzero( rest );
967: if( inoff != n ) cerror( "inoff error");
968:
969: }
970:
971: vfdalign( n )
972: {
973: /* make inoff have the offset the next alignment of n */
974: register OFFSZ m;
975:
976: m = inoff;
977: SETOFF( m, n );
978: inforce( m );
979: }
980:
981:
982: #ifndef NODBG
983: extern int idebug;
984: #endif
985:
986: int ibseen = 0; /* the number of } constructions which have been filled */
987:
988: int iclass; /* storage class of thing being initialized */
989:
990: int ilocctr = 0; /* location counter for current initialization */
991:
992: beginit(curid)
993: {
994: /* beginning of initilization; set location ctr and set type */
995: register struct symtab *p;
996:
997: # ifndef NODBG
998: if( idebug >= 3 ) printf( "beginit(), curid = %d\n", curid );
999: # endif
1000:
1001: p = &stab[curid];
1002:
1003: iclass = p->sclass;
1004: if( curclass == EXTERN || curclass == FORTRAN ) iclass = EXTERN;
1005: switch( iclass )
1006: {
1007:
1008: case UNAME:
1009: case EXTERN:
1010: return;
1011: case AUTO:
1012: case REGISTER:
1013: break;
1014: case EXTDEF:
1015: case STATIC:
1016: ilocctr = ISARY(p->stype)?ADATA:DATA;
1017: locctr( ilocctr );
1018: defalign( talign( p->stype, p->sizoff ) );
1019: if( p->slevel>1 && p->sclass == STATIC ) deflab( p->offset );
1020: else defnam( p );
1021:
1022: }
1023:
1024: inoff = 0;
1025: ibseen = 0;
1026:
1027: pstk = 0;
1028:
1029: instk( curid, p->stype, p->dimoff, p->sizoff, inoff );
1030:
1031: }
1032:
1033: instk( id, t, d, s, off )
1034: register OFFSZ off;
1035: register TWORD t;
1036:
1037: {
1038: /* make a new entry on the parameter stack to initialize id */
1039:
1040: register struct symtab *p;
1041:
1042: for(;;)
1043: {
1044: # ifndef NODBG
1045: if( idebug ) printf( "instk((%d, %o,%d,%d, %d)\n", id, t, d, s, off );
1046: # endif
1047:
1048: /* save information on the stack */
1049:
1050: if( !pstk ) pstk = instack;
1051: else ++pstk;
1052:
1053: pstk->in_fl = 0; /* { flag */
1054: pstk->in_id = id ;
1055: pstk->in_t = t ;
1056: pstk->in_d = d ;
1057: pstk->in_s = s ;
1058: pstk->in_n = 0; /* number seen */
1059: pstk->in_x = t==STRTY ?dimtab[s+1] : 0 ;
1060: pstk->in_off = off; /* offset at beginning of this element */
1061: /* if t is an array, DECREF(t) can't be a field */
1062: /* INS_sz has size of array elements, and -size for fields */
1063: if( ISARY(t) )
1064: {
1065: pstk->in_sz = tsize( DECREF(t), d+1, s );
1066: }
1067: else if( stab[id].sclass & FIELD )
1068: {
1069: pstk->in_sz = - ( stab[id].sclass & FLDSIZ );
1070: }
1071: else
1072: {
1073: pstk->in_sz = 0;
1074: }
1075:
1076: if( (iclass==AUTO || iclass == REGISTER ) &&
1077: (ISARY(t) || t==STRTY) )
1078: uerror( "no automatic aggregate initialization" );
1079:
1080: /* now, if this is not a scalar, put on another element */
1081:
1082: if( ISARY(t) )
1083: {
1084: t = DECREF(t);
1085: ++d;
1086: continue;
1087: }
1088: else if( t == STRTY )
1089: {
1090: id = dimtab[pstk->in_x];
1091: p = &stab[id];
1092: if( p->sclass != MOS && !(p->sclass&FIELD) )
1093: cerror( "insane structure member list" );
1094: t = p->stype;
1095: d = p->dimoff;
1096: s = p->sizoff;
1097: off += p->offset;
1098: continue;
1099: }
1100: else return;
1101: }
1102: }
1103:
1104: NODE *
1105: getstr()
1106: {
1107: /* decide if the string is external or an initializer,
1108: and get the contents accordingly */
1109: register l, temp;
1110: register NODE *p;
1111:
1112: if( (iclass==EXTDEF||iclass==STATIC) &&
1113: (pstk->in_t == CHAR || pstk->in_t == UCHAR) &&
1114: pstk!=instack && ISARY( pstk[-1].in_t ) )
1115: {
1116: /* treat "abc" as { 'a', 'b', 'c', 0 } */
1117: strflg = 1;
1118: ilbrace(); /* simulate { */
1119: inforce( pstk->in_off );
1120:
1121: /* if the array is inflexible (not top level), pass in the size
1122: ** Be prepared to throw away unwanted initializers
1123: */
1124:
1125: /* get the contents */
1126: lxstr((pstk-1)!=instack?dimtab[(pstk-1)->in_d]:0);
1127: irbrace(); /* simulate } */
1128: return( NIL );
1129: }
1130: else
1131: {
1132: /* make a label, and get the contents and stash them away */
1133: if( iclass != SNULL )
1134: {
1135: /* initializing */
1136: /* fill out previous word, to permit pointer */
1137: vfdalign( ALPOINT );
1138: }
1139: /* set up location counter */
1140: temp = locctr( blevel==0?ISTRNG:STRNG );
1141: deflab( l = getlab() );
1142: strflg = 0;
1143: lxstr(0); /* get the contents */
1144: locctr( blevel==0?ilocctr:temp );
1145: p = buildtree( STRING, NIL, NIL );
1146: p->tn.rval = -l;
1147: return(p);
1148: }
1149: }
1150:
1151: putbyte( v )
1152: {
1153: /* simulate byte v appearing in a list of integer values */
1154: register NODE *p;
1155: p = bcon(v);
1156: incode( p, SZCHAR );
1157: tfree( p );
1158: gotscal();
1159: }
1160:
1161: endinit()
1162: {
1163: register TWORD t;
1164: register d, s, n, d1;
1165:
1166: # ifndef NODBG
1167: if( idebug ) printf( "endinit(), inoff = %d\n", inoff );
1168: # endif
1169:
1170: switch( iclass )
1171: {
1172:
1173: case EXTERN:
1174: case AUTO:
1175: case REGISTER:
1176: iclass = SNULL;
1177: return;
1178: }
1179:
1180: pstk = instack;
1181:
1182: t = pstk->in_t;
1183: d = pstk->in_d;
1184: s = pstk->in_s;
1185: n = pstk->in_n;
1186:
1187: if( ISARY(t) )
1188: {
1189: d1 = dimtab[d];
1190:
1191: /* fill out part of the last element, if needed */
1192: vfdalign( pstk->in_sz );
1193:
1194: n = inoff/pstk->in_sz; /* real number of initializers */
1195: if( d1 >= n )
1196: {
1197: /* once again, t is an array, so no fields */
1198: inforce( tsize( t, d, s ) );
1199: n = d1;
1200: }
1201: if( d1!=0 && d1!=n ) uerror( "too many initializers");
1202: if( n==0 ) werror( "empty array declaration");
1203: dimtab[d] = n;
1204: }
1205:
1206: else if( t == STRTY || t == UNIONTY )
1207: {
1208: /* clearly not fields either */
1209: inforce( tsize( t, d, s ) );
1210: }
1211: else if( n > 1 ) uerror( "bad scalar initialization");
1212: /* this will never be called with a field element... */
1213: else inforce( tsize(t,d,s) );
1214:
1215: paramno = 0;
1216: vfdalign( ALINIT );
1217: inoff = 0;
1218: iclass = SNULL;
1219:
1220: }
1221:
1222: doinit( p )
1223: register NODE *p;
1224:
1225: {
1226:
1227: /* take care of generating a value for the initializer p */
1228: /* inoff has the current offset (last bit written)
1229: ** in the current word being generated
1230: */
1231:
1232: register sz, d, s;
1233: register TWORD t;
1234:
1235: /* note: size of an individual initializer assumed to fit into an int */
1236:
1237: if( iclass < 0 ) goto leave;
1238: if( iclass == EXTERN || iclass == UNAME )
1239: {
1240: uerror( "cannot initialize extern or union" );
1241: iclass = -1;
1242: goto leave;
1243: }
1244:
1245: if( iclass == AUTO || iclass == REGISTER )
1246: {
1247: /* do the initialization and get out, without regard
1248: ** for filing out the variable with zeros, etc.
1249: */
1250: bccode();
1251: idname = pstk->in_id;
1252: p = buildtree( ASSIGN, buildtree( NAME, NIL, NIL ), p );
1253: ecomp(p);
1254: return;
1255: }
1256:
1257: if( p == NIL ) return; /* throw away strings already made into lists */
1258:
1259: if( ibseen )
1260: {
1261: uerror( "} expected");
1262: goto leave;
1263: }
1264:
1265: # ifndef NODBG
1266: if( idebug > 1 ) printf( "doinit(%o)\n", p );
1267: # endif
1268:
1269: t = pstk->in_t; /* type required */
1270: d = pstk->in_d;
1271: s = pstk->in_s;
1272: if( pstk->in_sz < 0 )
1273: {
1274: /* bit field */
1275: sz = -pstk->in_sz;
1276: }
1277: else
1278: {
1279: sz = tsize( t, d, s );
1280: }
1281:
1282: inforce( pstk->in_off );
1283:
1284: p = buildtree( ASSIGN, block( NAME, NIL,NIL, t, d, s ), p );
1285: p->in.left->in.op = FREE;
1286: p->in.left = p->in.right;
1287: p->in.right = NIL;
1288: p->in.left = optim( p->in.left );
1289: if( p->in.left->in.op == UNARY AND )
1290: {
1291: p->in.left->in.op = FREE;
1292: p->in.left = p->in.left->in.left;
1293: }
1294: p->in.op = INIT;
1295: p = optim(p);
1296:
1297: # ifndef NOFLOAT
1298: if( p->in.left->in.op == FCON )
1299: {
1300: fincode( p->in.left->fpn.dval, sz );
1301: }
1302: else
1303: # endif
1304: if( p->in.left->in.op != ICON )
1305: {
1306: uerror( "illegal initialization" );
1307: inoff += sz;
1308: }
1309: else
1310: {
1311: /* a constant is being used as initializer */
1312: if( sz < SZINT )
1313: {
1314: /* special case: bit fields, etc. */
1315: incode( p->in.left, sz );
1316: }
1317: else
1318: {
1319: # ifdef MYINIT
1320: MYINIT( optim(p), sz );
1321: # else
1322: ecode( optim(p) );
1323: inoff += sz;
1324: # endif
1325: }
1326: }
1327:
1328: gotscal();
1329:
1330: leave:
1331: tfree(p);
1332: }
1333:
1334: gotscal()
1335: {
1336: register t, ix;
1337: register n, id;
1338: register struct symtab *p;
1339: register OFFSZ temp;
1340:
1341: for( ; pstk > instack; )
1342: {
1343:
1344: if( pstk->in_fl ) ++ibseen;
1345:
1346: --pstk;
1347:
1348: t = pstk->in_t;
1349:
1350: if( t == STRTY )
1351: {
1352: ix = ++pstk->in_x;
1353: if( (id=dimtab[ix]) < 0 ) continue;
1354:
1355: /* otherwise, put next element on the stack */
1356:
1357: p = &stab[id];
1358: instk( id, p->stype, p->dimoff, p->sizoff, p->offset+pstk->in_off );
1359: return;
1360: }
1361: else if( ISARY(t) )
1362: {
1363: n = ++pstk->in_n;
1364: if( n >= dimtab[pstk->in_d] && pstk > instack ) continue;
1365:
1366: /* put the new element onto the stack */
1367:
1368: temp = pstk->in_sz;
1369: instk( pstk->in_id, (TWORD)DECREF(pstk->in_t), pstk->in_d+1, pstk->in_s,
1370: pstk->in_off+n*temp );
1371: return;
1372: }
1373:
1374: }
1375:
1376: }
1377:
1378: ilbrace()
1379: {
1380: /* process an initializer's left brace */
1381: register t;
1382: register struct instk *temp;
1383:
1384: temp = pstk;
1385:
1386: for( ; pstk > instack; --pstk )
1387: {
1388:
1389: t = pstk->in_t;
1390: if( t != STRTY && !ISARY(t) ) continue; /* not an aggregate */
1391: if( pstk->in_fl )
1392: {
1393: /* already associated with a { */
1394: if( pstk->in_n ) uerror( "illegal {");
1395: continue;
1396: }
1397:
1398: /* we have one ... */
1399: pstk->in_fl = 1;
1400: break;
1401: }
1402:
1403: /* cannot find one */
1404: /* ignore such right braces */
1405:
1406: pstk = temp;
1407: }
1408:
1409: irbrace()
1410: {
1411: /* called when a '}' is seen */
1412:
1413: # ifndef NODBG
1414: if( idebug ) printf( "irbrace(): paramno = %d on entry\n", paramno );
1415: # endif
1416:
1417: if( ibseen )
1418: {
1419: --ibseen;
1420: return;
1421: }
1422:
1423: for( ; pstk > instack; --pstk )
1424: {
1425: if( !pstk->in_fl ) continue;
1426:
1427: /* we have one now */
1428:
1429: pstk->in_fl = 0; /* cancel { */
1430: gotscal(); /* take it away... */
1431: return;
1432: }
1433:
1434: /* these right braces match ignored left braces: throw out */
1435:
1436: }
1437:
1438: upoff( size, alignment, poff )
1439: register alignment, *poff;
1440: {
1441: /* update the offset pointed to by poff; return the
1442: ** offset of a value of size `size', alignment `alignment',
1443: ** given that off is increasing
1444: */
1445:
1446: register off;
1447:
1448: off = *poff;
1449: SETOFF( off, alignment );
1450: if( (maxoffset-off) < size )
1451: {
1452: if( instruct!=INSTRUCT )cerror("too many local variables");
1453: else cerror("Structure too large");
1454: }
1455: *poff = off+size;
1456: return( off );
1457: }
1458:
1459: oalloc( p, poff )
1460: register struct symtab *p;
1461: register *poff;
1462: {
1463: /* allocate p with offset *poff, and update *poff */
1464: register al, off, tsz;
1465: int noff;
1466:
1467: al = talign( p->stype, p->sizoff );
1468: noff = off = *poff;
1469: tsz = tsize( p->stype, p->dimoff, p->sizoff );
1470: #ifdef BACKAUTO
1471: if( p->sclass == AUTO )
1472: {
1473: if( (maxoffset-off) < tsz ) cerror("too many local variables");
1474: noff = off + tsz;
1475: SETOFF( noff, al );
1476: off = -noff;
1477: }
1478: else
1479: #endif
1480: #ifdef BACKPARAM
1481: /* this is rather nonstandard, and may be buggy in some cases */
1482: /* in particular, won't work with ARGSRET and ARGALLRET */
1483: if( p->sclass == PARAM )
1484: {
1485: if( (maxoffset-off) < tsz ) cerror("too many local variables");
1486: if( tsz < SZINT )
1487: {
1488: noff = off + SZINT;
1489: SETOFF( noff, ALINT );
1490: off = -noff;
1491: # ifndef RTOLBYTES
1492: off += tsz;
1493: #endif
1494: }
1495: else
1496: {
1497: noff = off + tsz;
1498: SETOFF( noff, al );
1499: off = -noff;
1500: }
1501: }
1502: else
1503: #endif
1504: if( p->sclass == PARAM && ( tsz < SZINT ) )
1505: {
1506: off = upoff( SZINT, ALINT, &noff );
1507: # ifndef RTOLBYTES
1508: off = noff - tsz;
1509: #endif
1510: }
1511: else
1512: {
1513: off = upoff( tsz, al, &noff );
1514: }
1515:
1516: if( p->sclass != REGISTER )
1517: {
1518: /* in case we are allocating stack space for register arguments */
1519: if( p->offset == NOOFFSET ) p->offset = off;
1520: else if( off != p->offset ) return(1);
1521: }
1522:
1523: *poff = noff;
1524: return(0);
1525: }
1526:
1527: falloc( p, w, new, pty )
1528: register struct symtab *p;
1529: register NODE *pty;
1530: {
1531: /* allocate a field of width w */
1532: /* new is 0 if new entry, 1 if redefinition, -1 if alignment */
1533:
1534: register al,sz,type;
1535:
1536: type = (new<0)? pty->in.type : p->stype;
1537:
1538: /* this must be fixed to use the current type in alignments */
1539: switch( new<0?pty->in.type:p->stype )
1540: {
1541:
1542: case ENUMTY:
1543: {
1544: register s;
1545: s = new<0 ? pty->fn.csiz : p->sizoff;
1546: al = dimtab[s+2];
1547: sz = dimtab[s];
1548: break;
1549: }
1550:
1551: case CHAR:
1552: case UCHAR:
1553: al = ALCHAR;
1554: sz = SZCHAR;
1555: break;
1556:
1557: case SHORT:
1558: case USHORT:
1559: al = ALSHORT;
1560: sz = SZSHORT;
1561: break;
1562:
1563: case INT:
1564: case UNSIGNED:
1565: al = ALINT;
1566: sz = SZINT;
1567: break;
1568: #ifdef LONGFIELDS
1569:
1570: case LONG:
1571: case ULONG:
1572: al = ALLONG;
1573: sz = SZLONG;
1574: break;
1575: #endif
1576:
1577: default:
1578: # ifdef FUNNYFLDS
1579: if( new < 0 )
1580: {
1581: # endif
1582: uerror( "illegal field type" );
1583: al = ALINT;
1584: # ifdef FUNNYFLDS
1585: }
1586: else
1587: {
1588: al = fldal( p->stype );
1589: sz =SZINT;
1590: }
1591: # endif
1592: }
1593:
1594: if( w > sz )
1595: {
1596: uerror( "field too big");
1597: w = sz;
1598: }
1599:
1600: if( w == 0 )
1601: {
1602: /* align only */
1603: SETOFF( strucoff, al );
1604: if( new >= 0 ) uerror( "zero size field");
1605: return(0);
1606: }
1607:
1608: if( strucoff%al + w > sz ) SETOFF( strucoff, al );
1609: if( new < 0 )
1610: {
1611: if( (maxoffset-strucoff) < w )
1612: cerror("structure too large");
1613: strucoff += w; /* we know it will fit */
1614: return(0);
1615: }
1616:
1617: /* establish the field */
1618:
1619: if( new == 1 )
1620: {
1621: /* previous definition */
1622: if( p->offset != strucoff || p->sclass != (FIELD|w) ) return(1);
1623: }
1624: p->offset = strucoff;
1625: if( (maxoffset-strucoff) < w ) cerror("structure too large");
1626: strucoff += w;
1627: p->stype = type;
1628: return(0);
1629: }
1630:
1631: # ifndef EXCLASS
1632: # define EXCLASS EXTERN
1633: # endif
1634:
1635: nidcl( p )
1636: register NODE *p;
1637: {
1638: /* handle unitialized declarations */
1639: /* assumed to be not functions */
1640: register class;
1641: register commflag; /* flag for labelled common declarations */
1642:
1643: commflag = 0;
1644:
1645: /* compute class */
1646: if( (class=curclass) == SNULL )
1647: {
1648: if( blevel > 1 ) class = AUTO;
1649: else if( blevel != 0 || instruct ) cerror( "nidcl error" );
1650: else
1651: {
1652: /* blevel = 0 */
1653: if( (class = EXCLASS) == EXTERN ) commflag = 1;
1654: }
1655: }
1656:
1657: defid( p, class );
1658:
1659: if( class==EXTDEF || class==STATIC )
1660: {
1661:
1662: # ifndef ALLCOMM
1663: /* simulate initialization by 0 */
1664: beginit( p->tn.rval );
1665: endinit();
1666: # else
1667: commflag = 1;
1668: # endif
1669:
1670: }
1671: if( commflag ) commdec( p->tn.rval );
1672: }
1673:
1674: TWORD
1675: types( t1, t2, t3 )
1676: register TWORD t1, t2, t3;
1677: {
1678: /* return a basic type from basic types t1, t2, and t3 */
1679:
1680: TWORD t[3];
1681: register TWORD noun, adj, unsg;
1682: register i;
1683:
1684: t[0] = t1;
1685: t[1] = t2;
1686: t[2] = t3;
1687:
1688: unsg = INT; /* INT or UNSIGNED */
1689: noun = UNDEF; /* INT, CHAR, or FLOAT */
1690: adj = INT; /* INT, LONG, or SHORT */
1691:
1692: for( i=0; i<3; ++i )
1693: {
1694: switch( t[i] )
1695: {
1696:
1697: default:
1698: bad:
1699: uerror( "illegal type combination" );
1700: return( INT );
1701:
1702: case UNDEF:
1703: continue;
1704:
1705: case UNSIGNED:
1706: if( unsg != INT ) goto bad;
1707: unsg = UNSIGNED;
1708: continue;
1709:
1710: case LONG:
1711: case SHORT:
1712: if( adj != INT ) goto bad;
1713: adj = t[i];
1714: continue;
1715:
1716: case INT:
1717: case CHAR:
1718: case FLOAT:
1719: if( noun != UNDEF ) goto bad;
1720: noun = t[i];
1721: continue;
1722: }
1723: }
1724:
1725: /* now, construct final type */
1726: if( noun == UNDEF ) noun = INT;
1727: else if( noun == FLOAT )
1728: {
1729: if( unsg != INT || adj == SHORT ) goto bad;
1730: return( adj==LONG ? DOUBLE : FLOAT );
1731: }
1732: else if( noun == CHAR && adj != INT ) goto bad;
1733:
1734: /* now, noun is INT or CHAR */
1735: if( adj != INT ) noun = adj;
1736: if( unsg == UNSIGNED ) return( noun + (UNSIGNED-INT) );
1737: else return( noun );
1738: }
1739:
1740: NODE *
1741: tymerge( typ, idp )
1742: register NODE *typ, *idp;
1743:
1744: {
1745: /* merge type typ with identifier idp */
1746:
1747: register unsigned t;
1748: register i;
1749:
1750: if( typ->in.op != TYPE ) cerror( "tymerge: arg 1" );
1751: if(idp == NIL ) return( NIL );
1752:
1753: # ifndef NODBG
1754: if( ddebug > 2 ) eprint(idp);
1755: # endif
1756:
1757: idp->in.type = typ->in.type;
1758: idp->fn.cdim = curdim;
1759: tyreduce( idp );
1760: idp->fn.csiz = typ->fn.csiz;
1761:
1762: for( t=typ->in.type, i=typ->fn.cdim; t&TMASK; t = DECREF(t) )
1763: {
1764: if( ISARY(t) ) dstash( dimtab[i++] );
1765: }
1766:
1767: /* now idp is a single node: fix up type */
1768:
1769: idp->in.type = ctype( idp->in.type );
1770:
1771: if( (t = BTYPE(idp->in.type)) != STRTY && t != UNIONTY && t != ENUMTY )
1772: {
1773: idp->fn.csiz = t; /* in case ctype has rewritten things */
1774: }
1775:
1776: return( idp );
1777: }
1778:
1779: tyreduce( p )
1780: register NODE *p;
1781:
1782: {
1783:
1784: /* build a type, stash away dimensions, from a declaration parse tree */
1785: /* the type is built top down, the dimensions bottom up */
1786:
1787: register o, temp;
1788: register unsigned t;
1789:
1790: o = p->in.op;
1791: p->in.op = FREE;
1792:
1793: if( o == NAME ) return;
1794:
1795: t = INCREF( p->in.type );
1796: if( o == UNARY CALL ) t += (FTN-PTR);
1797: else if( o == LB )
1798: {
1799: t += (ARY-PTR);
1800: temp = p->in.right->tn.lval;
1801: p->in.right->in.op = FREE;
1802: }
1803:
1804: p->in.left->in.type = t;
1805: tyreduce( p->in.left );
1806:
1807: if( o == LB ) dstash( temp );
1808:
1809: p->tn.rval = p->in.left->tn.rval;
1810: p->in.type = p->in.left->in.type;
1811:
1812: }
1813:
1814: fixtype( p, class )
1815: register NODE *p;
1816: register class;
1817: {
1818: register unsigned t, type;
1819: register mod1, mod2;
1820: /* fix up the types, and check for legality */
1821:
1822: if( (type = p->in.type) == UNDEF ) return;
1823: if( mod2 = (type&TMASK) )
1824: {
1825: t = DECREF(type);
1826: while( mod1=mod2, mod2 = (t&TMASK) )
1827: {
1828: if( mod1 == ARY && mod2 == FTN )
1829: {
1830: uerror( "array of functions is illegal" );
1831: type = 0;
1832: }
1833: else if( mod1==FTN && ( mod2==ARY || mod2==FTN ) )
1834: {
1835: uerror( "function returns illegal type" );
1836: type = 0;
1837: }
1838: t = DECREF(t);
1839: }
1840: }
1841:
1842: /* detect function arguments, watching out for structure declarations */
1843: /* for example, beware of f(x) struct [ int a[10]; } *x; { ... } */
1844: /* the danger is that "a" will be converted to a pointer */
1845:
1846: if( class==SNULL && blevel==1 && !(instruct&(INSTRUCT|INUNION)) )
1847: class = PARAM;
1848: if( class == PARAM || ( class==REGISTER && blevel==1 ) )
1849: {
1850: if( type == FLOAT ) type = DOUBLE;
1851: else if( ISARY(type) )
1852: {
1853: ++p->fn.cdim;
1854: type += (PTR-ARY);
1855: }
1856: else if( ISFTN(type) )
1857: {
1858: werror( "a function is declared as an argument" );
1859: type = INCREF(type);
1860: }
1861: }
1862:
1863: if( instruct && ISFTN(type) )
1864: {
1865: uerror( "function illegal in structure or union" );
1866: type = INCREF(type);
1867: }
1868: p->in.type = type;
1869: }
1870:
1871: # ifndef MYCTYPE
1872: TWORD
1873: ctype( t )
1874: register TWORD t;
1875: {
1876: register TWORD bt;
1877: bt = BTYPE(t);
1878:
1879: # ifdef NOFLOAT
1880: if( bt==FLOAT || bt==DOUBLE ) cerror( "ctype:f" );
1881: # endif
1882:
1883: # ifdef NOSHORT
1884: # ifdef NOUNSIGNED
1885: if( bt==SHORT || bt==USHORT ) MODTYPE(t,INT);
1886: # else
1887: if( bt==SHORT ) MODTYPE(t,INT);
1888: else if( bt==USHORT) MODTYPE(t,UNSIGNED);
1889: # endif
1890: # endif
1891:
1892: # ifdef NOLONG
1893: # ifdef NOUNSIGNED
1894: if( bt==LONG || bt==ULONG ) MODTYPE(t,INT);
1895: # else
1896: if( bt==LONG ) MODTYPE(t,INT);
1897: else if( bt==ULONG) MODTYPE(t,UNSIGNED);
1898: # endif
1899: # endif
1900:
1901: #if defined(M32B) && defined(IMPREGAL)
1902: if ( bt==DOUBLE ) radbl();
1903: #endif
1904: return( t );
1905: }
1906: # endif
1907:
1908: uclass( class )
1909: register class;
1910: {
1911: /* give undefined version of class */
1912: if( class == SNULL ) return( EXTERN );
1913: else if( class == STATIC ) return( USTATIC );
1914: else if( class == FORTRAN ) return( UFORTRAN );
1915: else return( class );
1916: }
1917:
1918: fixclass( class, type )
1919: register TWORD type;
1920: register class;
1921:
1922: {
1923:
1924: /* first, fix null class */
1925:
1926: if( class == SNULL )
1927: {
1928: if( instruct&INSTRUCT ) class = MOS;
1929: else if( instruct&INUNION ) class = MOU;
1930: else if( blevel == 0 ) class = EXTDEF;
1931: else if( blevel == 1 ) class = PARAM;
1932: else class = AUTO;
1933:
1934: }
1935:
1936: /* now, do general checking */
1937:
1938: if( ISFTN( type ) )
1939: {
1940: switch( class )
1941: {
1942: default:
1943: uerror( "function has illegal storage class" );
1944: case AUTO:
1945: class = EXTERN;
1946: case EXTERN:
1947: case EXTDEF:
1948: case FORTRAN:
1949: case TYPEDEF:
1950: case STATIC:
1951: case UFORTRAN:
1952: case USTATIC:
1953: ;
1954: }
1955: }
1956:
1957: if( class&FIELD )
1958: {
1959: if( !(instruct&INSTRUCT) ) uerror( "illegal use of field" );
1960: return( class );
1961: }
1962:
1963: switch( class )
1964: {
1965:
1966: case MOU:
1967: if( !(instruct&INUNION) ) uerror( "illegal class" );
1968: return( class );
1969:
1970: case MOS:
1971: if( !(instruct&INSTRUCT) ) uerror( "illegal class" );
1972: return( class );
1973:
1974: case MOE:
1975: if( instruct & (INSTRUCT|INUNION) ) uerror( "illegal class" );
1976: return( class );
1977:
1978: case REGISTER:
1979: if( blevel == 0 ) uerror( "illegal register declaration" );
1980: /* if cisreg returns 1, nextrvar has the reg. number */
1981: else if( cisreg( type ) ) return( class );
1982: if( blevel == 1 ) return( PARAM );
1983: else return( AUTO );
1984:
1985: case AUTO:
1986: case LABEL:
1987: case ULABEL:
1988: if( blevel < 2 ) uerror( "illegal class" );
1989: return( class );
1990:
1991: case PARAM:
1992: if( blevel != 1 ) uerror( "illegal class" );
1993: return( class );
1994:
1995: case UFORTRAN:
1996: case FORTRAN:
1997: # ifdef NOFORTRAN
1998: NOFORTRAN; /* a condition which can regulate the FORTRAN usage */
1999: # endif
2000: if( !ISFTN(type) ) uerror( "fortran declaration must apply to function" );
2001: else
2002: {
2003: type = DECREF(type);
2004: if( ISFTN(type) || ISARY(type) || ISPTR(type) )
2005: {
2006: uerror( "fortran function has wrong type" );
2007: }
2008: }
2009: case STNAME:
2010: case UNAME:
2011: case ENAME:
2012: case EXTERN:
2013: case STATIC:
2014: case EXTDEF:
2015: case TYPEDEF:
2016: case USTATIC:
2017: return( class );
2018:
2019: default:
2020: cerror( "illegal class: %d", class );
2021: /* NOTREACHED */
2022: }
2023: }
2024:
2025: struct symtab *
2026: mknonuniq(idindex)
2027: register *idindex;
2028: {
2029: /* locate a symbol table entry for */
2030: /* an occurrence of a nonunique structure member name */
2031: /* or field */
2032: register i;
2033: register struct symtab * sp;
2034:
2035: sp = & stab[ i= *idindex ]; /* position search at old entry */
2036: while( sp->stype != TNULL )
2037: {
2038: /* locate unused entry */
2039: if( ++i >= SYMTSZ )
2040: {
2041: /* wrap around symbol table */
2042: i = 0;
2043: sp = stab;
2044: }
2045: else ++sp;
2046: if( i == *idindex ) cerror("Symbol table full");
2047: }
2048: sp->sflags = SNONUNIQ | SMOS;
2049: sp->sname = stab[*idindex].sname; /* old entry name */
2050: *idindex = i;
2051: # ifndef NODBG
2052: if( ddebug )
2053: {
2054: printf( "\tnonunique entry for %s from %d to %d\n",
2055: sp->sname, *idindex, i );
2056: }
2057: # endif
2058: return ( sp );
2059: }
2060:
2061: lookup( name, s)
2062: register char *name;
2063: {
2064: /* look up name: must agree with s w.r.t. STAG, SMOS and SHIDDEN */
2065:
2066: register i, ii;
2067: register struct symtab *sp;
2068:
2069: /* compute initial hash index */
2070: # ifndef NODBG
2071: if( ddebug > 2 )
2072: {
2073: printf( "lookup( %s, %d ), stwart=%d, instruct=%d\n",
2074: name, s, stwart, instruct );
2075: }
2076: # endif
2077:
2078: i = ((unsigned) name) % SYMTSZ;
2079:
2080: sp = &stab[ii=i];
2081:
2082: for(;;)
2083: {
2084: /* look for name */
2085: if( sp->stype == TNULL )
2086: {
2087: /* empty slot */
2088: sp->sflags = s; /* set STAG, SMOS if needed, turn off all others */
2089: sp->sname = name;
2090: sp->stype = UNDEF;
2091: sp->sclass = SNULL;
2092: return( i );
2093: }
2094: if( (sp->sflags & (STAG|SMOS|SHIDDEN)) != s ) goto next;
2095: if ( sp->sname == name )
2096: return( i );
2097: next:
2098: if( ++i >= SYMTSZ )
2099: {
2100: i = 0;
2101: sp = stab;
2102: }
2103: else ++sp;
2104: if( i == ii ) cerror( "symbol table full" );
2105: }
2106: }
2107:
2108: #ifndef checkst
2109: /* if not debugging, make checkst a macro */
2110: checkst(lev)
2111: {
2112: register int s, i, j;
2113: register struct symtab *p, *q;
2114:
2115: for( i=0, p=stab; i<SYMTSZ; ++i, ++p )
2116: {
2117: if( p->stype == TNULL ) continue;
2118: j = lookup( p->sname, p->sflags&(SMOS|STAG) );
2119: if( j != i )
2120: {
2121: q = &stab[j];
2122: if( q->stype == UNDEF ||
2123: q->slevel <= p->slevel )
2124: {
2125: cerror( "check error: %s", q->sname );
2126: }
2127: }
2128: else if( p->slevel > lev ) cerror( "%s check at level %d", p->sname, lev );
2129: }
2130: }
2131: #endif
2132:
2133: struct symtab *
2134: relook(p)
2135: register struct symtab *p;
2136:
2137: {
2138: /* look up p again, and see where it lies */
2139: register struct symtab *q;
2140:
2141: /* I'm not sure that this handles towers of several hidden definitions in all cases */
2142: q = &stab[lookup( p->sname, p->sflags&(STAG|SMOS|SHIDDEN) )];
2143: /* make relook always point to either p or an empty cell */
2144: if( q->stype == UNDEF )
2145: {
2146: q->stype = TNULL;
2147: return(q);
2148: }
2149: while( q != p )
2150: {
2151: if( q->stype == TNULL ) break;
2152: if( ++q >= &stab[SYMTSZ] ) q=stab;
2153: }
2154: return(q);
2155: }
2156:
2157: clearst( lev )
2158: {
2159: /* clear entries of internal scope from the symbol table */
2160: extern struct symtab *scopestack[];
2161: register struct symtab *p, *q, *r;
2162:
2163: # ifdef STABS
2164: /* do this first, so structure members don't get clobbered
2165: ** before they are printed out...
2166: */
2167: aobeg();
2168: p = scopestack[blevel];
2169: while (p)
2170: {
2171: aocode(p);
2172: p = p->scopelink;
2173: }
2174: aoend();
2175: # endif
2176:
2177: /* q is to collect enteries which properly belong to
2178: an outer scope */
2179: q = (struct symtab *) NULL;
2180: /* first, find an empty slot to prevent newly hashed entries
2181: ** from being slopped into...
2182: */
2183:
2184: p = scopestack[lev];
2185: while (p)
2186: {
2187: # ifndef NODBG
2188: if (ddebug)
2189: printf("removing %s = stab[ %d], flags %o level %d\n",
2190: p->sname,p-stab,p->sflags,p->slevel);
2191: # endif
2192: /* if this is still undefined, complain */
2193: if (p->stype == UNDEF ||
2194: ( p->sclass == ULABEL && lev <=2) ) {
2195: uerror("%s undefined", p->sname);
2196: }
2197: if( p->sflags & SHIDES )
2198: unhide(p);
2199: if( (r=relook(p)) != p )
2200: movestab( r, p );
2201: if ( lev > p->slevel ) {
2202: /* collect outer scope entries first
2203: appearing in inner scope */
2204: r = p;
2205: p = p->scopelink;
2206: r->scopelink = q;
2207: q = r;
2208: } else {
2209: p->stype = TNULL;
2210: p = p->scopelink;
2211: }
2212: }
2213: scopestack[lev] = (struct symtab *) NULL;
2214: /* move outer scope entries into holes, and up a level */
2215: while( q )
2216: {
2217: r = &stab[ lookup( q->sname, q->sflags ) ];
2218: if ( r != q )
2219: {
2220: movestab( r, q );
2221: q->stype = TNULL;
2222: }
2223: q = q->scopelink;
2224: r->scopelink = scopestack[ lev-1 ];
2225: scopestack[ lev-1 ] = r;
2226: }
2227: }
2228:
2229: movestab( p, q )
2230: register struct symtab *p, *q;
2231: {
2232: /* structure assignment: *p = *q; */
2233: p->stype = q->stype;
2234: p->sclass = q->sclass;
2235: p->slevel = q->slevel;
2236: p->offset = q->offset;
2237: p->sflags = q->sflags;
2238: p->dimoff = q->dimoff;
2239: p->sizoff = q->sizoff;
2240: p->suse = q->suse;
2241: p->sname = q->sname;
2242: }
2243:
2244: hide( p )
2245: register struct symtab *p;
2246: {
2247: register struct symtab *q;
2248: for( q=p+1; ; ++q )
2249: {
2250: if( q >= &stab[SYMTSZ] ) q = stab;
2251: if( q == p ) cerror( "symbol table full" );
2252: if( q->stype == TNULL ) break;
2253: }
2254: movestab( q, p );
2255: p->sflags |= SHIDDEN;
2256: q->sflags = (p->sflags&(SMOS|STAG)) | SHIDES;
2257: if( hflag ) werror( "%s redefinition hides earlier one", p->sname );
2258: # ifndef NODBG
2259: if( ddebug ) printf( " %d hidden in %d\n", p-stab, q-stab );
2260: # endif
2261: return( idname = q-stab );
2262: }
2263:
2264: unhide( p )
2265: register struct symtab *p;
2266: {
2267: register struct symtab *q;
2268: register s;
2269:
2270: s = p->sflags & (SMOS|STAG);
2271: q = p;
2272:
2273: for(;;)
2274: {
2275:
2276: if( q == stab ) q = &stab[SYMTSZ-1];
2277: else --q;
2278:
2279: if( q == p ) break;
2280:
2281: if( (q->sflags&(SMOS|STAG)) == s )
2282: {
2283: if ( p->sname == q->sname )
2284: {
2285: /* found the name */
2286: q->sflags &= ~SHIDDEN;
2287: # ifndef NODBG
2288: if( ddebug ) printf( "unhide uncovered %d from %d\n", q-stab,p-stab);
2289: # endif
2290: return;
2291: }
2292: }
2293:
2294: }
2295: cerror( "unhide fails" );
2296: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.