Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030106225154

Diff

Diff from 1.20 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
474 NODE *
475 rstructidnsoru ){ /* reference to a structure or union, with no definition */
ragge
1.2
476         struct symtab *p;
477         NODE *q;
ragge
1.1
478         p = &stab[idn];
479         switchp->stype ){
480
481         case UNDEF:
482         def:
483                 q = blockFREENILNIL000 );
484                 q->tn.rval = idn;
485                 q->in.type = (soru&INSTRUCT) ? STRTY : ( (soru&INUNION) ? UNIONTY : ENUMTY );
486                 defidq, (soru&INSTRUCT) ? STNAME : ( (soru&INUNION) ? UNAME : ENAME ) );
487                 break;
488
489         case STRTY:
490                 ifsoru & INSTRUCT ) break;
491                 goto def;
492
493         case UNIONTY:
494                 ifsoru & INUNION ) break;
495                 goto def;
496
497         case ENUMTY:
498                 if( !(soru&(INUNION|INSTRUCT)) ) break;
499                 goto def;
500
501                 }
502         stwart = instruct;
503         returnmktyp->stype0p->sizoff ) );
504         }
505
ragge
1.2
506 void
507 moedef(int idn)
508 {
509         NODE *q;
ragge
1.1
510
511         q = blockFREENILNILMOETY00 );
512         q->tn.rval = idn;
513         ifidn>=0 ) defidqMOE );
ragge
1.2
514 }
ragge
1.1
515
ragge
1.2
516 /*
517  * begining of structure or union declaration
518  */
519 int
520 bstruct(int idnint soru)
521 {
522         NODE *q;
ragge
1.1
523
ragge
1.18
524         psave(instruct);
525         psave(strunem);
526         psave(strucoff);
ragge
1.1
527         strucoff = 0;
528         instruct = soru;
529         q = blockFREENILNIL000 );
530         q->tn.rval = idn;
531         ifinstruct==INSTRUCT ){
ragge
1.18
532                 strunem = MOS;
ragge
1.1
533                 q->in.type = STRTY;
534                 ifidn >= 0 ) defidqSTNAME );
535                 }
536         else ifinstruct == INUNION ) {
ragge
1.18
537                 strunem = MOU;
ragge
1.1
538                 q->in.type = UNIONTY;
539                 ifidn >= 0 ) defidqUNAME );
540                 }
541         else { /* enum */
ragge
1.18
542                 strunem = MOE;
ragge
1.1
543                 q->in.type = ENUMTY;
544                 ifidn >= 0 ) defidqENAME );
545                 }
546         psaveidn = q->tn.rval );
547         /* the "real" definition is where the members are seen */
548         if ( idn >= 0 ) stab[idn].suse = lineno;
549         returnparamno-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 );
608                 ifp->sclass & FIELD ){
609                         sz = p->sclass&FLDSIZ;
610                         }
611                 else {
612                         sz = tsizep->stypep->dimoffp->sizoff );
613                         }
614                 ifsz == 0 ){
615                         werror"illegal zero sized structure member: %s"p->sname );
616                         }
617                 ifsz > strucoff ) strucoff = sz;  /* for use with unions */
618                 SETOFFalsa );
619                 /* set al, the alignment, to the lcm of the alignments of the members */
620                 }
621         dstash( -1 );  /* endmarker */
622         SETOFFstrucoffal );
623
624         iftemp == ENUMTY ){
ragge
1.2
625                 TWORD ty;
ragge
1.1
626
627 # ifdef ENUMSIZE
628                 ty = ENUMSIZE(high,low);
629 # else
630                 if( (char)high == high && (char)low == low ) ty = ctypeCHAR );
631                 else if( (short)high == high && (short)low == low ) ty = ctypeSHORT );
632                 else ty = ctype(INT);
633 #endif
634                 strucoff = tsizety0, (int)ty );
635                 dimtabszindex+2 ] = al = talignty, (int)ty );
636                 }
637
638         ifstrucoff == 0 ) uerror"zero sized structure" );
639         dimtabszindex ] = strucoff;
640         dimtabszindex+2 ] = al;
641         dimtabszindex+3 ] = paramstkoparam+3 ];  /* name index */
642
643         FIXSTRUCTszindexoparam ); /* local hook, eg. for sym debugger */
644 # ifndef BUG1
645         ifddebug>1 ){
646                 printf"\tdimtab[%d,%d,%d] = %d,%d,%d\n"szindex,szindex+1,szindex+2,
647                                 dimtab[szindex],dimtab[szindex+1],dimtab[szindex+2] );
648                 fori = dimtab[szindex+1]; dimtab[i] >= 0; ++i ){
649                         printf"\tmember %s(%d)\n"stab[dimtab[i]].snamedimtab[i] );
650                         }
651                 }
652 # endif
653
654         strucoff = paramstkoparam+2 ];
655         paramno = oparam;
656
657         returnmktytemp0szindex ) );
658         }
659
ragge
1.2
660 /*
661  * error printing routine in parser
662  */
663 void yyerror(char *s);
664 void
665 yyerror(char *s)
666 {
667         uerror(s);
668 }
669
670 void yyaccpt(void);
671 void
672 yyaccpt(void)
673 {
ragge
1.1
674         ftnend();
ragge
1.2
675 }
ragge
1.1
676
ragge
1.2
677 void
678 ftnarg(int idn)
679 {
ragge
1.1
680         switchstab[idn].stype ){
681
682         case UNDEF:
683                 /* this parameter, entered at scan */
684                 break;
685         case FARG:
686                 uerror("redeclaration of formal parameter, %s",
687                         stab[idn].sname);
688                 /* fall thru */
689         case FTN:
690                 /* the name of this function matches parm */
691                 /* fall thru */
692         default:
693                 idn = hide( &stab[idn]);
694                 break;
695         case TNULL:
696                 /* unused entry, fill it */
697                 ;
698                 }
699         stab[idn].stype = FARG;
700         stab[idn].sclass = PARAM;
701         psaveidn );
ragge
1.2
702 }
ragge
1.1
703
ragge
1.2
704 /*
705  * compute the alignment of an object with type ty, sizeoff index s
706  */
707 int
708 talign(unsigned int tyint s)
709 {
710         int i;
ragge
1.1
711
712         ifs<0 && ty!=INT && ty!=CHAR && ty!=SHORT && ty!=UNSIGNED && ty!=UCHAR && ty!=USHORT 
713                                         ){
714                 returnfldalty ) );
715                 }
716
717         fori=0i<=(SZINT-BTSHIFT-1); i+=TSHIFT ){
718                 switch( (ty>>i)&TMASK ){
719
720                 case FTN:
721                         uerror"can't assign to function" );
722                         returnALCHAR );
723                 case PTR:
724                         returnALPOINT );
725                 case ARY:
726                         continue;
727                 case 0:
728                         break;
729                         }
730                 }
731
732         switchBTYPE(ty) ){
733
734         case UNIONTY:
735         case ENUMTY:
736         case STRTY:
737                 return( (unsigned intdimtabs+2 ] );
738         case CHAR:
739         case UCHAR:
ragge
1.9
740                 return (ALCHAR);
ragge
1.1
741         case FLOAT:
ragge
1.9
742                 return (ALFLOAT);
ragge
1.1
743         case DOUBLE:
ragge
1.9
744                 return (ALDOUBLE);
745         case LONGLONG:
746         case ULONGLONG:
747                 return (ALLONGLONG);
ragge
1.1
748         case LONG:
749         case ULONG:
ragge
1.9
750                 return (ALLONG);
ragge
1.1
751         case SHORT:
752         case USHORT:
ragge
1.9
753                 return (ALSHORT);
ragge
1.1
754         default:
ragge
1.9
755                 return (ALINT);
ragge
1.1
756                 }
757         }
758
759 OFFSZ
760 tsizetyds )  TWORD ty; {
761         /* compute the size associated with type ty,
762             dimoff d, and sizoff s */
763         /* BETTER NOT BE CALLED WHEN t, d, and s REFER TO A BIT FIELD... */
764
765         int i;
766         OFFSZ mult;
767
768         mult = 1;
769
770         fori=0i<=(SZINT-BTSHIFT-1); i+=TSHIFT ){
771                 switch( (ty>>i)&TMASK ){
772
773                 case FTN:
774                         /* cerror( "compiler takes size of function"); */
775                         uerror"can't take size of function" );
776                         returnSZCHAR );
777                 case PTR:
778                         returnSZPOINT * mult );
779                 case ARY:
780                         mult *= (unsigned intdimtabd++ ];
781                         continue;
782                 case 0:
783                         break;
784
785                         }
786                 }
787
788         ifdimtab[s]==0 ) {
789                 ifty == STRTY )
790                         uerror"undefined structure" );
791                 else
792                         uerror"unknown size");
793                 returnSZINT );
794                 }
795         return( (unsigned intdimtabs ] * mult );
796         }
797
ragge
1.2
798 /*
799  * force inoff to have the value n
800  */
801 void
802 inforce(OFFSZ n)
803 {
ragge
1.1
804         /* inoff is updated to have the value n */
805         OFFSZ wb;
ragge
1.2
806         int rest;
ragge
1.1
807         /* rest is used to do a lot of conversion to ints... */
808
809         ifinoff == n ) return;
ragge
1.20
810         if (inoff > n)
811                 cerror("initialization alignment error: inoff %lld n %lld",
812                     inoffn);
ragge
1.1
813
814         wb = inoff;
815         SETOFFwbSZINT );
816
817         /* wb now has the next higher word boundary */
818
819         ifwb >= n ){ /* in the same word */
820                 rest = n - inoff;
821                 vfdzerorest );
822                 return;
823                 }
824
825         /* otherwise, extend inoff to be word aligned */
826
827         rest = wb - inoff;
828         vfdzerorest );
829
830         /* now, skip full words until near to n */
831
832         rest = (n-inoff)/SZINT;
833         zecoderest );
834
835         /* now, the remainder of the last word */
836
837         rest = n-inoff;
838         vfdzerorest );
839         ifinoff != n ) cerror"inoff error");
840
841         }
842
ragge
1.2
843 /*
844  * make inoff have the offset the next alignment of n
845  */
846 void
847 vfdalign(int n)
848 {
ragge
1.1
849         OFFSZ m;
850
851         m = inoff;
852         SETOFFmn );
853         inforcem );
ragge
1.2
854 }
ragge
1.1
855
856
857 int idebug = 0;
858
859 int ibseen = 0;  /* the number of } constructions which have been filled */
860
861 int ifull = 0/* 1 if all initializers have been seen */
862
863 int iclass;  /* storage class of thing being initialized */
864
865 int ilocctr = 0;  /* location counter for current initialization */
866
ragge
1.2
867 /*
868  * beginning of initilization; set location ctr and set type
869  */
870 void
ragge
1.18
871 beginit(int curidint class)
ragge
1.2
872 {
873         struct symtab *p;
ragge
1.1
874
875 # ifndef BUG1
876         ifidebug >= 3 ) printf"beginit(), curid = %d\n"curid );
877 # endif
878
879         p = &stab[curid];
880
881         iclass = p->sclass;
ragge
1.18
882         ifclass == EXTERN || class == FORTRAN )
883                 iclass = EXTERN;
ragge
1.1
884         switchiclass ){
885
886         case UNAME:
887         case EXTERN:
888                 return;
889         case AUTO:
890         case REGISTER:
891                 break;
892         case EXTDEF:
893         case STATIC:
894                 ilocctr = ISARY(p->stype)?ADATA:DATA;
895                 ifnerrors == 0 ){
896                         (voidlocctrilocctr );
897                         defaligntalignp->stypep->sizoff ) );
898                         defnamp );
899                 }
ragge
1.2
900         }
ragge
1.1
901
902         inoff = 0;
903         ibseen = 0;
904         ifull = 0;
905
906         pstk = 0;
907
908         instkcuridp->stypep->dimoffp->sizoffinoff );
909
ragge
1.2
910 }
ragge
1.1
911
ragge
1.2
912 /*
913  * make a new entry on the parameter stack to initialize id
914  */
915 void
916 instk(int idTWORD tint dint sOFFSZ off)
917 {
918         struct symtab *p;
ragge
1.1
919
ragge
1.2
920         for (;;) {
ragge
1.1
921 # ifndef BUG1
ragge
1.2
922                 if (idebug)
ragge
1.11
923                         printf("instk((%d, %o,%d,%d, %lld)\n",
924                             idtds, (long long)off);
ragge
1.1
925 # endif
926
927                 /* save information on the stack */
928
ragge
1.19
929                 if (!pstk)
930                         pstk = instack;
931                 else
932                         ++pstk;
ragge
1.1
933
934                 pstk->in_fl = 0;        /* { flag */
ragge
1.20
935                 pstk->in_id = id;
936                 pstk->in_t = t;
937                 pstk->in_d = d;
938                 pstk->in_s = s;
ragge
1.1
939                 pstk->in_n = 0;  /* number seen */
ragge
1.20
940                 pstk->in_x = (t == STRTY || t == UNIONTY) ? dimtab[s+1] : 0 ;
ragge
1.19
941                 pstk->in_off = off;/* offset at the beginning of this element */
942
ragge
1.1
943                 /* if t is an array, DECREF(t) can't be a field */
ragge
1.19
944                 /* in_sz has size of array elements, and -size for fields */
945                 if (ISARY(t)) {
946                         pstk->in_sz = tsize(DECREF(t), d+1s);
947                 } else if (stab[id].sclass & FIELD){
948                         pstk->in_sz = - (stab[id].sclass & FLDSIZ);
949                 } else {
ragge
1.1
950                         pstk->in_sz = 0;
ragge
1.19
951                 }
ragge
1.1
952
ragge
1.19
953                 if ((iclass==AUTO || iclass == REGISTER) &&
954                     (ISARY(t) || t==STRTY))
955                         uerror("no automatic aggregate initialization");
ragge
1.1
956
957                 /* now, if this is not a scalar, put on another element */
958
ragge
1.19
959                 if (ISARY(t)) {
ragge
1.1
960                         t = DECREF(t);
961                         ++d;
962                         continue;
ragge
1.20
963                 } else if (t == STRTY || t == UNIONTY) {
ragge
1.19
964                         if (dimtab[pstk->in_s] == 0) {
ragge
1.20
965                                 uerror("can't initialize undefined %s",
966                                     t == STRTY ? "structure" : "union");
ragge
1.1
967                                 iclass = -1;
968                                 return;
ragge
1.19
969                         }
ragge
1.1
970                         id = dimtab[pstk->in_x];
971                         p = &stab[id];
ragge
1.20
972                         if (((p->sclass != MOS && t == STRTY) ||
973                             (p->sclass != MOU && t == UNIONTY)) &&
974                             !(p->sclass&FIELD))
975                                 cerror("insane %s member list",
976                                     t == STRTY ? "structure" : "union");
ragge
1.1
977                         t = p->stype;
978                         d = p->dimoff;
979                         s = p->sizoff;
980                         off += p->offset;
981                         continue;
ragge
1.19
982                 } else
983                         return;
ragge
1.1
984         }
ragge
1.19
985 }
ragge
1.1
986
987 NODE *
988 getstr(){ /* decide if the string is external or an initializer, and get the contents accordingly */
989
ragge
1.2
990         int ltemp;
991         NODE *p;
ragge
1.1
992
993         if( (iclass==EXTDEF||iclass==STATIC) && (pstk->in_t == CHAR || pstk->in_t == UCHAR) &&
994                         pstk!=instack && ISARYpstk[-1].in_t ) ){
995                 /* treat "abc" as { 'a', 'b', 'c', 0 } */
996                 strflg = 1;
997                 ilbrace();  /* simulate { */
998                 inforcepstk->in_off );
999                 /* if the array is inflexible (not top level), pass in the size and
1000                         be prepared to throw away unwanted initializers */
1001                 lxstr((pstk-1)!=instack?dimtab[(pstk-1)->in_d]:0);  /* get the contents */
1002                 irbrace();  /* simulate } */
1003                 returnNIL );
1004                 }
1005         else { /* make a label, and get the contents and stash them away */
1006                 ificlass != SNULL ){ /* initializing */
1007                         /* fill out previous word, to permit pointer */
1008                         vfdalignALPOINT );
1009                         }
1010                 temp = locctrblevel==0?ISTRNG:STRNG ); /* set up location counter */
1011                 deflabl = getlab() );
1012