Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030121232624

Diff

Diff from 1.24 to:

Annotations

Annotate by Age | Author | Mixed | None
/fisheye/browse/pcc/pcc/cc/ccom/pftn.c

Annotated File View

ragge
1.2
1 #if 0
ragge
1.1
2 static char *sccsid ="@(#)pftn.c        1.29 (Berkeley) 6/18/90";
ragge
1.2
3 #endif
ragge
1.1
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 */
ragge
1.18
11 static int strunem;                     /* currently parsed member */
ragge
1.1
12
13 struct instk {
14         int in_sz;   /* size of array element */
15         int in_x;    /* current index for structure member in structure initializations */
16         int in_n;    /* number of initializations seen */
17         int in_s;    /* sizoff */
18         int in_d;    /* dimoff */
19         TWORD in_t;    /* type */
20         int in_id;   /* stab index */
21         int in_fl;   /* flag which says if this level is controlled by {} */
22         OFFSZ in_off;  /* offset of the beginning of this level */
ragge
1.2
23 instack[10], *pstk;
ragge
1.1
24
ragge
1.2
25 /* defines used for getting things off of the initialization stack */
ragge
1.1
26
27
ragge
1.2
28 struct symtab *relook(struct symtab *);
29 struct symtab * mknonuniq(int *);
30 void fixtype(NODE *pint class);
31 int fixclass(int classTWORD type);
32 int falloc(struct symtab *pint wint newNODE *pty);
33 void psave(int);
34 int oalloc(struct symtab *pint *poff);
35 int hide(struct symtab *p);
36 void inforce(OFFSZ n);
37 void vfdalign(int n);
38 void instk(int idTWORD tint dint sOFFSZ off);
39 void gotscal(void);
ragge
1.1
40
41 int ddebug = 0;
42
ragge
1.2
43 void
44 defid(NODE *qint class)
45 {
46         struct symtab *p;
ragge
1.1
47         int idp;
ragge
1.2
48         TWORD type;
ragge
1.1
49         TWORD stp;
ragge
1.2
50         int scl;
ragge
1.1
51         int dsymddef;
52         int slevtemp;
53         int changed;
54
55         ifq == NIL ) return;  /* an error was detected */
56
57         ifq < node || q >= &node[TREESZ] ) cerror"defid call" );
58
59         idp = q->tn.rval;
60
61         ifidp < 0 ) cerror"tyreduce" );
62         p = &stab[idp];
63
64 # ifndef BUG1
ragge
1.4
65         if (ddebug) {
66                 printf("defid(%s (%d), "p->snameidp);
67                 tprint(q->in.type);
68                 printf(", %s, (%d,%d)), level %d\n"scnames(class),
69                     q->fn.cdimq->fn.csizblevel);
70         }
ragge
1.1
71 # endif
72
73         fixtypeqclass );
74
75         type = q->in.type;
76         class = fixclassclasstype );
77
78         stp = p->stype;
79         slev = p->slevel;
80
81 # ifndef BUG1
ragge
1.4
82         if (ddebug) {
83                 printf("        modified to ");
84                 tprint(type);
85                 printf(", %s\n"scnames(class));
86                 printf("        previous def'n: ");
87                 tprint(stp);
88                 printf(", %s, (%d,%d)), level %d\n",
89                     scnames(p->sclass), p->dimoffp->sizoffslev);
90         }
ragge
1.1
91 # endif
92
93         ifstp == FTN && p->sclass == SNULL )goto enter;
ragge
1.4
94         if (blevel==1 && stp!=FARG)
95                 switchclass ){
ragge
1.1
96                 default:
ragge
1.4
97                         if (!(class&FIELD))
98                                 uerror"declared argument %s is missing",
99                                     p->sname );
ragge
1.1
100                 case MOS:
101                 case STNAME:
102                 case MOU:
103                 case UNAME:
104                 case MOE:
105                 case ENAME:
106                 case TYPEDEF:
107                         ;
ragge
1.4
108         }
ragge
1.1
109         ifstp == UNDEF|| stp == FARG ) goto enter;
110
111         iftype != stp ) goto mismatch;
112         ifblevel > slev && (class == AUTO || class == REGISTER) )
113                 /* new scope */
114                 goto mismatch;
115
116         /* test (and possibly adjust) dimensions */
117         dsym = p->dimoff;
118         ddef = q->fn.cdim;
119         changed = 0;
120         fortemp=typetemp&TMASKtemp = DECREF(temp) ){
121                 ifISARY(temp) ){
122                         if (dimtab[dsym] == 0) {
123                                 dimtab[dsym] = dimtab[ddef];
124                                 changed = 1;
125                                 }
126                         else if (dimtab[ddef]!=0&&dimtab[dsym]!=dimtab[ddef]) {
127                                 goto mismatch;
128                                 }
129                         ++dsym;
130                         ++ddef;
131                         }
132                 }
133
134         if (changed) {
135                 FIXDEF(p);
136                 }
137
138         /* check that redeclarations are to the same structure */
139         if( (temp==STRTY||temp==UNIONTY||temp==ENUMTY) && p->sizoff != q->fn.csiz
140                  && class!=STNAME && class!=UNAME && class!=ENAME ){
141                 goto mismatch;
142                 }
143
144         scl = ( p->sclass );
145
146 # ifndef BUG1
147         ifddebug ){
148                 printf"       previous class: %s\n"scnames(scl) );
149                 }
150 # endif
151
152         ifclass&FIELD ){
153                 /* redefinition */
154                 if( !fallocpclass&FLDSIZ1NIL ) ) {
155                         /* successful allocation */
156                         psaveidp );
157                         return;
158                         }
159                 /* blew it: resume at end of switch... */
160                 }
161
162         else switchclass ){
163
164         case EXTERN:
165                 switchscl ){
166                 case STATIC:
167                 case USTATIC:
168                         ifslev==0 ) return;
169                         break;
170                 case EXTDEF:
171                 case EXTERN:
172                 case FORTRAN:
173                 case UFORTRAN:
174                         return;
175                         }
176                 break;
177
178         case STATIC:
179                 ifscl==USTATIC || (scl==EXTERN && blevel==0) ){
180                         p->sclass = STATIC;
181                         ifISFTN(type) ) curftn = idp;
182                         return;
183                         }
184                 break;
185
186         case USTATIC:
187                 ifscl==STATIC || scl==USTATIC ) return;
188                 break;
189
190         case TYPEDEF:
191                 ifscl == class ) return;
192                 break;
193
194         case UFORTRAN:
195                 ifscl == UFORTRAN || scl == FORTRAN ) return;
196                 break;
197
198         case FORTRAN:
199                 ifscl == UFORTRAN ){
200                         p->sclass = FORTRAN;
201                         ifISFTN(type) ) curftn = idp;
202                         return;
203                         }
204                 break;
205
206         case MOU:
207         case MOS:
208                 ifscl == class ) {
209                         ifoallocp, &strucoff ) ) break;
210                         ifclass == MOU ) strucoff = 0;
211                         psaveidp );
212                         return;
213                         }
214                 break;
215
216         case MOE:
217                 break;
218
219         case EXTDEF:
ragge
1.10
220                 switch (scl) {
221                 case EXTERN:
ragge
1.1
222                         p->sclass = EXTDEF;
ragge
1.10
223                         if (ISFTN(type))
224                                 curftn = idp;
ragge
1.1
225                         return;
ragge
1.10
226                 case USTATIC:
227                         p->sclass = STATIC;
228                         if (ISFTN(type))
229                                 curftn = idp;
230                         return;
231                 }
ragge
1.1
232                 break;
233
234         case STNAME:
235         case UNAME:
236         case ENAME:
237                 ifscl != class ) break;
238                 ifdimtab[p->sizoff] == 0 ) return;  /* previous entry just a mention */
239                 break;
240
241         case PARAM:
242         case AUTO:
243         case REGISTER:
244                 ;  /* mismatch.. */
245
246                 }
247
248         mismatch:
249         /* allow nonunique structure/union member names */
250
251         ifclass==MOU || class==MOS || class & FIELD ){/* make a new entry */
ragge
1.2
252                 int *memp;
ragge
1.1
253                 p->sflags |= SNONUNIQ;  /* old entry is nonunique */
254                 /* determine if name has occurred in this structure/union */
255                 if (paramno > 0formemp = &paramstk[paramno-1];
256                         /* while */ *memp>=0 && stab[*memp].sclass != STNAME
257                                 && stab[*memp].sclass != UNAME;
258                         /* iterate */ --memp){ char *cname, *oname;
259                         ifstab[*memp].sflags & SNONUNIQ ){
260                                 cname=p->sname;
261                                 oname=stab[*memp].sname;
262                                 if (cname != onamegoto diff;
263                                 uerror("redeclaration of: %s",p->sname);
264                                 break;
265                                 diffcontinue;
266                                 }
267                         }
268                 p = mknonuniq( &idp ); /* update p and idp to new entry */
269                 goto enter;
270                 }
ragge
1.24
271         if (blevel > slev && class != EXTERN && class != FORTRAN &&
272             class != UFORTRAN) {
ragge
1.1
273                 q->tn.rval = idp = hidep );
274                 p = &stab[idp];
275                 goto enter;
ragge
1.24
276         }
ragge
1.1
277         uerror"redeclaration of %s"p->sname );
278         ifclass==EXTDEF && ISFTN(type) ) curftn = idp;
279         return;
280
281         enter:  /* make a new entry */
282
283 # ifndef BUG1
284         ifddebug ) printf"  new entry made\n" );
285 # endif
286         iftype == UNDEF ) uerror("void type for %s",p->sname);
287         p->stype = type;
288         p->sclass = class;
289         p->slevel = blevel;
290         p->offset = NOOFFSET;
291         p->suse = lineno;
292         ifclass == STNAME || class == UNAME || class == ENAME ) {
293                 p->sizoff = curdim;
294                 dstash0 );  /* size */
295                 dstash( -1 ); /* index to members of str or union */
296                 dstashALSTRUCT );  /* alignment */
297                 dstashidp );
298                 }
299         else {
300                 switchBTYPE(type) ){
301                 case STRTY:
302                 case UNIONTY:
303                 case ENUMTY:
304                         p->sizoff = q->fn.csiz;
305                         break;
306                 default:
307                         p->sizoff = BTYPE(type);
308                         }
309                 }
310
311         /* copy dimensions */
312
313         p->dimoff = q->fn.cdim;
314
315         /* allocate offsets */
316         ifclass&FIELD ){
317                 (voidfallocpclass&FLDSIZ0NIL );  /* new entry */
318                 psaveidp );
319                 }
320         else switchclass ){
321
322         case AUTO:
323                 (voidoallocp, &autooff );
324                 break;
325         case STATIC:
326         case EXTDEF:
327                 p->offset = getlab();
328                 ifISFTN(type) ) curftn = idp;
329                 break;
330
331         case EXTERN:
332         case UFORTRAN:
333         case FORTRAN:
334                 p->offset = getlab();
335                 p->slevel = 0;
336                 break;
337         case MOU:
338         case MOS:
339                 (voidoallocp, &strucoff );
340                 ifclass == MOU ) strucoff = 0;
341                 psaveidp );
342                 break;
343
344         case MOE:
345                 p->offset = strucoff++;
346                 psaveidp );
347                 break;
348         case REGISTER:
349                 p->offset = regvar--;
350                 ifblevel == 1 ) p->sflags |= SSET;
351                 ifregvar < minrvar ) minrvar = regvar;
352                 break;
353                 }
354
355         {
ragge
1.2
356                 int l = p->slevel;
ragge
1.1
357
358                 ifl >= MAXSCOPES )
359                         cerror"scopes nested too deep" );
360
361                 p->snext = schain[l];
362                 schain[l] = p;
363                 ifl >= chaintop )
364                         chaintop = l + 1;
365                 }
366
367         /* user-supplied routine to fix up new definitions */
368
369         FIXDEF(p);
370
371 # ifndef BUG1
372         ifddebug ) printf"  dimoff, sizoff, offset: %d, %d, %d\n"p->dimoffp->sizoffp->offset );
373 # endif
374
375         }
376
ragge
1.2
377 void
378 psave(int i)
379 {
ragge
1.1
380         ifparamno >= PARAMSZ ){
381                 cerror"parameter stack overflow");
ragge
1.2
382         }
ragge
1.1
383         paramstkparamno++ ] = i;
ragge
1.2
384 }
ragge
1.1
385
ragge
1.2
386 /*
387  * end of function
388  */
389 void
390 ftnend()
391 {
ragge
1.1
392         ifretlab != NOLAB && nerrors == 0 ){ /* inside a real function */
393                 efcode();
ragge
1.2
394         }
ragge
1.1
395         checkst(0);
396         retstat = 0;
397         tcheck();
398         brklab = contlab = retlab = NOLAB;
399         flostat = 0;
400         ifnerrors == 0 ){
401                 ifpsavbc != & asavbc[0] ) cerror("bcsave error");
402                 ifparamno != 0 ) cerror("parameter reset error");
403                 ifswx != 0 ) cerror"switch error");
404                 }
405         psavbc = &asavbc[0];
406         paramno = 0;
407         autooff = AUTOINIT;
408         minrvar = regvar = MAXRVAR;
409         reached = 1;
410         swx = 0;
411         swp = swtab;
412         (voidlocctr(DATA);
ragge
1.2
413 }
ragge
1.1
414
ragge
1.2
415 void
416 dclargs()
417 {
418         int ij;
419         struct symtab *p;
420         NODE *q;
ragge
1.1
421         argoff = ARGINIT;
ragge
1.12
422
ragge
1.1
423 # ifndef BUG1
ragge
1.12
424         if (ddebug > 2)
425                 printf("dclargs()\n");
ragge
1.1
426 # endif
ragge
1.12
427         for (i = 0i < paramno; ++i) {
428                 if ((j = paramstk[i]) < 0)
429                         continue;
ragge
1.1
430                 p = &stab[j];
431 # ifndef BUG1
ragge
1.12
432                 if (ddebug > 2) {
ragge
1.1
433                         printf("\t%s (%d) ",p->snamej);
434                         tprint(p->stype);
435                         printf("\n");
ragge
1.12
436                 }
ragge
1.1
437 # endif
ragge
1.12
438                 if (p->stype == FARG) {
ragge
1.1
439                         q = block(FREE,NIL,NIL,INT,0,INT);
440                         q->tn.rval = j;
ragge
1.12
441                         defid(qPARAM);
442                 }
ragge
1.1
443                 FIXARG(p); /* local arg hook, eg. for sym. debugger */
ragge
1.12
444           /* always set aside space, even for register arguments */
445                 oalloc(p, &argoff);
446         }
ragge
1.1
447         cendarg();
448         (voidlocctr(PROG);
449         defalign(ALINT);
450         ftnno = getlab();
ragge
1.12
451         bfcode(paramstkparamno);
ragge
1.1
452         paramno = 0;
ragge
1.2
453 }
ragge
1.1
454
ragge
1.21
455 /*
456  * reference to a structure or union, with no definition
457  */
ragge
1.1
458 NODE *
ragge
1.21
459 rstruct(int idnint soru)
460 {
ragge
1.2
461         struct symtab *p;
462         NODE *q;
ragge
1.1
463         p = &stab[idn];
ragge
1.21
464         switch (p->stype) {
ragge
1.1
465
466         case UNDEF:
467         def:
ragge
1.21
468                 q = block(FREENILNIL000);
ragge
1.1
469                 q->tn.rval = idn;
ragge
1.21
470                 q->in.type = (soru&INSTRUCT) ? STRTY :
471                     ((soru&INUNION) ? UNIONTY : ENUMTY);
472                 defid(q, (soru&INSTRUCT) ? STNAME :
473                     ((soru&INUNION) ? UNAME : ENAME));
ragge
1.1
474                 break;
475
476         case STRTY:
ragge
1.21
477                 if (soru & INSTRUCT)
478                         break;
ragge
1.1
479                 goto def;
480
481         case UNIONTY:
ragge
1.21
482                 if (soru & INUNION)
483                         break;
ragge
1.1
484                 goto def;
485
486         case ENUMTY:
ragge
1.21
487                 if (!(soru&(INUNION|INSTRUCT)))
488                         break;
ragge
1.1
489                 goto def;
490
ragge
1.21
491         }
ragge
1.1
492         stwart = instruct;
ragge
1.21
493         return(mkty(p->stype0p->sizoff));
494 }
ragge
1.1
495
ragge
1.2
496 void
497 moedef(int idn)
498 {
499         NODE *q;
ragge
1.1
500
501         q = blockFREENILNILMOETY00 );
502         q->tn.rval = idn;
503         ifidn>=0 ) defidqMOE );
ragge
1.2
504 }
ragge
1.1
505
ragge
1.2
506 /*
507  * begining of structure or union declaration
508  */
509 int
510 bstruct(int idnint soru)
511 {
512         NODE *q;
ragge
1.1
513
ragge
1.18
514         psave(instruct);
515         psave(strunem);
516         psave(strucoff);
ragge
1.1
517         strucoff = 0;
518         instruct = soru;
ragge
1.21
519         q = block(FREENILNIL000);
ragge
1.1
520         q->tn.rval = idn;
ragge
1.21
521         if (instruct==INSTRUCT) {
ragge
1.18
522                 strunem = MOS;
ragge
1.1
523                 q->in.type = STRTY;
ragge
1.21
524                 if (idn >= 0)
525                         defid(qSTNAME);
526         } else if(instruct == INUNION) {
ragge
1.18
527                 strunem = MOU;
ragge
1.1
528                 q->in.type = UNIONTY;
ragge
1.21
529                 if (idn >= 0)
530                         defid(qUNAME);
531         } else { /* enum */
ragge
1.18
532                 strunem = MOE;
ragge
1.1
533                 q->in.type = ENUMTY;
ragge
1.21
534                 if (idn >= 0)
535                         defid(qENAME);
536         }
537         psave(idn = q->tn.rval);
ragge
1.1
538         /* the "real" definition is where the members are seen */
ragge
1.21
539         if (idn >= 0)
540                 stab[idn].suse = lineno;
541         return(paramno-4);
ragge
1.2
542 }
ragge
1.1
543
ragge
1.18
544 /*
545  * Called after a struct is declared to restore the environment.
546  */
ragge
1.1
547 NODE *
ragge
1.2
548 dclstruct(int oparam)
549 {
550         struct symtab *p;
551         int ialsajszszindex;
552         TWORD temp;
553         int highlow;
ragge
1.1
554
ragge
1.18
555         /*
556          * paramstk contains:
557          *      paramstk[oparam] = previous instruct
558          *      paramstk[oparam+1] = previous class
559          *      paramstk[oparam+2] = previous strucoff
560          *      paramstk[oparam+3] = structure name
561          *
562          *      paramstk[oparam+4, ...]  = member stab indices
563          */
ragge
1.1
564
565
ragge
1.18
566         if ((i = paramstk[oparam+3]) < 0) {
ragge
1.1
567                 szindex = curdim;
ragge
1.18
568                 dstash(0);  /* size */
569                 dstash(-1);  /* index to member names */
570                 dstash(ALSTRUCT);  /* alignment */
571                 dstash(-lineno);        /* name of structure */
572         } else
ragge
1.1
573                 szindex = stab[i].sizoff;
574
575 # ifndef BUG1
ragge
1.18
576         if (ddebug) {
577                 printf("dclstruct( %s ), szindex = %d\n",
578                     (i>=0)? stab[i].sname : "??"szindex);
579         }
ragge
1.1
580 # endif
581         temp = (instruct&INSTRUCT)?STRTY:((instruct&INUNION)?UNIONTY:ENUMTY);
ragge
1.18
582         stwart = instruct = paramstk[oparam];
583         strunem = paramstk[oparam+1];
584         dimtab[szindex+1] = curdim;
ragge
1.1
585         al = ALSTRUCT;
586
587         high = low = 0;
588
589         fori = oparam+4;  iparamno; ++i ){
590                 dstashj=paramstk[i] );
591                 ifj<0 || j>= SYMTSZ ) cerror"gummy structure member" );
592                 p = &stab[j];
593                 iftemp == ENUMTY ){
594                         ifp->offset < low ) low = p->offset;
595                         ifp->offset > high ) high = p->offset;
596                         p->sizoff = szindex;
597                         continue;
598                         }
599                 sa = talignp->stypep->sizoff );
ragge
1.21
600                 if (p->sclass & FIELD) {
ragge
1.1
601                         sz = p->sclass&FLDSIZ;
ragge
1.21
602                 } else {
603                         sz = tsize(p->stypep->dimoffp->sizoff);
604                 }
605 #if 0
606                 if (sz == 0) {
607                         werror("illegal zero sized structure member: %s"p->sname );
ragge
1.1
608                 }
ragge
1.21
609 #endif
610                 if (sz > strucoff)
611                         strucoff = sz;  /* for use with unions */
612                 /*
613                  * set al, the alignment, to the lcm of the alignments
614                  * of the members.
615                  */
616                 SETOFF(alsa);
617         }
618         dstash(-1);  /* endmarker */
ragge
1.1
619         SETOFFstrucoffal );
620
621         iftemp == ENUMTY ){
ragge
1.2
622                 TWORD ty;
ragge
1.1
623
624 # ifdef ENUMSIZE
625                 ty = ENUMSIZE(high,low);
626 # else
627                 if( (char)high == high && (char)low == low ) ty = ctypeCHAR );
628                 else if( (short)high == high && (short)low == low ) ty = ctypeSHORT );
629                 else ty = ctype(INT);
630 #endif
631                 strucoff = tsizety0, (int)ty );
632                 dimtabszindex+2 ] = al = talignty, (int)ty );
ragge
1.21
633         }
ragge
1.1
634
ragge
1.21
635 #if 0
636         if (strucoff == 0)
637                 uerror"zero sized structure" );
638 #endif
639         dimtab[szindex] = strucoff;
640         dimtab[szindex+2] = al;
641         dimtab[szindex+3] = paramstkoparam+3 ];  /* name index */
ragge
1.1
642
ragge
1.21
643         FIXSTRUCT(szindexoparam); /* local hook, eg. for sym debugger */
ragge
1.1
644 # ifndef BUG1
ragge
1.21
645         if (ddebug>1) {
646                 printf("\tdimtab[%d,%d,%d] = %d,%d,%d\n",
647                     szindex,szindex+1,szindex+2,
648                     dimtab[szindex],dimtab[szindex+1],dimtab[szindex+2] );
649                 for (i = dimtab[szindex+1]; dimtab[i] >= 0; ++i) {
650                         printf("\tmember %s(%d)\n",
651                             stab[dimtab[i]].snamedimtab[i]);
ragge
1.1
652                 }
ragge
1.21
653         }
ragge
1.1
654 # endif
655
656         strucoff = paramstkoparam+2 ];
657         paramno = oparam;
658
659         returnmktytemp0szindex ) );
ragge
1.21
660 }
ragge
1.1
661
ragge
1.2
662 /*
663  * error printing routine in parser
664  */
665 void yyerror(char *s);
666 void
667 yyerror(char *s)
668 {
669         uerror(s);
670 }
671
672 void yyaccpt(void);
673 void
674 yyaccpt(void)
675 {
ragge
1.1
676         ftnend();
ragge
1.2
677 }
ragge
1.1
678
ragge
1.2
679 void
680 ftnarg(int idn)
681 {
ragge
1.1
682         switchstab[idn].stype ){
683
684         case UNDEF:
685                 /* this parameter, entered at scan */
686                 break;
687         case FARG:
688                 uerror("redeclaration of formal parameter, %s",
689                         stab[idn].sname);
690                 /* fall thru */
691         case FTN:
692                 /* the name of this function matches parm */
693                 /* fall thru */
694         default:
695                 idn = hide( &stab[idn]);
696                 break;
697         case TNULL:
698                 /* unused entry, fill it */
699                 ;
700                 }
701         stab[idn].stype = FARG;
702         stab[idn].sclass = PARAM;
703         psaveidn );
ragge
1.2
704 }
ragge
1.1
705
ragge
1.2
706 /*
707  * compute the alignment of an object with type ty, sizeoff index s
708  */
709 int
710 talign(unsigned int tyint s)
711 {
712         int i;
ragge
1.1
713
714         ifs<0 && ty!=INT && ty!=CHAR && ty!=SHORT && ty!=UNSIGNED && ty!=UCHAR && ty!=USHORT 
715                                         ){
716                 returnfldalty ) );
717                 }
718
719         fori=0i<=(SZINT-BTSHIFT-1); i+=TSHIFT ){
720                 switch( (ty>>i)&TMASK ){
721
722                 case FTN:
723                         uerror"can't assign to function" );
724                         returnALCHAR );
725                 case PTR:
726                         returnALPOINT );
727                 case ARY:
728                         continue;
729                 case 0:
730                         break;
731                         }
732                 }
733
734         switchBTYPE(ty) ){
735
736         case UNIONTY:
737         case ENUMTY:
738         case STRTY:
739                 return( (unsigned intdimtabs+2 ] );
740         case CHAR:
741         case UCHAR:
ragge
1.9
742                 return (ALCHAR);
ragge
1.1
743         case FLOAT:
ragge
1.9
744                 return (ALFLOAT);
ragge
1.1
745         case DOUBLE:
ragge
1.9
746                 return (ALDOUBLE);
747         case LONGLONG:
748         case ULONGLONG:
749                 return (ALLONGLONG);
ragge
1.1
750         case LONG:
751         case ULONG:
ragge
1.9
752                 return (ALLONG);
ragge
1.1
753         case SHORT:
754         case USHORT:
ragge
1.9
755                 return (ALSHORT);
ragge
1.1
756         default:
ragge
1.9
757                 return (ALINT);
ragge
1.1
758                 }
759         }
760
761 OFFSZ
762 tsizetyds )  TWORD ty; {
763         /* compute the size associated with type ty,
764             dimoff d, and sizoff s */
765         /* BETTER NOT BE CALLED WHEN t, d, and s REFER TO A BIT FIELD... */
766
767         int i;
768         OFFSZ mult;
769
770         mult = 1;
771
772         fori=0i<=(SZINT-BTSHIFT-1); i+=TSHIFT ){
773                 switch( (ty>>i)&TMASK ){
774
775                 case FTN:
776                         /* cerror( "compiler takes size of function"); */
777                         uerror"can't take size of function" );
778                         returnSZCHAR );
779                 case PTR:
780                         returnSZPOINT * mult );
781                 case ARY:
782                         mult *= (unsigned intdimtabd++ ];
783                         continue;
784                 case 0:
785                         break;
786
787                         }
788                 }
789
ragge
1.21
790         if (ty != STRTY && ty != UNIONTY) {
791                 if (dimtab[s] == 0) {
792                         uerror("unknown size");
793                         return(SZINT);
794                 }
795         } else {
796                 if (dimtab[s+1] == -1)
797                         uerror("unknown structure/union");
798         }
799
ragge
1.1
800         return( (unsigned intdimtabs ] * mult );
ragge
1.21
801 }
ragge
1.1
802
ragge
1.2
803 /*
804  * force inoff to have the value n
805  */
806 void
807 inforce(OFFSZ n)
808 {
ragge
1.1
809         /* inoff is updated to have the value n */
810         OFFSZ wb;
ragge
1.2
811         int rest;
ragge
1.1
812         /* rest is used to do a lot of conversion to ints... */
813
814         ifinoff == n ) return;
ragge
1.20
815         if (inoff > n)
816                 cerror("initialization alignment error: inoff %lld n %lld",
817                     inoffn);
ragge
1.1
818
819         wb = inoff;
820         SETOFFwbSZINT );
821
822         /* wb now has the next higher word boundary */
823
824         ifwb >= n ){ /* in the same word */
825                 rest = n - inoff;
826                 vfdzerorest );
827                 return;
828                 }
829
830         /* otherwise, extend inoff to be word aligned */
831
832         rest = wb - inoff;
833         vfdzerorest );
834
835         /* now, skip full words until near to n */
836
837         rest = (n-inoff)/SZINT;
838         zecoderest );
839
840         /* now, the remainder of the last word */
841
842         rest = n-inoff;
843         vfdzerorest );
844         ifinoff != n ) cerror"inoff error");
845
846         }
847
ragge
1.2
848 /*
849  * make inoff have the offset the next alignment of n
850  */
851 void
852 vfdalign(int n)
853 {
ragge
1.1
854         OFFSZ m;
855
856         m = inoff;
857         SETOFFmn );
858         inforcem );
ragge
1.2
859 }
ragge
1.1
860
861
862 int idebug = 0;
863
864 int ibseen = 0;  /* the number of } constructions which have been filled */
865
866 int ifull = 0/* 1 if all initializers have been seen */
867
868 int iclass;  /* storage class of thing being initialized */
869
870 int ilocctr = 0;  /* location counter for current initialization */
871
ragge
1.2
872 /*
873  * beginning of initilization; set location ctr and set type
874  */
875 void
ragge
1.18
876 beginit(int curidint class)
ragge
1.2
877 {
878         struct symtab *p;
ragge
1.1
879
880 # ifndef BUG1
881         ifidebug >= 3 ) printf"beginit(), curid = %d\n"curid );
882 # endif
883
884         p = &stab[curid];
885
886         iclass = p->sclass;
ragge
1.18
887         ifclass == EXTERN || class == FORTRAN )
888                 iclass = EXTERN;
ragge
1.1
889         switchiclass ){
890
891         case UNAME:
892         case EXTERN:
893                 return;
894         case AUTO:
895         case REGISTER:
896                 break;
897         case EXTDEF:
898         case STATIC:
899                 ilocctr = ISARY(p->stype)?ADATA:DATA;
900                 ifnerrors == 0 ){
901                         (voidlocctrilocctr );
902                         defaligntalignp->stypep->sizoff ) );
903                         defnamp );
904                 }
ragge
1.2
905         }
ragge
1.1
906
907         inoff = 0;
908         ibseen = 0;
909         ifull = 0;
910
911         pstk = 0;
912
913         instkcuridp->stypep->dimoffp->sizoffinoff );
914
ragge
1.2
915 }
ragge
1.1
916
ragge
1.2
917 /*
918  * make a new entry on the parameter stack to initialize id
919  */
920 void
921 instk(int idTWORD tint dint sOFFSZ off)
922 {
923         struct symtab *p;
ragge
1.1
924
ragge
1.2
925         for (;;) {
ragge
1.1
926 # ifndef BUG1
ragge
1.2
927                 if (idebug)
ragge
1.11
928                         printf("instk((%d, %o,%d,%d, %lld)\n",
929                             idtds, (long long)off);
ragge
1.1
930 # endif
931
932                 /* save information on the stack */
933
ragge
1.19
934                 if (!pstk)
935                         pstk = instack;
936                 else
937                         ++pstk;
ragge
1.1
938
939                 pstk->in_fl = 0;        /* { flag */
ragge
1.20
940                 pstk->in_id = id;
941                 pstk->in_t = t;
942                 pstk->in_d = d;
943                 pstk->in_s = s;
ragge
1.1
944                 pstk->in_n = 0;  /* number seen */
ragge
1.20
945                 pstk->in_x = (t == STRTY || t == UNIONTY) ? dimtab[s+1] : 0 ;
ragge
1.19
946                 pstk->in_off = off;/* offset at the beginning of this element */
947
ragge
1.1
948                 /* if t is an array, DECREF(t) can't be a field */
ragge
1.19
949                 /* in_sz has size of array elements, and -size for fields */
950                 if (ISARY(t)) {
951                         pstk->in_sz = tsize(DECREF(t), d+1s);
952                 } else if (stab[id].sclass & FIELD){
953                         pstk->in_sz = - (stab[id].sclass & FLDSIZ);
954                 } else {
ragge
1.1
955                         pstk->in_sz = 0;
ragge
1.19
956                 }
ragge
1.1
957
ragge
1.19
958                 if ((iclass==AUTO || iclass == REGISTER) &&
959                     (ISARY(t) || t==STRTY))
960                         uerror("no automatic aggregate initialization");
ragge
1.1
961
962                 /* now, if this is not a scalar, put on another element */
963
ragge
1.19
964                 if (ISARY(t)) {
ragge
1.1
965                         t = DECREF(t);
966                         ++d;
967                         continue;
ragge
1.20
968                 } else if (t == STRTY || t == UNIONTY) {
ragge
1.19
969                         if (dimtab[pstk->in_s] == 0) {
ragge
1.20
970                                 uerror("can't initialize undefined %s",
971                                     t == STRTY ? "structure" : "union");
ragge
1.1
972                                 iclass = -1;
973                                 return;
ragge
1.19
974                         }
ragge
1.1
975                         id = dimtab[pstk->in_x];
976                         p = &stab[id];
ragge
1.20
977                         if (((p->sclass != MOS && t == STRTY) ||
978                             (p->sclass != MOU && t == UNIONTY)) &&
979                             !(p->sclass&FIELD))
980                                 cerror("insane %s member list",
981                                     t == STRTY ? "structure" : "union"