![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to gdecl.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n0|
Return to gdecl.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / cc / c / n0 |
1.1 root 1: /*
2: * The routines in this file read in declarators
3: * and build up the DIM and INFO structures.
4: */
5: #ifdef vax
6: #include "INC$LIB:cc0.h"
7: #else
8: #include "cc0.h"
9: #endif
10:
11: /*
12: * Read declarator.
13: * The arg "tdp" is the dimensions from a typedef.
14: * The storage class is passed since
15: * it determines the lexic level of the lookup.
16: */
17: gdecl(asp, adp, tdp, c, ls)
18: SYM **asp;
19: DIM **adp, *tdp;
20: int c, ls;
21: {
22: register SYM *sp;
23: DIM *dp;
24: int ll; /* Lexical level */
25: int aok; /* Args are OK flag */
26: sizeof_t bound; /* Array bound */
27:
28: if (llex == 0 && (c==C_GDEF || c==C_GREF || c==C_SEX))
29: aok = 1;
30: else
31: aok = 0;
32: while (s == CONST || s == VOLATILE) {
33: /* Ignore these for now. They should be treated as MUL */
34: /* They can appear before the type-name as well */
35: lex();
36: }
37: if (s == MUL) {
38: lex();
39: if (gdecl(asp, adp, NULL, c, ls) == 0)
40: return (0);
41: *adp = tackdim(*adp, D_PTR, (sizeof_t)0);
42: while (tdp != NULL) {
43: *adp = tackdim(*adp, tdp->d_type, tdp->d_bound);
44: tdp = tdp->d_dp;
45: }
46: return (1);
47: }
48: if (s == LPAREN) {
49: lex();
50: if (gdecl(asp, adp, NULL, c, ls) == 0)
51: return (0);
52: mustbe(RPAREN);
53: sp = *asp;
54: dp = *adp;
55: aok = 0;
56: } else if (s == ID) {
57: if (c==C_ARG || c==C_PAUTO || c==C_PREG)
58: ll = LL_ARG;
59: else if (c==C_GDEF || c==C_GREF)
60: ll = LL_EXT;
61: else
62: ll = llex;
63: sp = deflookup(ls, ll);
64: dp = NULL;
65: lex();
66: } else {
67: cerror("declarator syntax");
68: while (s!=EOF && s!=COMMA && s!=SEMI)
69: skip();
70: return (0);
71: }
72: again:
73: if (s == LPAREN) {
74: lex();
75: gproto(&aok, &dp);
76: mustbe(RPAREN);
77: goto again;
78: }
79: if (s == LBRACK) {
80: lex();
81: bound = 0;
82: if (s != RBRACK)
83: bound = getbound();
84: mustbe(RBRACK);
85: dp = tackdim(dp, D_ARRAY, bound);
86: goto again;
87: }
88: while (tdp != NULL) {
89: dp = tackdim(dp, tdp->d_type, tdp->d_bound);
90: tdp = tdp->d_dp;
91: }
92: *asp = sp;
93: *adp = dp;
94: return (1);
95: }
96:
97: /*
98: * This routine generates tags for tagless struct/union/enum
99: * declarations. This makes life easier for csd.
100: */
101: SYM *newtag(ll) int ll;
102: {
103: sprintf(id, ".%d", newlab());
104: setid(id);
105: return deflookup(SL_TAG, ll);
106: }
107:
108: /*
109: * This routine processes structure and union declarations.
110: * The type and INFO data gets passed back indirectly through the
111: * "call by reference" parameters.
112: * The storage class is passed so that local extern structure
113: * definitions get entered at the correct (global) lexical level.
114: */
115: gstruct(sc, at, aip)
116: int sc, *at;
117: INFO **aip;
118: {
119: int c, dt, i, j, mc, t, tc, w, rf, ls, ll;
120: SYM *tsp, *msp, *mp;
121: DIM *dp, **mdp;
122: INFO *ip, *nip;
123: unsigned long ofs, max, bitsize;
124:
125: ll = (sc == C_GREF) ? LL_EXT : llex;
126: ls = lsym;
127: if (notvariant(VSINU))
128: lsym += 1;
129: dt = T_STRUCT;
130: tc = C_STAG;
131: mc = C_MOS;
132: if (s == UNION) {
133: dt = T_UNION;
134: tc = C_UTAG;
135: mc = C_MOU;
136: }
137: tsp = NULL;
138: lex();
139: if (s == ID) {
140: tsp = reflookup(SL_TAG);
141: if (tsp == NULL)
142: tsp = deflookup(SL_TAG, ll);
143: lex();
144: if (s != LBRACE) {
145: c = tsp->s_class;
146: if (c == C_NONE) {
147: *at = dt+1; /* Forward */
148: *aip = tsp;
149: return;
150: }
151: if (c==C_STAG || c==C_UTAG) {
152: if (c != tc)
153: tagmismatch(tsp);
154: *at = dt;
155: *aip = tsp->s_ip;
156: ++tsp->s_ip->i_refc;
157: return;
158: }
159: cerror("\"%s\" is not a tag", tsp->s_id);
160: *at = T_INT;
161: *aip = NULL;
162: return;
163: }
164: tsp = deflookup(SL_TAG, ll);
165: } else
166: tsp = newtag(ll);
167: mustbe(LBRACE);
168: nip = (INFO *) new(sizeof(INFO));
169: nip->i_refc = 1;
170: nip->i_nsp = 0;
171: ofs = 0;
172: max = 0;
173: while (s!=EOF && s!=RBRACE) {
174: gcandt(&c, &t, &dp, &ip, &rf);
175: if (t == T_NONE) {
176: if (s == ID)
177: cerror("\"%s\" is not a typedef name", id);
178: else
179: cerror("missing type in structure body");
180: while (s!=EOF && s!=RBRACE && s!=SEMI)
181: lex();
182: if (s == SEMI)
183: lex();
184: continue;
185: }
186: if (rf != 0 || c != C_NONE)
187: cerror("class not allowed in structure body");
188: if (isvariant(VSINU)) {
189: /*
190: * Handle the "struct" in "union" rule.
191: * A series of unnamed structures within a union are united
192: * into a set of named/typed offsets within the union.
193: * Basically, we add the unique members of the
194: * new structure to the members of the current union.
195: * Not strictly part of C, and only works if all MOS in
196: * same level of symbol table.
197: */
198: if (dt==T_UNION && t==T_STRUCT && s==SEMI) {
199: notbook();
200: lex();
201: bitsize = (unsigned long)ip->i_size*NBPBYTE;
202: if (bitsize > max)
203: max = bitsize;
204: for (i=0; i<ip->i_nsp; ++i) {
205: mp = ip->i_sp[i];
206: j = nip->i_nsp;
207: while (--j >= 0)
208: if (nip->i_sp[j] == mp)
209: break;
210: if (j < 0) {
211: nip = newinfo(nip, mp);
212: if (tsp != NULL)
213: mp->s_flag |= S_TAG;
214: }
215: }
216: continue;
217: }
218: }
219: for (;;) {
220: if (s == COLON) {
221: lex();
222: newtree(sizeof(TREE));
223: ++ininit;
224: w = iconexpr();
225: --ininit;
226: if (w < 0)
227: cerror("bad filler field width");
228: ofs = fieldalign(t, NULL, ip, w, ofs) + w;
229: } else if (gdecl(&msp, &mdp, dp, mc, ls)) {
230: if (sc == C_GREF)
231: msp->s_level = LL_EXT;
232: w = 0;
233: if (s == COLON) {
234: lex();
235: newtree(sizeof(TREE));
236: ++ininit;
237: w = iconexpr();
238: --ininit;
239: if (w <= 0)
240: cerror("bad field width");
241: }
242: ofs = fieldalign(t, mdp, ip, w, ofs);
243: msp = declare(msp, mc, t, mdp, ip, rf, w, ofs);
244: nip = newinfo(nip, msp);
245: if (tsp != NULL)
246: msp->s_flag |= S_TAG;
247: if (w == 0)
248: ofs += (unsigned long)ssize(msp)*NBPBYTE;
249: else
250: ofs += w;
251: }
252: if (dt == T_UNION) {
253: if (ofs > max)
254: max = ofs;
255: ofs = 0;
256: }
257: if (s != COMMA)
258: break;
259: lex();
260: }
261: xdropinfo(t, ip);
262: mustbe(SEMI);
263: }
264: mustbe(RBRACE);
265: if (dt == T_STRUCT)
266: max = ofs;
267: max = (max + NBPSTRG - 1) / NBPSTRG;
268: max = max * NBPSTRG / NBPBYTE;
269: if (max > MAXESIZE) {
270: cerror("size of %s too large",
271: (dt==T_STRUCT) ? "struct" : "union");
272: max = 0;
273: }
274: nip->i_size = max;
275: if (tsp != NULL)
276: tsp = declare(tsp, tc, 0, NULL, nip, 0);
277: *at = dt;
278: *aip = nip;
279: }
280:
281: /*
282: * Read an enumeration.
283: */
284: genum(sc, at, aip)
285: int sc, *at;
286: INFO **aip;
287: {
288: register SYM *sp, *tsp;
289: INFO *ip;
290: int c, emv, emvmax, ll;
291:
292: ll = (sc == C_GREF) ? LL_EXT : llex;
293: tsp = NULL;
294: lex();
295: if (s == ID) {
296: tsp = reflookup(SL_TAG);
297: lex();
298: if (s != LBRACE) {
299: if (tsp == NULL)
300: tsp = deflookup(SL_TAG, ll);
301: c = tsp->s_class;
302: if (c == C_NONE) {
303: *at = T_FENUM;
304: *aip = tsp;
305: return;
306: }
307: if (c == C_ETAG) {
308: *at = T_ENUM;
309: *aip = tsp->s_ip;
310: ++tsp->s_ip->i_refc;
311: return;
312: }
313: cerror("\"%s\" is not an \"enum\" tag",
314: tsp->s_id);
315: *at = T_INT;
316: *aip = NULL;
317: return;
318: }
319: tsp = deflookup(SL_TAG, ll);
320: } else
321: tsp = newtag(ll);
322: mustbe(LBRACE);
323: ip = (INFO *) new(sizeof(INFO));
324: ip->i_refc = 1;
325: ip->i_nsp = 0;
326: emv = 0;
327: emvmax = 0;
328: for (;;) {
329: if (s==EOF || s==RBRACE) {
330: cerror("unexpected end of enumeration list");
331: break;
332: }
333: if (s != ID) {
334: cerror("error in enumeration list syntax");
335: skip();
336: continue;
337: }
338: sp = deflookup(SL_VAR, LL_EXT);
339: lex();
340: if (s == ASSIGN) {
341: lex();
342: newtree(sizeof(TREE));
343: ++ininit;
344: emv = iconexpr();
345: --ininit;
346: }
347: if (emv > emvmax)
348: emvmax = emv;
349: ip = newinfo(ip, sp);
350: sp = declare(sp, C_MOE, 0, NULL, NULL, 0, emv);
351: ++emv;
352: if (s == RBRACE)
353: break;
354: mustbe(COMMA);
355: }
356: if (s == RBRACE)
357: lex();
358: ip->i_type = emvmax>MAXUCE ? T_INT : T_UCHAR;
359: if (tsp != NULL)
360: tsp = declare(tsp, C_ETAG, 0, NULL, ip, 0);
361: *at = T_ENUM;
362: *aip = ip;
363: }
364:
365: /*
366: * Read a function prototype declaration.
367: * '*aokp' indicates whether the storage class of the parent declarator
368: * and the position of the parenthesized list is appropriate for the
369: * formal parameter list of an actual function definition.
370: * '*adp' is where the function prototype DIM should be stored.
371: */
372: gproto(aokp, adp) register int *aokp; register DIM **adp;
373: {
374: register SYM *ap;
375: if (*aokp==1) {
376: nargs = 0;
377: if (s != RPAREN)
378: for (;;) {
379: if (s != ID) {
380: cerror("argument list has incorrect syntax");
381: break;
382: }
383: if (nargs >= NARGS)
384: cfatal("too many arguments");
385: ap = deflookup(SL_VAR, LL_ARG);
386: ap = declare(ap, C_ARG, T_INT,
387: NULL, NULL, 0);
388: args[nargs++] = ap;
389: lex();
390: if (s != COMMA)
391: break;
392: lex();
393: }
394: *aokp = 0;
395: }
396: *adp = tackdim(*adp, D_FUNC, (sizeof_t)0);
397: }
398:
399: /*
400: * Tack a DIM structure onto the end
401: * of the dimension list associated with "dp".
402: */
403: DIM *
404: tackdim(dp, t, b)
405: DIM *dp;
406: int t;
407: sizeof_t b;
408: {
409: register DIM *dp1, *dp2;
410:
411: dp1 = (struct dim *) new(sizeof(struct dim));
412: dp1->d_dp = NULL;
413: dp1->d_type = t;
414: dp1->d_bound = b;
415: if ((dp2 = dp) == NULL)
416: return (dp1);
417: while (dp2->d_dp != NULL)
418: dp2 = dp2->d_dp;
419: dp2->d_dp = dp1;
420: return (dp);
421: }
422:
423: /*
424: * Release a DIM chain.
425: */
426: dropdim(dp)
427: register DIM *dp;
428: {
429: if (dp != NULL) {
430: dropdim(dp->d_dp);
431: free((char *) dp);
432: }
433: }
434:
435: /*
436: * Duplicate a DIM chain.
437: */
438: DIM *
439: dupldim(dp)
440: register DIM *dp;
441: {
442: register DIM *np;
443:
444: if (dp == NULL)
445: return (NULL);
446: np = (struct dim *) new(sizeof(struct dim));
447: np->d_dp = dupldim(dp->d_dp);
448: np->d_type = dp->d_type;
449: np->d_bound = dp->d_bound;
450: return (np);
451: }
452:
453: /*
454: * Append a symbol to a struct/union/enum information array.
455: * Grow the array if necessary and possible.
456: */
457: INFO *
458: newinfo(ip, sp)
459: register INFO *ip;
460: SYM *sp;
461: {
462: register INFO *tip;
463: register int i;
464:
465: i = ip->i_nsp;
466: if ((i % 16) == 0) {
467: tip = ip;
468: ip = (INFO *) new(sizeof(INFO) + (i+16) * sizeof(SYM *));
469: ip->i_refc = tip->i_refc;
470: ip->i_data = tip->i_data;
471: ip->i_nsp = i;
472: while (--i >= 0)
473: ip->i_sp[i] = tip->i_sp[i];
474: free((char *) tip);
475: i = ip->i_nsp;
476: }
477: ip->i_sp[i] = sp;
478: ip->i_nsp += 1;
479: return (ip);
480: }
481:
482: /*
483: * Read an array bound.
484: * An array bound is a constant expression.
485: * It may be inside a cast, so save and restore the tree allocate pointer.
486: * If signed, give an error if the bound is less than 0.
487: * Call the machine dependent size check routine for upper bound check.
488: */
489: sizeof_t getbound()
490: {
491: register TREE *tp;
492: extern TREE *expr();
493: register int t;
494: register long bound;
495: TREE *tmp;
496:
497: tmp = talloc();
498: tp = expr();
499: treset(tmp);
500: if (tp->t_op == ICON)
501: bound = tp->t_ival;
502: else if (tp->t_op == LCON)
503: bound = tp->t_lval;
504: else if (tp->t_op == ZCON)
505: bound = tp->t_zval;
506: else {
507: cerror("array bound must be a constant");
508: return (0);
509: }
510: t = tltype(tp);
511: if ((t==T_CHAR || t==T_SHORT || t==T_INT || t==T_LONG)
512: && bound < 0) {
513: cerror("array bound must be positive");
514: return (0);
515: }
516: return (szcheck(bound, 1, "array bound"));
517: }
518:
519: /*
520: * The SYM 'sp' has storage class C_STAG or C_UTAG.
521: * A new declaration has been encountered which is of the wrong class.
522: * Print a diagnostic giving the name of the tag and its previous class.
523: */
524: tagmismatch(sp)
525: register SYM *sp;
526: {
527: register char *p;
528:
529: p = (sp->s_class == C_UTAG) ? "union" : "structure";
530: cerror("\"%s\" is a %s tag", sp->s_id, p);
531: }
532:
533: /*
534: * Read a cast.
535: * Return a pointer to a CAST tree node,
536: * or NULL if not a legal cast.
537: */
538: TREE *
539: cast()
540: {
541: register TREE *tp;
542: DIM *dp;
543: INFO *ip;
544: DIM *cast1();
545: int rf;
546: int c, t;
547:
548: gcandt(&c, &t, &dp, &ip, &rf);
549: if (c==C_NONE && t==T_NONE && rf==0)
550: return (NULL);
551: if (rf != 0 || c != C_NONE)
552: cerror("storage class not allowed in cast");
553: if (t == T_NONE) {
554: cerror("type required in cast");
555: t = T_INT;
556: }
557: dp = cast1(dp);
558: if (t==T_VOID && dp!=NULL && !isfunction(dp)) {
559: cerror("illegal use of void type in cast");
560: t = T_INT;
561: }
562: mustbe(RPAREN);
563: tp = talloc();
564: tp->t_op = CAST;
565: tp->t_type = t;
566: tp->t_dp = dp;
567: tp->t_ip = ip;
568: return (tp);
569: }
570:
571: /* this is the cast version of gdecl() */
572: DIM *
573: cast1(tdp)
574: DIM *tdp;
575: {
576: register DIM *dp;
577: register sizeof_t b;
578: DIM *cast2();
579:
580: while (s == CONST || s == VOLATILE) {
581: lex();
582: }
583: if (s == MUL) {
584: lex();
585: dp = cast2(cast1(NULL), D_PTR, (sizeof_t)0);
586: } else {
587: dp = NULL;
588: if (s == LPAREN) {
589: lex();
590: if (s != RPAREN) {
591: dp = cast1(NULL);
592: mustbe(RPAREN);
593: } else {
594: lex();
595: dp = cast2(dp, D_FUNC, (sizeof_t)0);
596: }
597: }
598: again:
599: if (s == LPAREN) {
600: DIM *tdp;
601: lex();
602: tdp = dp;
603: cproto(&tdp);
604: dp = tdp;
605: mustbe(RPAREN);
606: goto again;
607: }
608: if (s == LBRACK) {
609: lex();
610: b = 0;
611: if (s != RBRACK)
612: b = getbound();
613: mustbe(RBRACK);
614: dp = cast2(dp, D_ARRAY, b);
615: goto again;
616: }
617: }
618: while (tdp != NULL) {
619: dp = cast2(dp, tdp->d_type, tdp->d_bound);
620: tdp = tdp->d_dp;
621: }
622: return (dp);
623: }
624:
625: /* this is the cast version of tackdim() */
626: DIM *
627: cast2(dp, t, b)
628: DIM *dp;
629: int t;
630: sizeof_t b;
631: {
632: register DIM *dp1, *dp2;
633:
634: dp1 = (struct dim *) talloc();
635: dp1->d_dp = NULL;
636: dp1->d_type = t;
637: dp1->d_bound = b;
638: if ((dp2 = dp) == NULL)
639: return (dp1);
640: while (dp2->d_dp != NULL)
641: dp2 = dp2->d_dp;
642: dp2->d_dp = dp1;
643: return (dp);
644: }
645:
646: cproto(adp) DIM **adp;
647: {
648: *adp = cast2(*adp, D_FUNC, (sizeof_t)0);
649: }
650:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.