![[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 / cfront2.00|
Return to typ2.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / cfront2.00 |
1.1 root 1: /*ident "@(#)ctrans:src/typ2.c 1.1.5.15" */
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); // must be last, see basetype::normalize()
93: Pfctvec_type = Pfctvec_type->addrof();
94: Pfctvec_type = Pfctvec_type->addrof();
95: PERM(Pfctvec_type);
96:
97: any_tbl = new table(TBLSIZE,0,0);
98: gtbl = new table(GTBLSIZE,0,0);
99: gtbl->t_name = new name("global");
100: }
101:
102: Pbase basetype::arit_conv(Pbase t)
103: /*
104: perform the "usual arithmetic conversions" C ref Manual 6.6
105: on "this" op "t"
106: "this" and "t" are integral or floating
107: "t" may be 0
108: */
109: {
110: while (base == TYPE) this = Pbase(Pbase(this)->b_name->tp);
111:
112: bit l;
113: bit u;
114: bit f;
115: bit l1 = (base == LONG);
116: bit u1 = b_unsigned;
117: bit f1 = (base==FLOAT || base==DOUBLE || base==LDOUBLE);
118: if (t) {
119: while (t->base == TYPE) t = Pbase(Pbase(t)->b_name->tp);
120: bit l2 = (t->base == LONG);
121: bit u2 = t->b_unsigned;
122: bit f2 = (t->base==FLOAT || t->base==DOUBLE || base==LDOUBLE);
123: l = l1 || l2;
124: u = u1 || u2;
125: f = f1 || f2;
126: }
127: else {
128: l = l1;
129: u = u1;
130: f = f1;
131: }
132:
133: if (f) {
134: if (base==LDOUBLE || (t && t->base==LDOUBLE)) return ldouble_type;
135: if (base==DOUBLE || (t && t->base==DOUBLE)) return double_type;
136: return float_type;
137: }
138: if (l & u) return ulong_type;
139: if (l & !u) return long_type;
140: if (u) {
141: if (base==INT || (t && t->base==INT)) return uint_type;
142: if (SZ_SHORT==SZ_INT) // ANSIism
143: if (base==SHORT || (t && t->base==SHORT)) return uint_type;
144: return int_type;
145: }
146: return int_type;
147: }
148:
149: bit vec_const = 0;
150: bit fct_const = 0;
151:
152: bit type::tconst()
153: /*
154: is this type a constant
155: */
156: {
157: Ptype t = this;
158: vec_const = 0;
159: fct_const = 0;
160: //error('d',"tconst %t",t);
161: xxx:
162: switch (t->base) {
163: case TYPE:
164: if (Pbase(t)->b_const) return 1;
165: t = Pbase(t)->b_name->tp;
166: goto xxx;
167: case VEC:
168: vec_const = 1;
169: return 1;
170: case PTR:
171: case RPTR:
172: return Pptr(t)->rdo;
173: case FCT:
174: case OVERLOAD:
175: fct_const = 1;
176: return 1;
177: default:
178: return Pbase(t)->b_const;
179: }
180: }
181:
182: TOK type::set_const(bit mode)
183: /*
184: make someting a constant or variable, return old status
185: */
186: {
187: Ptype t = this;
188: int m;
189: xxx:
190: switch (t->base) {
191: case TYPE:
192: m = Pbase(t)->b_const;
193: Pbase(t)->b_const = mode;
194: t = Pbase(t)->b_name->tp;
195: goto xxx;
196: case ANY:
197: case RPTR:
198: case VEC:
199: return t->base; // constant by definition
200: case PTR:
201: m = Pptr(t)->rdo;
202: Pptr(t)->rdo = mode;
203: return m;
204: default:
205: m = Pbase(t)->b_const;
206: Pbase(t)->b_const = mode;
207: return m;
208: }
209: }
210:
211: Pptr type::is_ref()
212: {
213: Ptype t = this;
214: xxx:
215: switch (t->base) {
216: case TYPE: t = Pbase(t)->b_name->tp; goto xxx;
217: case RPTR: return Pptr(t);
218: default: return 0;
219: }
220: }
221:
222: Pclass Mptr;
223:
224: Pptr type::is_ptr()
225: {
226: Ptype t = this;
227: xxx:
228: switch (t->base) {
229: case TYPE: t = Pbase(t)->b_name->tp; goto xxx;
230: case PTR:
231: case VEC: Mptr = Pptr(t)->memof;
232: return Pptr(t);
233: default: return 0;
234: }
235: }
236:
237: Pptr type::is_ptr_or_ref()
238: {
239: Ptype t = this;
240: xxx:
241: switch (t->base) {
242: case TYPE: t = Pbase(t)->b_name->tp; goto xxx;
243: case PTR:
244: case RPTR:
245: case VEC: Mptr = Pptr(t)->memof;
246: return Pptr(t);
247: default: return 0;
248: }
249: }
250:
251: int type::align()
252: {
253: Ptype t = this;
254: xx:
255: /*fprintf(stderr,"align %d %d\n",t,t->base);*/
256: switch (t->base) {
257: case TYPE: t = Pbase(t)->b_name->tp; goto xx;
258: case COBJ: t = Pbase(t)->b_name->tp; goto xx;
259: case VEC: t = Pvec(t)->typ; goto xx;
260: case ANY: return 1;
261: case CHAR: return AL_CHAR;
262: case SHORT: return AL_SHORT;
263: case INT: return AL_INT;
264: case LONG: return AL_LONG;
265: case FLOAT: return AL_FLOAT;
266: case DOUBLE: return AL_DOUBLE;
267: case LDOUBLE: return AL_LDOUBLE;
268: case PTR:
269: case RPTR: return AL_WPTR;
270: case CLASS: return Pclass(t)->obj_align;
271: case ENUM:
272: case EOBJ: return AL_INT;
273: case VOID: error("illegal use of void"); return AL_INT;
274: default: error('i',"(%d,%k)->type::align",t,t->base);
275: }
276: }
277:
278: bit fake_sizeof;
279:
280: int type::tsizeof()
281: /*
282: the sizeof type operator
283: return the size in bytes of the types representation
284: */
285: {
286: Ptype t = this;
287: zx:
288: //error('d',"zx %t %d",t,t->base);
289: if (t == 0) error('i',"typ.tsizeof(t==0)");
290: switch (t->base) {
291: case TYPE:
292: t = Pbase(t)->b_name->tp;
293: goto zx;
294: case COBJ:
295: t = Pbase(t)->b_name->tp;
296: if (t == 0) return 0; // ``fake'' generated classes: _Sdd
297: goto zx;
298:
299: case ANY: return 1;
300: case VOID: return 0;
301: case ZTYPE: return SZ_WPTR; /* assume pointer */
302: case CHAR: return SZ_CHAR;
303: case SHORT: return SZ_SHORT;
304: case INT: return SZ_INT;
305: case LONG: return SZ_LONG;
306: case FLOAT: return SZ_FLOAT;
307: case DOUBLE: return SZ_DOUBLE;
308: case LDOUBLE: return SZ_LDOUBLE;
309:
310: case VEC:
311: { Pvec v = Pvec(t);
312: if (v->size == 0) {
313: if (fake_sizeof == 0) error('w',"sizeof array with undeclared dimension");
314: return SZ_WPTR; // vector argument has sizeof ptr
315: }
316: return v->size * v->typ->tsizeof();
317: }
318: case RPTR:
319: case PTR:
320: { int k = (Pptr(t)->memof)?sizeof(short)+sizeof(short):0;
321: t = Pptr(t)->typ;
322: xxx:
323: switch (t->base) {
324: default: return SZ_WPTR;
325: case CHAR: return SZ_BPTR;
326: case FCT: return SZ_WPTR+k;
327: case TYPE: t = Pbase(t)->b_name->tp; goto xxx;
328: }
329: }
330: case FIELD:
331: return Pbase(t)->b_bits/BI_IN_BYTE+1;
332:
333: case CLASS:
334: {
335: Pclass cl = Pclass(t);
336: if ((cl->defined&(DEFINED|SIMPLIFIED)) == 0) {
337: error("%tU, size not known",cl);
338: return SZ_INT;
339: }
340: if (cl->c_body == 1) // detect first allocation or sizeof
341: cl->dcl_print(0);
342: return cl->obj_size;
343: }
344:
345: case EOBJ:
346: case ENUM: return SZ_INT;
347:
348: default: return 0; // deref can be called for any type
349: //error('i',"sizeof(%d)",t->base);
350: }
351: }
352:
353: bit type::vec_type()
354: {
355: Ptype t = this;
356: xx:
357: switch (t->base) {
358: case ANY:
359: case VEC:
360: case PTR:
361: case RPTR: return 1;
362: case TYPE: t = Pbase(t)->b_name->tp; goto xx;
363: default: return 0;
364: }
365: }
366:
367: int ref_initializer;
368:
369: Ptype type::deref()
370: /* index==1: *p
371: index==0: p[expr]
372: */
373: {
374: //error('d',"%t -> deref() refd %d",this,ref_initializer);
375: Ptype t = this;
376: xx:
377: switch (t->base) {
378: case TYPE:
379: t = Pbase(t)->b_name->tp;
380: goto xx;
381: case PTR:
382: case RPTR:
383: case VEC:
384: { if (t == Pvoid_type) error("void* deRd");
385: Ptype tt = t = Pvec(t)->typ;
386: if (ref_initializer == 0) {
387: while (tt->base == TYPE) tt = Pbase(tt)->b_name->tp;
388: if (tt->base == COBJ) {
389: tt = Pbase(tt)->b_name->tp;
390: if (tt && Pclass(tt)->defined&(DEFINED|SIMPLIFIED))
391: (void) t->tsizeof();
392: }
393: }
394: // no break
395: }
396: case ANY:
397: return t;
398: default:
399: error("nonP deRd");
400: return any_type;
401: }
402: }
403:
404: Pfct type::memptr()
405: // is ``this'' a pointer to member function
406: {
407: Ptype t = this;
408: while (t->base == TYPE) t = Pbase(t)->b_name->tp;
409: if (t->base != PTR || Pptr(t)->memof==0) return 0;
410:
411: t = Pptr(t)->typ;
412: while (t->base == TYPE) t = Pbase(t)->b_name->tp;
413: return (t->base == FCT) ? Pfct(t) : 0;
414: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.