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