Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20020510160127

Diff

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