Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030202145022

Diff

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