Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20020326192151

Diff

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