Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030110220256

Diff

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