Quick Search:

View

Revision:
Expand:  
Changeset: MAIN:ragge:20030531184306

Diff

Diff from 1.32 to:

Annotations

Annotate by Age | Author | Mixed | None
/fisheye/browse/pcc/pcc/cc/ccom/pftn.c

Annotated File View

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