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