![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ddecl.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 ddecl.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 deal with the declaration of names. ! 3: * The declaration stuff is done here; the parsing is done elsewhere. ! 4: */ ! 5: #ifdef vax ! 6: #include "INC$LIB:cc0.h" ! 7: #else ! 8: #include "cc0.h" ! 9: #endif ! 10: ! 11: /* ! 12: * This array maps function and parameter types ! 13: * into their defined interface types. ! 14: * fixtype() below knows about this table; ! 15: * if it changes, fixtype() might change too. ! 16: */ ! 17: static char xtype[] = { ! 18: T_NONE, /* T_NONE, */ ! 19: T_INT, T_UINT, /* T_CHAR, T_UCHAR, */ ! 20: T_INT, T_UINT, /* T_SHORT, T_USHORT, */ ! 21: T_INT, T_UINT, /* T_INT, T_UINT, */ ! 22: T_PTR, /* T_PTR, */ ! 23: T_LONG, T_ULONG, /* T_LONG, T_ULONG, */ ! 24: T_DOUBLE, T_DOUBLE, /* T_FLOAT, T_DOUBLE, */ ! 25: T_VOID, /* T_VOID, */ ! 26: T_STRUCT, T_FSTRUCT, /* T_STRUCT, T_FSTRUCT, */ ! 27: T_UNION, T_FUNION, /* T_UNION, T_FUNION, */ ! 28: T_INT, T_INT /* T_ENUM, T_FENUM */ ! 29: }; ! 30: ! 31: /* ! 32: * Declare a variable 'sp' with class 'c', type 't' and structure info 'ip'. ! 33: * Many checks are made here for redeclarations and funny things. ! 34: * For objects of class 'C_MOE', 'x1' is the enumeration value. ! 35: * For objects of class 'C_MOS' and 'C_MOU', ! 36: * 'x1' is the field width in bits and 'x2' is the long offset in bits. ! 37: * 'ronlyf' passes both 'readonly' and 'alien' modifiers. ! 38: */ ! 39: SYM * ! 40: declare(sp, c, t, ndp, ip, ronlyf, x1, x2) ! 41: register SYM *sp; ! 42: DIM *ndp; ! 43: INFO *ip; ! 44: unsigned long x2; ! 45: { ! 46: register DIM *dp, *xdp; ! 47: int af, ff, rf; ! 48: int oc, ot; ! 49: unsigned long value; ! 50: unsigned offs; ! 51: ! 52: /* ! 53: * Demote some function definitions to references. ! 54: * Adjust the return type of functions returning char, short or float. ! 55: * If the s_level is wrong, due to missing "extern", check ! 56: * for redeclaration. ! 57: */ ! 58: if (ndp!=NULL && ndp->d_type==D_FUNC) { ! 59: if (c==C_AUTO || c==C_PAUTO || c==C_SIN ! 60: || ((c==C_GDEF || c==C_SEX) && (s==SEMI || s==COMMA))) ! 61: c = C_GREF; ! 62: if (ndp->d_dp==NULL && ((ronlyf&S_ALIEN)==0 || t==T_FLOAT)) ! 63: t = fixtype(t, sp, "function"); ! 64: if (sp->s_level > LL_EXT) ! 65: sp = fixlevel(sp); ! 66: } ! 67: /* ! 68: * Make certain that the declarator is not ! 69: * forbidden by the semantics of C. The declaration ! 70: * reader allows anything that exhibits correct ! 71: * syntax through. ! 72: */ ! 73: if (c!=C_TYPE && t==T_VOID && !isfunction(ndp)) { ! 74: cerror("illegal use of \"void\" type"); ! 75: t = T_INT; ! 76: } ! 77: af = ff = rf = 0; ! 78: for (dp=ndp; dp!=NULL; dp=dp->d_dp) { ! 79: switch (dp->d_type) { ! 80: ! 81: case D_ARRAY: ! 82: if (ff != 0) ! 83: cerror("function cannot return an array"); ! 84: if ((xdp = dp->d_dp) != NULL /* [10][] */ ! 85: && xdp->d_type == D_ARRAY ! 86: && xdp->d_bound == 0) ! 87: cerror("bad flexible array declaration"); ! 88: af = 1; ! 89: ff = 0; ! 90: break; ! 91: ! 92: case D_FUNC: ! 93: if (ff != 0) ! 94: cerror("function cannot return a function"); ! 95: else if (af != 0) ! 96: cerror("cannot declare array of functions"); ! 97: af = 0; ! 98: ff = 1; ! 99: break; ! 100: ! 101: case D_PTR: ! 102: af = ff = 0; ! 103: } ! 104: } ! 105: if (ff!=0 && istruct(t)) ! 106: notbook(); ! 107: /* ! 108: * Check for redeclarations. ! 109: * If the old is "C_ARG" (a function parameter), ! 110: * then just about any combination is ok. ! 111: * The types are adjusted in consideration of the passing rules. ! 112: * Other redeclarations are typechecked. ! 113: */ ! 114: ot = sp->s_type; ! 115: oc = sp->s_class; ! 116: if (oc == C_ARG) { ! 117: dp = ndp; ! 118: if (dp == NULL || isfunction(dp)) { ! 119: t = fixtype(t, sp, "parameter"); ! 120: if (istruct(t)) ! 121: notbook(); ! 122: } else if (dp->d_type == D_ARRAY) { ! 123: dp->d_type = D_PTR; ! 124: dp->d_bound = 0; ! 125: } else if (dp->d_type != D_PTR) ! 126: cerror("functions cannot be parameters"); ! 127: } else if (c==C_PAUTO || c==C_PREG) { ! 128: cerror("identifier \"%s\" is not a parameter", sp->s_id); ! 129: c = C_AUTO; ! 130: } else if ((c==C_AUTO || c==C_REG) ! 131: && ndp!=NULL && ndp->d_type==D_ARRAY && ndp->d_bound==0) { ! 132: cerror("cannot declare flexible automatic array"); ! 133: } else if (ot!=T_NONE && ot!=t && !ismemb(oc)) { ! 134: ++rf; ! 135: } else if (oc == C_CXT) { ! 136: if (ndp == NULL || ndp->d_type != D_FUNC || ronlyf != 0) ! 137: ++rf; ! 138: } else if (oc==C_MOE && c==C_MOE) { ! 139: if (sp->s_value != x1) ! 140: ++rf; ! 141: } else if (ismemb(oc) && ismemb(c)) { ! 142: value = x2/NBPBYTE; ! 143: offs = x2%NBPBYTE; ! 144: if (doalign(t) && x1 != 0 && (value&1) != 0) { ! 145: --value; ! 146: offs += 8; ! 147: } ! 148: if (x1 != sp->s_width ! 149: || value != sp->s_value ! 150: || offs != sp->s_offset) ! 151: ++rf; ! 152: } else if (isdefn(oc) && isdefn(c)) { ! 153: if (oc!=C_GREF && c!=C_GREF) ! 154: ++rf; ! 155: else if (c == C_GREF) ! 156: c = oc; ! 157: } else if (oc != C_NONE) ! 158: ++rf; ! 159: if (oc != C_NONE && (sp->s_flag&ronlyf) != ronlyf) ! 160: ++rf; ! 161: sp->s_class = c; ! 162: sp->s_type = t; ! 163: dropdim(sp->s_dp); ! 164: sp->s_dp = ndp; ! 165: sp->s_dline = line; ! 166: sp->s_flag |= ronlyf; ! 167: if ((ronlyf&S_ALIEN) != 0) { ! 168: if ( ! isdefn(c) || ndp==NULL || ndp->d_type!=D_FUNC) ! 169: cerror("inappropriate \"alien\" modifier"); ! 170: sp->s_seg = SALIEN; ! 171: } ! 172: if (istag(oc) || ot==T_STRUCT || ot==T_UNION || ot==T_ENUM) { ! 173: dropinfo(sp->s_ip); ! 174: sp->s_ip = NULL; ! 175: } ! 176: if (istag(c) || t>T_DOUBLE) { ! 177: sp->s_ip = ip; ! 178: if (istag(c) || t==T_STRUCT || t==T_UNION || t==T_ENUM) ! 179: ++ip->i_refc; ! 180: } ! 181: if (istag(c)) ! 182: backplug(sp); ! 183: if (c == C_MOE) ! 184: sp->s_value = x1; ! 185: if (ismemb(c)) { ! 186: value = x2/NBPBYTE; ! 187: offs = x2%NBPBYTE; ! 188: if (doalign(t) && x1 != 0 && (value&1) != 0) { ! 189: --value; ! 190: offs += 8; ! 191: } ! 192: if (value > MAXMEMB) ! 193: cerror("member \"%s\" is not addressable", sp->s_id); ! 194: sp->s_width = x1; ! 195: sp->s_value = value; ! 196: sp->s_offset = offs; ! 197: } ! 198: if (rf != 0) ! 199: cerror("identifier \"%s\" is being redeclared", sp->s_id); ! 200: return(sp); ! 201: } ! 202: ! 203: /* ! 204: * Decrement reference count of a ! 205: * structure info. block. ! 206: * Free it if the block is now an ! 207: * unreferenced one. ! 208: */ ! 209: dropinfo(ip) ! 210: register INFO *ip; ! 211: { ! 212: if (ip!=NULL && --ip->i_refc==0) ! 213: free((char *) ip); ! 214: } ! 215: ! 216: /* ! 217: * Test if a storage class is a global ! 218: * storage class. ! 219: */ ! 220: isdefn(c) ! 221: register int c; ! 222: { ! 223: if (c==C_GDEF || c==C_GREF || c==C_SEX || c==C_SIN) ! 224: return (1); ! 225: return (0); ! 226: } ! 227: ! 228: /* ! 229: * Test if a type is one of the structure ! 230: * like types. ! 231: */ ! 232: istruct(t) ! 233: { ! 234: if (t>=T_STRUCT && t<=T_FUNION) ! 235: return (1); ! 236: return (0); ! 237: } ! 238: ! 239: /* ! 240: * Test for tag classes. ! 241: */ ! 242: istag(c) ! 243: register int c; ! 244: { ! 245: if (c==C_STAG || c==C_UTAG || c==C_ETAG) ! 246: return (1); ! 247: return (0); ! 248: } ! 249: ! 250: /* ! 251: * Test for one of the type definition classes. ! 252: */ ! 253: istype(c) ! 254: register int c; ! 255: { ! 256: if (c==C_STAG || c==C_UTAG || c==C_ETAG || c==C_TYPE) ! 257: return (1); ! 258: return (0); ! 259: } ! 260: ! 261: /* ! 262: * Test for member classes. ! 263: */ ! 264: ismemb(c) ! 265: register int c; ! 266: { ! 267: if (c==C_MOS || c==C_MOU) ! 268: return (1); ! 269: return (0); ! 270: } ! 271: ! 272: /* ! 273: * Examine a "DIM" chain to see if it describes a function. ! 274: */ ! 275: isfunction(dp) ! 276: register DIM *dp; ! 277: { ! 278: register int n; ! 279: ! 280: for (n = 0; dp!=NULL; dp = dp->d_dp) ! 281: n = (dp->d_type == D_FUNC); ! 282: return (n); ! 283: } ! 284: ! 285: /* ! 286: * Given a type t, return the adjusted type xtype[t]. ! 287: * Issue a "type adjusted" warning for dangerous cases. ! 288: * This does not determine "dangerous" rigorously, ! 289: * rather it uses facts about the values in xtype[] above; ! 290: * the only cases in which xtype[t]!=t are ! 291: * char->int, uchar->uint, short->int, ushort->uint, float->double. ! 292: */ ! 293: fixtype(t, sp, s) ! 294: register int t; ! 295: SYM *sp; ! 296: char *s; ! 297: { ! 298: register int xt; ! 299: char *ntype; ! 300: ! 301: xt = xtype[t]; ! 302: if (xt != t && mysizes[xt] != mysizes[t]) { ! 303: switch(xt) { ! 304: case T_INT: ! 305: ntype = "int"; ! 306: break; ! 307: case T_UINT: ! 308: ntype = "unsigned int"; ! 309: break; ! 310: case T_DOUBLE: ! 311: ntype = "double"; ! 312: break; ! 313: } ! 314: if (isvariant(VWIDEN)) ! 315: cwarn("type of %s \"%s\" adjusted to %s", s, sp->s_id, ntype); ! 316: } ! 317: return(xt); ! 318: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.