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