Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030531103446

Diff

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