![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to typ2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ocfront|
Return to typ2.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ocfront |
1.1 ! root 1: /*ident "@(#)ctrans:src/typ2.c 1.1.5.17" */ ! 2: /************************************************************************** ! 3: ! 4: C++ source for cfront, the C++ compiler front-end ! 5: written in the computer science research center of Bell Labs ! 6: ! 7: Copyright (c) 1984 AT&T, Inc. All rigths Reserved ! 8: THIS IS UNPUBLISHED PROPRIETARY SOURCE CODE OF AT&T, INC. ! 9: ! 10: typ2.c: ! 11: ! 12: ***************************************************************************/ ! 13: ! 14: #include "cfront.h" ! 15: #include "size.h" ! 16: ! 17: extern int chars_in_largest; ! 18: int largest_int; ! 19: ! 20: void typ_init() ! 21: { ! 22: chars_in_largest = strlen(LARGEST_INT); ! 23: largest_int = int(str_to_long(LARGEST_INT)); ! 24: ! 25: defa_type = new basetype(INT,0); // note defa_type!=int_type ! 26: int_type = new basetype(INT,0); // but they both represent `int' ! 27: ! 28: PERM(int_type); ! 29: PERM(defa_type); ! 30: ! 31: moe_type = new basetype(INT,0); ! 32: PERM(moe_type); ! 33: moe_type->b_const = 1; ! 34: moe_type->check(0); ! 35: ! 36: uint_type = new basetype(INT,0); ! 37: PERM(uint_type); ! 38: uint_type->type_adj(UNSIGNED); ! 39: uint_type->check(0); ! 40: ! 41: long_type = new basetype(LONG,0); ! 42: PERM(long_type); ! 43: long_type->check(0); ! 44: ! 45: ulong_type = new basetype(LONG,0); ! 46: PERM(ulong_type); ! 47: ulong_type->type_adj(UNSIGNED); ! 48: ulong_type->check(0); ! 49: ! 50: short_type = new basetype(SHORT,0); ! 51: PERM(short_type); ! 52: short_type->check(0); ! 53: ! 54: ushort_type = new basetype(SHORT,0); ! 55: PERM(ushort_type); ! 56: ushort_type->type_adj(UNSIGNED); ! 57: ushort_type->check(0); ! 58: ! 59: float_type = new basetype(FLOAT,0); ! 60: PERM(float_type); ! 61: ! 62: double_type = new basetype(DOUBLE,0); ! 63: PERM(double_type); ! 64: ! 65: ldouble_type = new basetype(LDOUBLE,0); ! 66: PERM(ldouble_type); ! 67: ! 68: zero_type = new basetype(ZTYPE,0); ! 69: PERM(zero_type); ! 70: zero->tp = zero_type; ! 71: ! 72: void_type = new basetype(VOID,0); ! 73: PERM(void_type); ! 74: ! 75: char_type = new basetype(CHAR,0); ! 76: PERM(char_type); ! 77: ! 78: uchar_type = new basetype(CHAR,0); ! 79: PERM(uchar_type); ! 80: uchar_type->type_adj(UNSIGNED); ! 81: uchar_type->check(0); ! 82: ! 83: Pchar_type = char_type->addrof(); ! 84: PERM(Pchar_type); ! 85: ! 86: Pint_type = int_type->addrof(); ! 87: PERM(Pint_type); ! 88: ! 89: Pvoid_type = void_type->addrof(); ! 90: PERM(Pvoid_type); ! 91: ! 92: Pfctvec_type = new fct(int_type,0,0); ! 93: Pfctvec_type = Pfctvec_type->addrof(); ! 94: Pfctvec_type = Pfctvec_type->addrof(); ! 95: PERM(Pfctvec_type); ! 96: ! 97: gtbl = new table(GTBLSIZE,0,0); ! 98: gtbl->t_name = new name("global"); ! 99: ptbl = new table(CTBLSIZE,0,0); ! 100: ptbl->t_name = new name("ptbl"); ! 101: } ! 102: ! 103: bit enum_promote; ! 104: ! 105: Pbase basetype::arit_conv(Pbase t) ! 106: /* ! 107: perform the "usual arithmetic conversions" C ref Manual 6.6 ! 108: on "this" op "t" ! 109: "this" and "t" are integral or floating ! 110: "t" may be 0 ! 111: */ ! 112: { ! 113: while (base == TYPE) this = Pbase(Pbase(this)->b_name->tp); ! 114: // error('d', "arit_conv: this: %k %d %t %d", base, base, this, this ); ! 115: ! 116: bit l; ! 117: bit u; ! 118: bit f; ! 119: bit l1 = (base == LONG); ! 120: bit u1 = b_unsigned; ! 121: bit f1 = (base==FLOAT || base==DOUBLE || base==LDOUBLE); ! 122: if (t) { ! 123: while (t->base == TYPE) t = Pbase(Pbase(t)->b_name->tp); ! 124: // error('d', "arit_conv: t: %k %d %t %d", t->base, t->base, t, t ); ! 125: ! 126: bit l2 = (t->base == LONG); ! 127: bit u2 = t->b_unsigned; ! 128: bit f2 = (t->base==FLOAT || t->base==DOUBLE || base==LDOUBLE); ! 129: l = l1 || l2; ! 130: u = u1 || u2; ! 131: f = f1 || f2; ! 132: } ! 133: else { ! 134: l = l1; ! 135: u = u1; ! 136: f = f1; ! 137: } ! 138: ! 139: if (f) { ! 140: if (base==LDOUBLE || (t && t->base==LDOUBLE)) return ldouble_type; ! 141: if (base==DOUBLE || (t && t->base==DOUBLE)) return double_type; ! 142: return float_type; ! 143: } ! 144: if (l & u) return ulong_type; ! 145: if (l & !u) return long_type; ! 146: if (u) { ! 147: if (base==INT || (t && t->base==INT)) return uint_type; ! 148: if (SZ_SHORT==SZ_INT) // ANSIism ! 149: if (base==SHORT || (t && t->base==SHORT)) return uint_type; ! 150: return int_type; ! 151: } ! 152: ! 153: if (t && t->base == EOBJ && base == EOBJ) enum_promote = 1; ! 154: return int_type; ! 155: } ! 156: ! 157: bit vec_const = 0; ! 158: bit fct_const = 0; ! 159: ! 160: bit type::tconst() ! 161: /* ! 162: is this type a constant ! 163: */ ! 164: { ! 165: Ptype t = this; ! 166: vec_const = 0; ! 167: fct_const = 0; ! 168: //error('d',"tconst %t",t); ! 169: xxx: ! 170: switch (t->base) { ! 171: case TYPE: ! 172: if (Pbase(t)->b_const) return 1; ! 173: t = Pbase(t)->b_name->tp; ! 174: goto xxx; ! 175: case VEC: ! 176: vec_const = 1; ! 177: return 1; ! 178: case PTR: ! 179: case RPTR: ! 180: return Pptr(t)->rdo; ! 181: case FCT: ! 182: case OVERLOAD: ! 183: fct_const = 1; ! 184: return 1; ! 185: default: ! 186: return Pbase(t)->b_const; ! 187: } ! 188: } ! 189: ! 190: TOK type::set_const(bit mode) ! 191: /* ! 192: make someting a constant or variable, return old status ! 193: */ ! 194: { ! 195: Ptype t = this; ! 196: int m; ! 197: xxx: ! 198: switch (t->base) { ! 199: case TYPE: ! 200: m = Pbase(t)->b_const; ! 201: Pbase(t)->b_const = mode; ! 202: t = Pbase(t)->b_name->tp; ! 203: goto xxx; ! 204: case ANY: ! 205: case RPTR: ! 206: case VEC: ! 207: return t->base; // constant by definition ! 208: case PTR: ! 209: m = Pptr(t)->rdo; ! 210: Pptr(t)->rdo = mode; ! 211: return m; ! 212: default: ! 213: m = Pbase(t)->b_const; ! 214: Pbase(t)->b_const = mode; ! 215: return m; ! 216: } ! 217: } ! 218: ! 219: Pptr type::is_ref() ! 220: { ! 221: Ptype t = this; ! 222: xxx: ! 223: switch (t->base) { ! 224: case TYPE: t = Pbase(t)->b_name->tp; goto xxx; ! 225: case RPTR: return Pptr(t); ! 226: default: return 0; ! 227: } ! 228: } ! 229: ! 230: Pclass Mptr; ! 231: ! 232: Pptr type::is_ptr() ! 233: { ! 234: Ptype t = this; ! 235: xxx: ! 236: switch (t->base) { ! 237: case TYPE: t = Pbase(t)->b_name->tp; goto xxx; ! 238: case PTR: ! 239: case VEC: Mptr = Pptr(t)->memof; ! 240: return Pptr(t); ! 241: default: return 0; ! 242: } ! 243: } ! 244: ! 245: Pptr type::is_ptr_or_ref() ! 246: { ! 247: Ptype t = this; ! 248: xxx: ! 249: switch (t->base) { ! 250: case TYPE: t = Pbase(t)->b_name->tp; goto xxx; ! 251: case PTR: ! 252: case RPTR: ! 253: case VEC: Mptr = Pptr(t)->memof; ! 254: return Pptr(t); ! 255: default: return 0; ! 256: } ! 257: } ! 258: ! 259: int type::align() ! 260: { ! 261: Ptype t = this; ! 262: xx: ! 263: /*fprintf(stderr,"align %d %d\n",t,t->base);*/ ! 264: switch (t->base) { ! 265: case TYPE: t = Pbase(t)->b_name->tp; goto xx; ! 266: case COBJ: t = Pbase(t)->b_name->tp; goto xx; ! 267: case VEC: t = Pvec(t)->typ; goto xx; ! 268: case ANY: return 1; ! 269: case CHAR: return AL_CHAR; ! 270: case SHORT: return AL_SHORT; ! 271: case INT: return AL_INT; ! 272: case LONG: return AL_LONG; ! 273: case FLOAT: return AL_FLOAT; ! 274: case DOUBLE: return AL_DOUBLE; ! 275: case LDOUBLE: return AL_LDOUBLE; ! 276: case PTR: ! 277: case RPTR: return AL_WPTR; ! 278: case CLASS: return Pclass(t)->obj_align; ! 279: case ENUM: ! 280: case EOBJ: return AL_INT; ! 281: case VOID: error("illegal use of void"); return AL_INT; ! 282: default: error('i',"(%d,%k)->type::align",t,t->base); ! 283: } ! 284: } ! 285: ! 286: bit fake_sizeof; ! 287: ! 288: int type::tsizeof(int ptmc) ! 289: /* ! 290: the sizeof type operator ! 291: return the size in bytes of the types representation ! 292: */ ! 293: { ! 294: Ptype t = this; ! 295: zx: ! 296: //error('d',"zx %t %d",t,t->base); ! 297: if (t == 0) error('i',"typ.tsizeof(t==0)"); ! 298: switch (t->base) { ! 299: case TYPE: ! 300: t = Pbase(t)->b_name->tp; ! 301: goto zx; ! 302: case COBJ: ! 303: t = Pbase(t)->b_name->tp; ! 304: if (t == 0) return 0; // ``fake'' generated classes: _Sdd ! 305: goto zx; ! 306: ! 307: case ANY: return 1; ! 308: case VOID: return 0; ! 309: case ZTYPE: return SZ_WPTR; /* assume pointer */ ! 310: case CHAR: return SZ_CHAR; ! 311: case SHORT: return SZ_SHORT; ! 312: case INT: return SZ_INT; ! 313: case LONG: return SZ_LONG; ! 314: case FLOAT: return SZ_FLOAT; ! 315: case DOUBLE: return SZ_DOUBLE; ! 316: case LDOUBLE: return SZ_LDOUBLE; ! 317: ! 318: case VEC: ! 319: { Pvec v = Pvec(t); ! 320: if (v->size == 0) { ! 321: if (fake_sizeof == 0) error('w',"sizeof array with undeclared dimension"); ! 322: return SZ_WPTR; // vector argument has sizeof ptr ! 323: } ! 324: return v->size * v->typ->tsizeof(); ! 325: } ! 326: case RPTR: ! 327: case PTR: ! 328: { ! 329: int k = (Pptr(t)->memof && !ptmc)?sizeof(short)+sizeof(short):0; ! 330: t = Pptr(t)->typ; ! 331: xxx: ! 332: switch (t->base) { ! 333: default: return SZ_WPTR; ! 334: case CHAR: return SZ_BPTR; ! 335: case FCT: return SZ_WPTR+k; ! 336: case TYPE: t = Pbase(t)->b_name->tp; goto xxx; ! 337: } ! 338: } ! 339: case FIELD: ! 340: error("sizeof(field)"); ! 341: return Pbase(t)->b_bits/BI_IN_BYTE+1; ! 342: case FCT: ! 343: error("sizeof(function)"); ! 344: return 0; ! 345: ! 346: case CLASS: ! 347: { ! 348: Pclass cl = Pclass(t); ! 349: if ((cl->defined&(DEFINED|SIMPLIFIED)) == 0) { ! 350: error("%tU, size not known",cl); ! 351: return SZ_INT; ! 352: } ! 353: if (cl->c_body == 1) // detect first allocation or sizeof ! 354: cl->dcl_print(0); ! 355: return cl->obj_size; ! 356: } ! 357: ! 358: case EOBJ: ! 359: case ENUM: return SZ_INT; ! 360: ! 361: default: return 0; // deref can be called for any type ! 362: //error('i',"sizeof(%d)",t->base); ! 363: } ! 364: } ! 365: ! 366: bit type::vec_type() ! 367: { ! 368: Ptype t = this; ! 369: xx: ! 370: switch (t->base) { ! 371: case ANY: ! 372: case VEC: ! 373: case PTR: ! 374: case RPTR: return 1; ! 375: case TYPE: t = Pbase(t)->b_name->tp; goto xx; ! 376: default: return 0; ! 377: } ! 378: } ! 379: ! 380: int ref_initializer; ! 381: ! 382: Ptype type::deref() ! 383: /* index==1: *p ! 384: index==0: p[expr] ! 385: */ ! 386: { ! 387: //error('d',"%t -> deref() refd %d",this,ref_initializer); ! 388: Ptype t = this; ! 389: xx: ! 390: switch (t->base) { ! 391: case TYPE: ! 392: t = Pbase(t)->b_name->tp; ! 393: goto xx; ! 394: case PTR: ! 395: case RPTR: ! 396: case VEC: ! 397: { if (t == Pvoid_type) error("void* dereferenced"); ! 398: Ptype tt = t = Pvec(t)->typ; ! 399: if (ref_initializer == 0) { ! 400: while (tt->base == TYPE) tt = Pbase(tt)->b_name->tp; ! 401: if (tt->base == COBJ) { ! 402: tt = Pbase(tt)->b_name->tp; ! 403: if (tt && Pclass(tt)->defined&(DEFINED|SIMPLIFIED)) ! 404: (void) t->tsizeof(); ! 405: } ! 406: } ! 407: // no break ! 408: } ! 409: case ANY: ! 410: return t; ! 411: default: ! 412: error("nonP dereferenced"); ! 413: return any_type; ! 414: } ! 415: } ! 416: ! 417: Pfct type::memptr() ! 418: // is ``this'' a pointer to member function ! 419: { ! 420: Ptype t = this; ! 421: while (t->base == TYPE) t = Pbase(t)->b_name->tp; ! 422: if (t->base != PTR || Pptr(t)->memof==0) return 0; ! 423: ! 424: t = Pptr(t)->typ; ! 425: while (t->base == TYPE) t = Pbase(t)->b_name->tp; ! 426: return (t->base == FCT) ? Pfct(t) : 0; ! 427: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.