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