![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dcl4.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 dcl4.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / cfront2.00 |
1.1 root 1: /*ident "@(#)ctrans:src/dcl4.c 1.3.4.33" */
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: dcl4.c:
11: Declaration of class and enum
12:
13: *************************************************************************/
14:
15: #include "cfront.h"
16: #include "size.h"
17:
18: extern loc no_where;
19:
20: Pname find_vptr(Pclass);
21: void fix_args(Pfct f, Pclass cl)
22: /*
23: This function is used to cope with the case where cl::cl(cl&) is
24: declared AFTER f has been declared
25: set n_xref bit for f
26: */
27: {
28: for (Pname a = f->argtype; a; a = a->n_list) {
29: Pname n = a->tp->is_cl_obj();
30: if (n && Pclass(n->tp)==cl) a->n_xref = 1;
31: }
32: }
33:
34: Pname merge_conv(Pname c1, Pname c2)
35: {
36: if (c1 == 0) return c2;
37: if (c2 == 0) return c1;
38: if (c1 == c2) return c1;
39: error('s',"cannot merge lists of conversion functions");
40: return c1;
41: }
42:
43: static Eppp;
44:
45: char* get_classname(char* s)
46: /*
47: retrieve the outermost class name in a vtable name
48: */
49: {
50: //error('d',"get_classname(%s)",s);
51: char* s1 = 0;
52:
53: while (*s) {
54: s1 = s;
55: for ( ; s[0] && (s[0] != '_' || s[1] && s[1] != '_'); s++);
56: if (*s) s += 2; // bypass "__"
57: }
58:
59: return s1;
60: }
61:
62: char* drop_classname(char* s)
63: /*
64: retrieve all but the outermost class name in a vtable name
65: */
66: {
67: //error('d',"drop_classname(%s)",s);
68: char* r = new char[strlen(s)+1];
69: sprintf(r,s);
70: s = r;
71:
72: char* s1 = s;
73: while (*s) {
74: for ( ; s[0] && (s[0] != '_' || s[1] && s[1] != '_'); s++);
75: if (*s) {
76: s1 = s;
77: s += 2; // bypass "__"
78: }
79: }
80:
81: *s1 = '\0';
82:
83: return (*r) ? r : 0;
84: }
85:
86: Pbcl classdef::get_base( char *s )
87: /*
88: Find the base class whose name matches the argument
89: */
90: {
91: //error('d',"%t::get_base(%s)",this,s);
92: for (Pbcl b = baselist; b; b = b->next) {
93: for ( char *s1 = s, *s2 = b->bclass->string;
94: *s1 && *s2 && *s1 == *s2;
95: s1++, s2++);
96:
97: if (!(*s1 || *s2))
98: break;
99: }
100:
101: return b;
102: }
103:
104: int classdef::get_offset(char* s)
105: /*
106: Get offset represented by string as viewed from "this"
107: */
108: {
109: //error('d',"%t::get_offset(%s)",this,s);
110: if (!s) return 0;
111:
112: Pbcl b = get_base(get_classname(s));
113:
114: return b->obj_offset + b->bclass->get_offset(drop_classname(s));
115: }
116:
117: char* vtbl_str(char* s1, char* s2)
118: /*
119: combine two pieces of a vtbl name
120: */
121: {
122: //error('d',"vtbl_str(%s,%s)",s1,s2);
123: char* s3;
124: if (s1)
125: if (s2) {
126: s3 = new char[strlen(s1)+strlen(s2)+3];
127: sprintf(s3,"%s__%s",s1,s2);
128: return s3;
129: }
130: else
131: return s1;
132: else
133: return s2;
134: }
135:
136: void classdef::add_vtbl(velem* v, char* s, bit virt_flag)
137: /*
138: add vtbl to virt_list
139: */
140: {
141: //error('d',"%t->add_vtbl(%d,%s)",this,v,s);
142: Pvirt vtab = new virt(this, v, s, virt_flag);
143:
144: if (virt_flag) has_vvtab = 1;
145:
146: if (!virt_list) {
147: virt_list = vtab;
148: return;
149: }
150:
151: // If conficting vtable entries are made because of
152: // a virtual base class, must be considered an error.
153: for (Pvirt vt = virt_list; vt; vt = vt->next )
154: // if (strcmp(vt->string,s)==0) {
155: if (vt->string && strcmp(vt->string,s)==0) {
156: velem* ivec = vt->virt_init;
157: Pname on = ivec[0].n;
158: Pname nn = v[0].n;
159: Pclass ocl,ncl;
160: for (int i=0; on && nn; i++,on=ivec[i].n,nn=v[i].n) {
161: ocl = Pfct(on->tp)->memof;
162: ncl = Pfct(nn->tp)->memof;
163: if (on != nn)
164: if (!ocl->has_base(ncl))
165: if (!ncl->has_base(ocl))
166: break;
167: else {
168: ivec[i].n = nn;
169: ivec[i].offset = v[i].offset;
170: }
171: }
172: if (on || nn)
173: error("virtualB: ambiguous%n and%n", on, nn);
174: return;
175: }
176:
177: vtab->next = virt_list->next;
178: virt_list->next = vtab;
179: }
180:
181: static int Voffset; // cope with offsets of virtuals in deep nests
182: extern TOK Nvirt;
183: int vcounter;
184: static vmax;
185: const vpChunk = 32;
186:
187: int classdef::do_virtuals(Pvirt vtab, char* str, int leftmost, bit virt_flag)
188: /*
189: make vtbl for b in "this"
190: match up virtuals and assign virtual indices for the base or delegate "bcl"
191: first base class shares ``this'' and vtbl with this class
192: */
193: {
194: if (vmax<vcounter) vmax = vcounter;
195: int vpsz = (vmax+vcounter)/vpChunk+1; // fragmentation prevention
196: vpsz *= vpChunk;
197: Pname* vp = new Pname[vpsz];
198: velem* ivec = vtab ? vtab->virt_init : 0;
199: int vo = Voffset;
200: int vc = 0;
201: int changed = 0;
202:
203: //error('d',"%t->do_virtuals(%d,%s) voffset %d",this,vtab,str,Voffset);
204: //error('d',"virt_count %d vpsz %d vcounter %d",virt_count,vpsz,vcounter);
205: if (ivec) { // vtbl replacement for ivec
206:
207: extern vhack;
208: Pname vfct(Pclass,char*);
209: if (vtab->is_vbase) {
210: str = 0;
211: Voffset = get_offset(vtab->string);
212: }
213: else
214: Voffset = Voffset + vtab->vclass->get_offset(vtab->string);
215: Pname vn;
216: for (int i=0; vn=ivec[i].n; i++) {
217:
218: /* go through virtual table's list of virtuals:
219: first see if the function is simply inherited
220: if not, check for a match
221: if not, then add as new
222: */
223: // Pname vn = ivec[i];
224: if ( i >= vpsz ) { // resize vp vector
225: int tvpsz = vpsz + vpChunk;
226: Pname *tvp = new Pname[ tvpsz ];
227: for ( int j = 0; j < i; ++j )
228: tvp[ j ] = vp[ j ];
229: delete [vpsz] vp;
230: vp = tvp;
231: //error( 'd',"resizing: i: %d vpsz: %d tvpsz: %d", i, vpsz, tvpsz );
232: vpsz = tvpsz;
233: }
234:
235: char* s = Pchar(vn->n_tbl_list);
236: Pname n = memtbl->look(s?s:vn->string, 0);
237: //error('d',"vn %n %s n %n %d",vn,s,n,Voffset);
238: if (n == 0) { // FCT + FCT
239: inher: // inherit
240: if (vn->n_initializer) error("cannot inherit pure virtualF%n",vn);
241: vp[i] = vn;
242: if ( ivec[i].offset && vtab->is_vbase )
243: vp[i]->n_offset = Voffset - vo;
244: else
245: vp[i]->n_offset = ivec[i].offset;
246: continue;
247: }
248:
249: Pfct f = Pfct(n->tp);
250: // error ('d', "f %d", f );
251: if (f == 0 ) continue;
252: //error('d',"f %t %d",f,f->f_virtual);
253:
254: if (s && f->base==OVERLOAD) { // OVERLOAD + OVERLOAD
255: // vn is overloaded and s is its name
256: for (Plist gl=Pgen(f)->fct_list; gl; gl=gl->l)
257: if (gl->f == vn) goto inher;
258: }
259:
260: extern Vcheckerror;
261: Pfct vnf = Pfct(vn->tp);
262: // re-define?
263: switch (f->base) {
264: default:
265: error('w',&n->where,"%n hides virtual%n",n,vn);
266: break;
267: case FCT: // derived::FCT
268: {
269: vhack = 1;
270: if (vnf->check(f,VIRTUAL) == 0) { // derived::FCT match base::FCT
271: //error('d',"vnf1 %t f %t vcheck %d",vnf,f,Vcheckerror);
272: // VTOK: virtual, but no index assigned
273: // you can only inherit an index from your first base
274: if (Vcheckerror) error("bad virtualT match for %n",vn);
275: if (f->f_virtual==VTOK) f->f_virtual = i+1;
276: vp[i] = n;
277: vp[i]->n_offset = Voffset;
278: changed = 1;
279: }
280: else {
281: //error('d',"vnf2 %t f %t vcheck %d",vnf,f,Vcheckerror);
282: if (Vcheckerror)
283: error("bad virtualT match for %n",vn);
284: else
285: switch (f->f_virtual) {
286: case 0:
287: case VTOK:
288: error('w',&n->where,"%n hides virtual%n",n,vn);
289: }
290: vp[i] = vn; // not a new overloaded: inherit
291: if ( ivec[i].offset && vtab->is_vbase )
292: vp[i]->n_offset = Voffset - vo;
293: else
294: vp[i]->n_offset = ivec[i].offset;
295: }
296: vhack = 0;
297: break;
298: }
299: case OVERLOAD: // derived::OVERLOAD
300: {
301: vhack = 1;
302: int hit = 0;
303: for (Plist gl=Pgen(f)->fct_list; gl; gl=gl->l) {
304: // try each fct from derived class
305: Pname fn = gl->f;
306: Pfct f = Pfct(fn->tp);
307:
308: if (f->check(vnf,VIRTUAL) == 0) { // derived::FCT
309: if (Vcheckerror) error("bad virtualT match for %n",vn);
310: if (f->f_virtual==VTOK) f->f_virtual = i+1;
311: vp[i] = fn;
312: vp[i]->n_offset = Voffset;
313: changed = 1;
314: goto found;
315: }
316: else {
317: if (Vcheckerror) error("bad virtualT match for %n",vn);
318: }
319: if (Vcheckerror == 0)
320: switch (f->f_virtual) {
321: case 0:
322: case VTOK:
323: hit = 1;
324: }
325:
326: }
327:
328: if (hit) error('w',&n->where,"%n hides virtual%n ofT %t",n,vn,vn->tp);
329:
330: vp[i] = vn; // not a new overloaded: inherit
331: if ( ivec[i].offset && vtab->is_vbase )
332: vp[i]->n_offset = Voffset - vo;
333: else
334: vp[i]->n_offset = ivec[i].offset;
335: found:
336: vhack = 0;
337: break;
338: }
339: }
340: }
341:
342: Voffset = vo;
343: vc = i;
344: }
345:
346: //error( 'd', "out of loop: vc: %d vpsz: %d", vc, vpsz );
347:
348: if (leftmost) {
349: /*
350: add new virtuals:
351: `VTOK' marks ``new virtual, no index assigned''.
352: You can only be new once (no base or first base).
353: */
354: int i;
355: for (Pname nn=memtbl->get_mem(i=1); nn; nn=memtbl->get_mem(++i) ) {
356: Pfct f = Pfct(nn->tp);
357:
358: if ( vc >= vpsz ) { // resize vp vector
359: int tvpsz = vpsz + vpChunk;
360: Pname *tvp = new Pname[ tvpsz ];
361: for ( int j = 0; j < vc; ++j )
362: tvp[ j ] = vp[ j ];
363: delete [vpsz] vp;
364: vp = tvp;
365: //error( 'd',"resizing2: vc: %d vpsz: %d tvpsz: %d", vc, vpsz, tvpsz );
366: vpsz = tvpsz;
367: }
368:
369: //error('d',"f %n %t",nn,f);
370: if (f)
371: switch (f->base) {
372: case FCT:
373: //error('d',"fv %d",f->f_virtual);
374: if (f->f_virtual == VTOK) {
375: // declared virtual, or
376: // virtual in some base
377: f->f_virtual = ++vc;
378: vp[f->f_virtual-1] = nn;
379: vp[f->f_virtual-1]->n_offset = 0;
380: f->f_vdef = 1;
381: changed = 2;
382: }
383: break;
384: case OVERLOAD:
385: { for (Plist gl=Pgen(f)->fct_list; gl; gl=gl->l) {
386: Pname fn = gl->f;
387: Pfct f = Pfct(fn->tp);
388: if (f->f_virtual == VTOK) {
389: f->f_virtual = ++vc;
390: vp[f->f_virtual-1] = fn;
391: vp[f->f_virtual-1]->n_offset = 0;
392: f->f_vdef = 1;
393: changed = 2;
394: }
395: }
396: break;
397: }
398: }
399: }
400: //error('d',"%s changed %d has_vvtab %d",string,changed,has_vvtab);
401: //error('d',"vc %d vpsz %d",vc,vpsz);
402: virt_count = 0;
403: if (changed)
404: virt_count = vc;
405: else if (has_vvtab) {
406: virt_merge = 1;
407: if (vc && vtab->is_vbase)
408: leftmost = 0;
409: }
410: }
411:
412: //error('d',"vc %d ch %d vp[%d] virt_count %d",vc,changed,vpsz,virt_count);
413: if (changed || !leftmost) {
414: // vc==0 if all explicit virtuals in fact were declared in base
415: velem* v = new velem[vc+1];
416:
417: for (int i=0; i<vc; i++) {
418: v[i].n = vp[i];
419: v[i].offset = vp[i]->n_offset;
420: }
421: v[vc].n = 0;
422:
423: if (leftmost)
424: add_vtbl(v,0,0);
425: else
426: add_vtbl(v,vtbl_str(vtab->string,str),virt_flag||vtab->is_vbase);
427: delete vp;
428: vcounter = 0;
429: return 1;
430: }
431:
432: delete vp;
433: vcounter = 0;
434: return 0;
435: }
436:
437: int classdef::all_virt(Pclass bcl, char* s, int leftmost, bit virt_flag)
438: {
439: //error('d',"%t::all_virt(%t,%s,%d)",this,bcl,s,leftmost);
440: int i = 0;
441:
442: if (bcl->virt_count)
443: for (Pvirt blist = bcl->virt_list; blist; blist = blist->next) {
444: // if (has_base(blist->vclass))
445: // if (blist->vclass==bcl
446: // // bcl is virtual in both
447: // || ((Nvirt=0,blist->vclass->has_base(bcl)) && Nvirt==VIRTUAL
448: // && (Nvirt=0,has_base(bcl)) && Nvirt==VIRTUAL
449: // )
450: // )
451: if (virt_merge && !(virt_flag || blist->is_vbase))
452: continue;
453:
454: i += do_virtuals(blist, s, leftmost, virt_flag);
455: if (!i && leftmost && !virt_merge)
456: return 0;
457:
458: leftmost = 0;
459: }
460:
461: // finding virt_list stops recursive step
462: // if vtables found and updated, return number
463: if (i) return i;
464:
465: for (Pbcl b = bcl->baselist; b; b = b->next) {
466: // if (b->base==PTR) continue;
467: if (b->promoted) continue;
468: //error('d',"b %t vl %d bl %d",b->bclass,b->bclass->virt_list,b->bclass->baselist);
469: if (leftmost && b->base == VIRTUAL) {
470: i += do_virtuals(0, 0, 1, 0);
471: if (!i && !virt_merge)
472: return 0;
473: leftmost = 0;
474: }
475: int vo = Voffset;
476: Voffset += b->obj_offset;
477: //error('d',"offset %t %d",b->bclass,Voffset);
478:
479: if (b->base==VIRTUAL)
480: i += all_virt(b->bclass, b->bclass->string, leftmost, 1);
481: else
482: i += all_virt(b->bclass, vtbl_str(b->bclass->string,s), leftmost, virt_flag);
483: if (!i && leftmost && !virt_merge)
484: return 0;
485:
486: Voffset = vo;
487: leftmost = 0;
488: }
489:
490: // if recursion updated vtables, return number
491: if (i) return i;
492:
493: // no vtables updated in recursion
494: // look for new virtuals
495: if (leftmost)
496: return do_virtuals(0, 0, 1, 0);
497: else
498: return 0;
499: }
500:
501: Pexpr copy_obj(Pexpr l, Pexpr r, int sz)
502: /*
503: generate:
504: struct _s { char[sz]; };
505: *(struct _s*)this->m = *(struct _s*)arg.mem;
506: */
507: {
508: if ( !sz ) sz = 1;
509: //error('d',"copy(%d)",sz);
510: char* s = make_name('S');
511: fprintf(out_file,"struct %s { char v[%d]; };\n",s,sz);
512: Pname n = new name(s);
513: Ptype t = new basetype(COBJ,n);
514: t = new ptr(PTR,t);
515:
516: l = new texpr(CAST,t,l);//new cast(t,l);
517: l = l->contents();
518:
519: r = new texpr(CAST,t,r);//new cast(t,r);
520: r = r->contents();
521:
522: return new expr(ASSIGN,l,r);
523: }
524: /*
525: Pname make_default_ctor(Pclass cl)
526: {
527: //error('d',"make_ctor %t",cl);
528: Pname cn = ktbl->look(cl->string,0);
529: if (cn) cn = Pbase(cn->tp)->b_name;
530: cc->stack();
531: cc->not = cn;
532: cc->cot = cl;
533: Pname fn = new name(cl->string);
534: Pfct f = new fct(defa_type,0,1);
535: fn->tp = f;
536: fn->n_oper = TNAME;
537: // fn->n_sto = STATIC;
538:
539: Pfct(f)->f_inline = 1;
540: f->body = new block(curloc,0,0);
541:
542: Pname nn = fn->dcl(cl->memtbl,PUBLIC);
543: delete fn;
544:
545: cc->unstack();
546: nn->simpl();
547: if (debug_opt) nn->dcl_print(0);
548: //error('d',"make_ctor->");
549: return nn;
550: }
551:
552: Pname make_default_dtor(Pclass cl)
553: {
554: //error('d',"make_dtor %t",cl);
555: Pname cn = ktbl->look(cl->string,0);
556: if (cn) cn = Pbase(cn->tp)->b_name;
557: cc->stack();
558: cc->not = cn;
559: cc->cot = cl;
560: Pname fn = new name(cl->string);
561: Pfct f = new fct(defa_type,0,1);
562: fn->tp = f;
563: fn->n_oper = DTOR;
564: // fn->n_sto = STATIC;
565:
566: Pfct(f)->f_inline = 1;
567: f->body = new block(curloc,0,0);
568:
569: Pname nn = fn->dcl(cl->memtbl,PUBLIC);
570: delete fn;
571:
572: cc->unstack();
573: nn->simpl();
574: if (debug_opt) nn->dcl_print(0);
575: //error('d',"make_dtor->");
576: return nn;
577: }
578: */
579:
580: Ptype find_arg_type(Pclass cl)
581: // first determine argument type
582: {
583: int i;
584: int mod = 0;
585: for (Pbcl b = cl->baselist; b; b = b->next) {
586: Pclass bcl = b->bclass;
587: switch (b->base) {
588: case VIRTUAL:
589: case NAME: // generate :b(*(b*)&arg)
590: {
591: Pname itor = bcl->has_itor();
592: if (itor && itor->tp->base==FCT) {
593: Pname a = Pfct(itor->tp)->argtype;
594: Pptr p = a->tp->is_ref();
595: if (p && p->typ->tconst()==0) {
596: mod = 1;
597: goto ll1;
598: }
599: }
600: }
601: }
602: }
603: ll1:
604: if (mod == 0)
605: for (Pname m=cl->memtbl->get_mem(i=1); m; m=cl->memtbl->get_mem(++i) ) {
606: Pname cln;
607: // ignore static members
608: if (m->n_evaluated || m->n_stclass==STATIC) continue;
609:
610: if (cln = m->tp->is_cl_obj()) {
611: Pname itor = Pclass(cln->tp)->has_itor();
612: if (itor && itor->tp->base==FCT) {
613: Pname a = Pfct(itor->tp)->argtype;
614: Pptr p = a->tp->is_ref();
615: if (p && p->typ->tconst()==0) {
616: mod = 1;
617: goto ll2;
618: }
619: }
620: }
621: }
622: ll2:
623: //error('d',"mod %d",mod);
624: Pbase bp = new basetype(INT,0);
625: *bp = *Pbase(Pptr(cl->this_type)->typ);
626: if (mod == 0) bp->b_const = 1;
627: return new ptr(RPTR,bp);
628: }
629:
630: Pname classdef::make_itor(int def)
631: /*
632: make cn::cn(const cn&) :bases_and_members_of_cn {}
633: */
634: {
635: //error('d',"%t->make_itor(%d) %d",this,def,obj_size);
636: Pstmt s;
637: Pname e;
638: int i;
639: Pname arg = new name(make_name('A'));
640: /*
641: int mod = 0; // first determine argument type
642: {
643: for (Pbcl b = baselist; b; b = b->next) {
644: Pclass bcl = b->bclass;
645: switch (b->base) {
646: case VIRTUAL:
647: case NAME: // generate :b(*(b*)&arg)
648: {
649: Pname itor = bcl->has_itor();
650: if (itor && itor->tp->base==FCT) {
651: Pname a = Pfct(itor->tp)->argtype;
652: Pptr p = a->tp->is_ref();
653: if (p && p->typ->tconst()==0) {
654: mod = 1;
655: goto ll1;
656: }
657: }
658: }
659: }
660: }
661: ll1:
662: if (mod == 0)
663: for (Pname m=memtbl->get_mem(i=1); m; m=memtbl->get_mem(++i) ) {
664: Pname cln;
665: // ignore static members
666: if (m->n_evaluated || m->n_stclass==STATIC) continue;
667:
668: if (cln = m->tp->is_cl_obj()) {
669: Pname itor = Pclass(cln->tp)->has_itor();
670: if (itor && itor->tp->base==FCT) {
671: Pname a = Pfct(itor->tp)->argtype;
672: Pptr p = a->tp->is_ref();
673: if (p && p->typ->tconst()==0) {
674: mod = 1;
675: goto ll2;
676: }
677: }
678: }
679: }
680: ll2:
681: //error('d',"mod %d",mod);
682: Pbase bp = new basetype(INT,0);
683: *bp = *Pbase(Pptr(this_type)->typ);
684: if (mod == 0) bp->b_const = 1;
685: arg->tp = new ptr(RPTR,bp);
686: }
687: */
688: arg->tp = find_arg_type(this);
689:
690: // c_xref = 2; // now it has X(X&)
691: c_xref |= C_XREF; // now it has X(X&)
692:
693: if (def) {
694: // define itor
695: int slow = 0; // slow==0 => copy using vector copy
696: int first = 1;
697: Pexpr es = 0;
698: s = new estmt(SM,no_where,0,0);
699: e = 0;
700:
701:
702: if (warning_opt && 128<obj_size)
703: error('w',"copying a %d byte object (ofC%n)",obj_size,this);
704:
705: if (baselist) slow = 1;
706:
707: //for (Pbcl v = baselist; v; v = v->next)
708: // if (v->base == VIRTUAL) {
709: // slow = 1;
710: // break;
711: // }
712:
713: // initialize bases:
714: if (slow)
715: for (Pbcl b = baselist; b; b = b->next) {
716: Pclass bcl = b->bclass;
717: Ptype pt = bcl->this_type;
718: //error('d',"base %t %k offset %d ptroffset %d",bcl,b->base,b->obj_offset,b->ptr_offset);
719: switch (b->base) {
720: case VIRTUAL:
721: case NAME: // generate :b(*(b*)&arg)
722: {
723: Pexpr b2 = new name(arg->string);
724: b2 = b2->address();
725: b2 = new texpr(CAST,pt,b2);//new cast(pt,b2);
726: b2->i2 = 1;
727: b2 = b2->contents();
728:
729: Pname ee = new name(bcl->string);
730: ee->base = TNAME;
731: ee->n_initializer = b2;
732: if (e) ee->n_list = e;
733: e = ee;
734: break;
735: }
736: }
737: }
738:
739: // initialize members
740: for (Pname m=memtbl->get_mem(i=1); m; m=memtbl->get_mem(++i) ) {
741: // ignore static members
742: if (m->n_evaluated || m->n_stclass==STATIC) continue;
743:
744: /*AAA // can copy vptr, X(X&) sets it anyway
745: if (strcmp(m->string,"__vptr")==0) {
746: //error('d',"%t vptr: %d",this,first);
747: if (first==0 && m->n_offset) {
748: Pexpr th = new expr(THIS,0,0);
749: Pexpr a = new name(arg->string);
750: a = a->address();
751: Pexpr ee = copy_obj(th,a,m->n_offset);
752: es = es ? new expr(CM,es,ee) : ee;
753: }
754: slow = 1;
755: first = 0;
756: continue;
757: }
758: AAA*/
759: Ptype mt = m->tp;
760: tx:
761: switch (mt->base) {
762: case TYPE:
763: mt = Pbase(mt)->b_name->tp;
764: goto tx;
765: case VEC:
766: { Pname cn = Pvec(mt)->typ->is_cl_obj();
767: //error('d',"vec %n %t xref %d",m,mt,cn?Pclass(cn->tp)->c_xref:0);
768: if (cn && Pclass(cn->tp)->c_xref&(C_XREF|C_VBASE)) {
769: error('s',"copy of %n[], no memberwise copy for%n",cn,cn);
770: slow = 1; // make sure an assignment operator
771: // is generated so that there will
772: // be no more error messages
773: }
774:
775: if (slow && mt->tsizeof()) {
776: /*
777: generate:
778: struct _s { char[sizeof(m)]; };
779: *(struct _s*)this->m = *(struct _s*)arg.mem;
780: */
781: Pexpr l = new name(m->string);
782: Pexpr r = new name(m->string);
783: r = new ref(DOT,new name(arg->string),r);
784: Pexpr ee = copy_obj(l,r,mt->tsizeof());
785: es = es ? new expr(CM,es,ee) : ee;
786: break;
787: }
788: }
789: case FCT:
790: case OVERLOAD:
791: case CLASS:
792: case ENUM:
793: break;
794: case COBJ:
795: { Pclass mcl = Pclass(Pbase(mt)->b_name->tp);
796: if (slow==0 // if slow, previous members have
797: // already been copied
798: && mcl->c_xref&(C_VBASE|C_XREF)) {
799: slow = 1;
800: if (first==0 && m->n_offset) {
801: //AAA copy up to here
802: Pexpr th = new expr(THIS,0,0);
803: Pexpr a = new name(arg->string);
804: a = a->address();
805: Pexpr ee = copy_obj(th,a,m->n_offset);
806: es = es ? new expr(CM,es,ee) : ee;
807: }
808: }
809: // no break
810: }
811:
812: default:
813: if (slow) {
814: //error('d',"slow %s %s",m->string,arg->string);
815: Pname ee = new name(m->string);
816: ee->n_initializer = new ref(DOT,new name(arg->string),new name(m->string));
817: if (e) ee->n_list = e;
818: e = ee;
819: }
820: }
821: first = 0;
822: }
823:
824: if (slow == 0) {
825: /* really simple just copy:
826: the only problem was a vptr which can be
827: ignored since X(X&) is going to reset it anyway
828: don't use assignment of this struct to avoid operator=
829: */
830: Pexpr th = new expr(THIS,0,0);
831: Pexpr a = new name(arg->string);
832: a = a->address();
833: Pexpr ee = copy_obj(th,a,obj_size);
834: es = es ? new expr(CM,es,ee) : ee;
835: }
836:
837: s->e = es;
838: Pname cn = ktbl->look(string,0);
839: if (cn) cn = Pbase(cn->tp)->b_name;
840: cc->stack();
841: cc->not = cn;
842: cc->cot = this;
843: }
844: Pname fn = new name(string);
845: Pfct f = new fct(defa_type,arg,1);
846: fn->tp = f;
847: fn->n_oper = TNAME;
848: // fn->n_sto = STATIC;
849:
850: Pfct(f)->f_inline = def?1:ITOR; // ITOR means ``define itor() if used''
851: if (def) {
852: f->body = new block(curloc,0,s);
853: f->f_init = e;
854: }
855:
856: Pname nn = fn->dcl(memtbl,PUBLIC);
857: delete fn;
858:
859: if (def) {
860: cc->unstack();
861: nn->simpl();
862: if (debug_opt) nn->dcl_print(0);
863: }
864: //error('d',"make_itor->");
865: return nn;
866: }
867:
868: int make_assignment(Pname cn)
869: /*
870: write the function:
871:
872: X& X::operator=(const X&) { assign all bases and members }
873:
874: return 1 is a function is really synthesized
875: */
876: {
877: Pclass cl = Pclass(cn->tp);
878: Pstmt s = new estmt(SM,no_where,0,0);
879: Pexpr e = 0;
880: Pname arg = new name(make_name('A'));
881: basetype* bp = new basetype(INT,0);
882: *bp = *Pbase(Pptr(cl->this_type)->typ);
883: bp->b_const = 1;
884: // arg->tp = new ptr(RPTR,bp);
885: arg->tp = find_arg_type(cl);
886: //error('d',"make_assignment %t %d",cl,cl->obj_size);
887: // cl->c_xref |= 4; // now it has X::operator=(const X&)
888:
889: if (warning_opt && 128<cl->obj_size)
890: error('w',"copying a %d byte object (ofC%n)",cl->obj_size,cl);
891: {
892: int slow = 0; // slow==0 => copy using vector copy
893: int first = 1; // first==1 => first member of (derived) class
894:
895: if (cl->baselist) slow = 1; // be dumb and safe
896: // for (Pbcl v = cl->baselist; v; v = v->next)
897: // if (v->base==VIRTUAL || v->c_xref&(C_VBASE|C_ASS)) {
898: // slow = 1;
899: // break;
900: // }
901:
902: if (slow)
903: for (Pbcl b = cl->baselist; b; b = b->next) {
904: Pclass bcl = b->bclass;
905: Ptype pt = bcl->this_type;
906: switch (b->base) {
907: case NAME:
908: { // generate: *(bcl*)this = *(bcl*)&arg;
909: //error('d',"base %t",bcl);
910: Pexpr b1 = new expr(THIS,0,0);
911: b1 = new texpr(CAST,pt,b1);
912: b1 = b1->contents();
913:
914: Pexpr b2 = new name(arg->string);
915: b2 = b2->address();
916: b2 = new texpr(CAST,pt,b2);
917: b2->i2 = 1;
918: b2 = b2->contents();
919:
920: Pexpr ee = new expr(ASSIGN,b1,b2);
921: e = e ? new expr(CM,e,ee) : ee;
922: break;
923: }
924: case VIRTUAL:
925: if (warning_opt)
926: error('w',"copying an object ofC%n with s virtualBC",cl);
927: if (b->ptr_offset) {
928: // copy object, but not pointer
929: // generate: *(bcl*)this->Pw = *(bcl*)arg->Pw;
930:
931: // I don't know how to avoid copying the object
932: // once for each pointer
933:
934: Pexpr b1 = new expr(THIS,0,0);
935: b1 = new mdot(bcl->string,b1);
936: b1->i1 = 3;
937: b1->tp = pt;
938: b1 = new expr(DEREF,b1,0);//b1->contents();
939:
940: Pexpr b2 = new name(arg->string);
941: b2 = b2->address();
942: b2 = new mdot(bcl->string,b2);
943: b2->i1 = 3;
944: b2->tp = pt;
945: b2 = new expr(DEREF,b2,0);//b2->contents();
946:
947: Pexpr ee = new expr(ASSIGN,b1,b2);
948: e = e ? new expr(CM,e,ee) : ee;
949: }
950: break;
951: }
952: }
953:
954: int i;
955: for (Pname m=cl->memtbl->get_mem(i=1); m; m=cl->memtbl->get_mem(++i) ) {
956: // ignore static members
957: if (m->n_evaluated || m->n_stclass==STATIC) continue;
958:
959: if (strcmp(m->string,"__vptr")==0) { // don't copy vptrs
960: // we may be copying
961: // into a base class object
962: if (first==0 && m->n_offset) {
963: // copy up to (but not including) vptr
964: // don't copy if first member
965: Pexpr th = new expr(THIS,0,0);
966: Pexpr a = new name(arg->string);
967: a = a->address();
968: Pexpr ee = copy_obj(th,a,m->n_offset);
969: e = e ? new expr(CM,e,ee) : ee;
970: }
971: slow = 1;
972: first = 0;
973: continue;
974: }
975: Ptype mt = m->tp;
976: tx:
977: switch (mt->base) {
978: case TYPE:
979: mt = Pbase(mt)->b_name->tp;
980: goto tx;
981: case VEC:
982: { Pname cn = Pvec(mt)->typ->is_cl_obj();
983: if (cn && Pclass(cn->tp)->c_xref&(C_ASS|C_VBASE)) {
984: error('s',"copy of %n[], no memberwise copy for%n",cn,cn);
985: slow = 1; // make sure an assignment operator
986: // is generated so that there will
987: // be no more error messages
988: }
989:
990: if (slow && mt->tsizeof()) {
991: // protect against sizeof(mt)==0: char[]
992: /*
993: generate:
994: struct _s { char[sizeof(m)]; };
995: *(struct _s*)this->m = *(struct _s*)arg.mem;
996: */
997: Pexpr l = new name(m->string);
998: Pexpr r = new name(m->string);
999: r = new ref(DOT,new name(arg->string),r);
1000: Pexpr ee = copy_obj(l,r,mt->tsizeof());
1001: e = e ? new expr(CM,e,ee) : ee;
1002: break;
1003: }
1004: }
1005: case FCT:
1006: case OVERLOAD:
1007: case CLASS:
1008: case ENUM:
1009: break;
1010: case RPTR:
1011: error("cannot assignC%t:RM%n",cl,m);
1012: break;
1013: case COBJ:
1014: //error('d',"cobj %n %d %d",m,slow,Pclass(Pbase(mt)->b_name->tp)->c_xref);
1015: if (slow==0
1016: && Pclass(Pbase(mt)->b_name->tp)->c_xref&(C_VBASE|C_ASS)) {
1017: // must use its assignment operation
1018: if (first==0 && m->n_offset) {
1019: // copy up to this member
1020: Pexpr th = new expr(THIS,0,0);
1021: Pexpr a = new name(arg->string);
1022: a = a->address();
1023: e = copy_obj(th,a,m->n_offset);
1024: }
1025: slow = 1;
1026: }
1027: // no break: copy cobj itself
1028: default:
1029: //error('d',"defa %n %d",m,slow);
1030: if (slow) {
1031: if (m->tp->tconst()) error("cannot assignC%t: const M%n",cl,m);
1032: Pname ms = new name(m->string);
1033: Pname as = new name(arg->string);
1034: Pexpr ee = new ref(DOT,as,new name(m->string));
1035: ee = new expr(ASSIGN,ms,ee);
1036: e = e ? new expr(CM,e,ee) : ee;
1037: }
1038: }
1039: first = 0;
1040: }
1041:
1042: if (slow == 0) {
1043: /* really simple just copy:
1044: */
1045: //error('d',"slow");
1046: /*
1047: Pexpr th = new expr(THIS,0,0);
1048: Pexpr a = new name(arg->string);
1049: a = a->address();
1050: Pexpr ee = copy_obj(th,a,cl->tsize());
1051: e = e ? new expr(CM,e,ee) : e;
1052: */
1053: //error('d',"%n simple assignment",cn);
1054: // cl->c_xref ^= C_ASS; // Didn't mean it: No X::operator=(X&)
1055: return 0;
1056: }
1057:
1058: }
1059:
1060: Pexpr rv = new expr(THIS,0,0);
1061: rv = new expr(DEREF,rv,0);//b1->contents();
1062:
1063: s->e = e ? new expr(CM,e,rv) : e;
1064: s->s_list = new estmt(RETURN,no_where,rv,0);
1065:
1066: cc->stack();
1067: cc->not = cn;
1068: cc->cot = cl;
1069:
1070: cl->c_xref |= C_ASS; // now it has X::operator=(const X&)
1071:
1072: Pname fn = new name(oper_name(ASSIGN));
1073: Pfct f = new fct(new ptr(RPTR,Pptr(cl->this_type)->typ),arg,1);
1074: f->f_inline = 1;
1075: fn->tp = f;
1076: fn->n_oper = ASSIGN;
1077: fn->n_sto = STATIC;
1078: Pname nn = fn->dcl(cl->memtbl,PUBLIC);
1079: delete fn;
1080: Pfct(nn->tp)->body = new block(curloc,0,s);
1081: Pfct(nn->tp)->dcl(nn);
1082:
1083: cc->unstack();
1084: nn->simpl();
1085: //error('d',"make_assign->");
1086: return 1;
1087: }
1088:
1089: void classdef::dcl(Pname cname, Ptable tbl)
1090: {
1091: int bvirt = 0;
1092: int dvirt = 0;
1093: int scope = PUBLIC;
1094: int protect = 0;
1095: int st = 1; // nothing private or protected seen: a struct
1096:
1097: int byte_old = byte_offset;
1098: int bit_old = bit_offset;
1099: int max_old = max_align;
1100: int boff = 0;
1101:
1102: int in_union = 0;
1103: int usz;
1104: int make_ctor = 0;
1105: int make_dtor = 0;
1106:
1107: /* this is the place for paranoia */
1108: if (this == 0) error('i',"0->Cdef::dcl(%p)",tbl);
1109: if (base != CLASS) error('i',"Cdef::dcl(%d)",base);
1110: if (cname == 0) error('i',"unNdC");
1111: if (cname->tp != this) error('i',"badCdef");
1112: if (tbl == 0) error('i',"Cdef::dcl(%n,0)",cname);
1113: if (tbl->base != TABLE) error('i',"Cdef::dcl(%n,tbl=%d)",cname,tbl->base);
1114: //error('d',"classdef %s tbl %d gtbl %d",string,tbl,gtbl);
1115:
1116: switch (csu) {
1117: case UNION:
1118: case ANON:
1119: in_union = 1;
1120: break;
1121: case CLASS:
1122: scope = 0;
1123: }
1124:
1125: max_align = AL_STRUCT;
1126:
1127: // local classes
1128: //error('d', "classdef(): lex_level: %d nof: %n", lex_level, cc->nof);
1129: if (lex_level) {
1130: in_fct = cc->nof;
1131: // local classes at lex_level==1
1132: if ( lcl == 0 ) lcl = make_name( 'L' );
1133: }
1134:
1135: if (strlen == 0) strlen = ::strlen(string);
1136:
1137: if (baselist) {
1138: /*
1139: check base classes.
1140: duplicates were removed in start_cl() in norm.c.
1141: remove bad classes.
1142: add virtual bases from bases to the list.
1143:
1144: check against
1145: class b : a {}
1146: class c : a, b {} // first a inaccessible
1147: */
1148:
1149: Pbcl ll = 0;
1150: Pbcl lll = 0;
1151: Pbcl vlist = 0;
1152: for (Pbcl lx, l=baselist; l; l=lx) { // remove bad bases
1153: Pclass cl = l->bclass;
1154: lx = l->next;
1155:
1156: //error('d',"base1 %t %k init %d",cl,l->ppp,l->init);
1157: // ``class'' => private base ``struct'' => public base
1158: if (l->ppp == 0) {
1159: l->ppp = csu==CLASS ? PRIVATE : PUBLIC;
1160: #ifndef OLD
1161: if (l->ppp == PRIVATE) error('w',"B%t private by default: please be explicit ``: private%t",cl,cl);
1162: #endif
1163: }
1164: // if you have a ``class'' as base you cannot remain a
1165: // ``mere struct''
1166: if (cl && cl->csu == CLASS) st = 0;
1167:
1168: if ((cl->defined&(DEFINED|SIMPLIFIED)) == 0) {
1169: error("BC %sU",cl->string);
1170: continue;
1171: }
1172: else
1173: (void)cl->tsizeof(); // ensure printout
1174:
1175: if (cl->csu==UNION || cl->csu==ANON) {
1176: error("C derived from union");
1177: continue;
1178: }
1179:
1180: if (in_union) {
1181: error("derived union");
1182: continue;
1183: }
1184:
1185: if (l->base==VIRTUAL) {
1186: if (cl->has_ictor()==0 && cl->has_ctor()) {
1187: error("virtualB%t has no defaultIr",cl);
1188: continue;
1189: }
1190: // order of virtual classes doesn't matter
1191: l->next = vlist;
1192: vlist = l;
1193: }
1194: else { // keep ordinary base classes in order
1195: if (ll == 0) {
1196: lll = l;
1197: l->next = 0;
1198: }
1199: else
1200: ll->next = l;
1201: ll = l;
1202: }
1203: }
1204: if (ll) {
1205: ll->next = vlist; // put virtual bases at end
1206: baselist = lll;
1207: }
1208: else
1209: baselist = vlist;
1210:
1211: lll = 0;
1212: for (l=baselist; l; l=l->next) { // detect unmanageable duplicates
1213: Pclass b = l->bclass;
1214: for (ll=baselist; ll; ll=ll->next)
1215: if (b!=ll->bclass && ll->bclass->check_dup(b,l->base)) {
1216: if (lll)
1217: lll->next = l->next;
1218: else
1219: baselist = l->next;
1220: goto mmm;
1221: }
1222:
1223: lll = l;
1224: mmm:;
1225: }
1226:
1227: for (l=baselist; l; l=l->next) { // promote virtual bases
1228: Pclass b = l->bclass;
1229: for (ll=b->baselist; ll; ll=ll->next) {
1230: if (ll->base == VIRTUAL) {
1231: Pclass v = ll->bclass;
1232: for (Pbcl lll=baselist; lll; lll=lll->next)
1233: if (lll->bclass == v) goto nnn;
1234: // error('w',"%t is virtualB of%t",v,this);
1235: baselist = new basecl(v,baselist);
1236: baselist->base = VIRTUAL;
1237: baselist->promoted = 1;
1238: // needs a more complete check of visibility rules
1239: //error('d',"promote %t %k",v,ll->ppp);
1240: baselist->ppp = ll->ppp;
1241: }
1242: nnn:;
1243: }
1244: }
1245:
1246: ll = 0;
1247: lll = 0;
1248: l=baselist;
1249: baselist = 0;
1250: vlist = 0;
1251: for (; l; l=lx) {
1252: // sort virtual bases so that no virtual base
1253: // is ahead of its own virtual base
1254: lx = l->next;
1255: if (l->base == VIRTUAL) { // add to sorted vlist
1256: // each class before its bases
1257: if (vlist == 0) {
1258: vlist = l;
1259: l->next = 0;
1260: }
1261: else {
1262: Pclass lb = l->bclass;
1263: Pbcl v_prev = 0;
1264: for (Pbcl vx, v = vlist; v; v=vx) {
1265: Pclass vb = v->bclass;
1266: vx = v->next;
1267:
1268: if (lb->has_base(vb)) {
1269: // put l ahead of v
1270: l->next = v;
1271: if (v_prev)
1272: v_prev->next = l;
1273: else
1274: vlist = l;
1275: break;
1276: }
1277: if (vx == 0) {
1278: // stick l at end
1279: v->next = l;
1280: l->next = 0;
1281: break;
1282: }
1283: v_prev = v;
1284: }
1285: }
1286: }
1287: else { // keep in order
1288: if (ll == 0) {
1289: lll = l;
1290: l->next = 0;
1291: }
1292: else
1293: ll->next = l;
1294: ll = l;
1295: }
1296: }
1297:
1298: if (ll) {
1299: ll->next = vlist; // put virtual bases at end
1300: baselist = lll;
1301: }
1302: else
1303: baselist = vlist;
1304:
1305: for (l=baselist; l; l=l->next) { // allocate base class objects
1306: Pclass cl = l->bclass;
1307: //error('d',"base %t %k init %d",cl,l->ppp,l->init);
1308: if (l->base == VIRTUAL) { // : virtual bclass
1309: // pointer and object for virtual base MAY
1310: // be allocated at the end - but not here
1311: c_xref |= C_VBASE;
1312: dvirt += cl->virt_count;
1313: }
1314: else { // : bclass =>allocate
1315: int ba = cl->align();
1316: if (max_align<ba) max_align = ba;
1317:
1318: if (cl == baselist->bclass) { // pad to ensure alignment:
1319: boff = cl->real_size;
1320: int xtra = boff%ba; // not obj_size-real_size, we can
1321: // optimize vbase object away
1322: if (xtra) boff += ba-xtra; // align
1323: }
1324: else { // let C handle the padding:
1325: int xtra = boff%ba;
1326: if (xtra) boff += ba-xtra; // align
1327: l->obj_offset = boff;
1328: boff += cl->obj_size; // don't use waste
1329: }
1330: bvirt += cl->virt_count;
1331: }
1332:
1333: if (cl->has_vvtab) has_vvtab = 1;
1334: c_xref |= cl->c_xref;
1335:
1336: //error('d',"%t: base %t conv %d base conv %d",this,cl,conv,cl->conv);
1337: conv = merge_conv(conv,cl->conv);
1338: }
1339: }
1340:
1341: memtbl->set_name(cname);
1342:
1343: // int nmem = mem_list->no_of_names();
1344: int nmem = 0;
1345: int fct_mem = 0;
1346: { for (Pname m = mem_list; m; m=m->n_list) {
1347: nmem++;
1348: if (m->tp && m->tp->base==FCT) fct_mem++;
1349: }
1350: }
1351: if (nmem) memtbl->grow((nmem<=2)?3:nmem);
1352:
1353: cc->stack();
1354: cc->not = cname;
1355: cc->cot = this;
1356:
1357: byte_offset = usz = boff;
1358: bit_offset = 0;
1359:
1360:
1361: Pbase bt = new basetype(COBJ,cname);
1362: bt->b_table = memtbl;
1363: Ptype cct = bt->addrof();
1364: if (strict_opt) Pptr(cct)->rdo = 1; // type of `this': X *const
1365: this_type = cc->tot = cct;
1366: PERM(cct);
1367: PERM(bt);
1368:
1369: for (Pname px, p=mem_list; p; p=px) {
1370: /*
1371: look at each member;
1372: declare it and determine its visibility
1373: calculate offsets and sizes
1374: */
1375: px = p->n_list;
1376:
1377: switch (p->base) {
1378: case PUBLIC:
1379: scope = PUBLIC;
1380: protect = 0;
1381: goto prpr;
1382:
1383: case PRIVATE:
1384: scope = 0;
1385: protect = 0;
1386: goto prpr;
1387:
1388: case PROTECTED:
1389: scope = 0;
1390: protect = PROTECTED;
1391: prpr:
1392: if (in_union) error("%k in unionD",p->base);
1393: continue;
1394:
1395: case PR: // visibility control: C::M
1396: {
1397: char* qs = p->n_qualifier->string;
1398: char* ms = p->string;
1399: TOK ppp = scope?PUBLIC:(protect?PROTECTED:PRIVATE);
1400:
1401: p->base = NAME;
1402: p->n_scope = scope;
1403: p->n_protect = protect;
1404:
1405: if (strcmp(ms,qs) == 0) ms = "__ct";
1406:
1407: extern ppbase;
1408: ppbase = PUBLIC;
1409:
1410: if (is_base(qs) == 0) {
1411: error("%kQr %s not aBC of %s",ppp,qs,string);
1412: continue;
1413: }
1414:
1415: extern int mex;
1416: extern Pclass mec;
1417: extern Pclass tcl;
1418: extern Pname me;
1419: extern Pfct mef;
1420: mex = 1;
1421: tcl = mec = this;
1422: me = 0;
1423: mef = 0;
1424: c_body = 0; // this search must not be interpreted as a use
1425: Pname os = Cdcl;
1426: Cdcl = p;
1427: Pexpr ee = find_name(ms,0);
1428: Cdcl = os;
1429: c_body = 1;
1430:
1431: // while (ee->base == MDOT || ee->base == REF)
1432: while (ee && (ee->base == MDOT || ee->base == REF))
1433: ee = ee->mem;
1434: Pname mx = Pname(ee);
1435:
1436: if (mx == 0) {
1437: error("C %s does not have aM %s",qs,ms);
1438: continue;
1439: }
1440:
1441: if (mx->tp->base == OVERLOAD) {
1442: error('s',"%k specification of overloaded%n",ppp,mx);
1443: continue;
1444: }
1445:
1446: TOK pp = mx->n_scope?PUBLIC:mx->n_protect?PROTECTED:PRIVATE;
1447:
1448: //error('d',"mx %n pp %k ppp %k",mx,pp,ppp);
1449: if (ppp != pp) {
1450: error(&p->where,"%kM%n specified%k",pp,mx,ppp);
1451: continue;
1452: }
1453:
1454:
1455: p->n_qualifier = mx;
1456: Pname m = memtbl->insert(p,0);
1457: m->base = PUBLIC;
1458: if (Nold) error("twoDs of CM%n",p);
1459: continue;
1460: }
1461: }
1462:
1463: //error('d',"mem%n %d scope %d n_sto %k",p,p->tp->base,scope,p->n_sto);
1464: if (scope==0) st = 0;
1465:
1466: if (p->tp->base == FCT) {
1467: int ff = 0;
1468: Pfct f = Pfct(p->tp);
1469: Pblock b = f->body;
1470: f->body = 0;
1471: if (b) f->f_inline = 1;
1472: switch (p->n_sto) {
1473: case FRIEND:
1474: ff = 1;
1475: break;
1476: case STATIC: // accept static member functions
1477: //error('d',"inline %d",f->f_inline);
1478: // if (f->f_inline==0)
1479: f->f_static = 1;
1480: p->n_sto = 0;
1481: break;
1482: case AUTO:
1483: // case STATIC:
1484: case REGISTER:
1485: case EXTERN:
1486: error("M%n cannot be%k",p,p->n_sto);
1487: p->n_sto = 0;
1488: }
1489: Pname m = p->dcl(memtbl,scope);
1490: if (m == 0) continue;
1491: //error('d',"p %n %t %d",m,f,m->n_initializer);
1492: if (m->n_initializer) c_abstract = 1;
1493: //error('d',"mem %n: %t ff %d protect %k",m,m->tp,ff,protect);
1494: if (ff == 0) m->n_protect = protect;
1495: if (b) {
1496: //error('d',"b line %d %d defined %d",p->where.line,m->where.line,m->tp->defined);
1497: if (m->tp->defined&(DEFINED|SIMPLIFIED))
1498: error("two definitions of%n",m);
1499: else
1500: Pfct(m->tp)->body = b;
1501: // Pfct(m->tp)->f_inline = 1;
1502: }
1503: if (ff==0 && p->where.line!=m->where.line)
1504: error("%n cannot be redeclared inCD",p);
1505: }
1506: else {
1507: Eppp = scope?scope:protect?protect:0;
1508:
1509: if (p->base == TNAME) { // typedef names are exported
1510: // to surrounding scope
1511: // NOT complete: should go to
1512: // surrounding non-class scope
1513: p->dcl(tbl,scope);
1514:
1515: // typedefs need to be generated outside class
1516: if ( p->tp && Pbase(p->tp)->base != COBJ ) {
1517: Pname n = gtbl->look(p->string,0);
1518: if ( n && lex_level == 0 && n->base != TNAME )
1519: error("%nredefined: identifier and typedef",p);
1520: p->dcl_print(0);
1521: }
1522: continue;
1523: };
1524:
1525: if (p->n_initializer) {
1526: error("Ir forM%n",p);
1527: p->n_initializer = 0;
1528: }
1529:
1530: // error('d',"lex_level: %d p %n lex %d",lex_level, p,p->lex_level);
1531: extern Ptable lcl_tbl;
1532: if ( lex_level && p->tp->base == VEC ) lcl_tbl = tbl;
1533: Pname m = p->dcl(memtbl,scope);
1534: lcl_tbl = 0;
1535: Eppp = 0;
1536: if (m == 0) continue;
1537:
1538: m->n_protect = protect;
1539:
1540: if (m->n_stclass==STATIC) {
1541: extern Plist stat_mem_list;
1542: if (in_union) error("staticM%n in union",m);
1543: // Ptype t = m->tp;
1544: // Pname cn = t->is_cl_obj();
1545: // if ((cn && Pclass(cn->tp)->has_ctor())
1546: // || t->is_ref()
1547: // || (t->tconst() && vec_const == 0))
1548: m->n_sto = EXTERN;
1549: if (tbl == gtbl) stat_mem_list = new name_list(m,stat_mem_list);
1550: if (m->n_initializer) error('s',"staticM%nWIr",m);
1551: }
1552:
1553: if (in_union) {
1554: if (usz < byte_offset) usz = byte_offset;
1555: byte_offset = 0;
1556: }
1557: }
1558: }
1559:
1560: if (st && csu==CLASS) csu = STRUCT; // nothing private => STRUCT
1561:
1562: if (in_union) byte_offset = usz;
1563:
1564: // now look look at the members
1565:
1566: Pname ct = has_ctor();
1567: Pname dt = has_dtor();
1568: int i;
1569:
1570: extern int mex;
1571: int omex = mex; mex = 0;
1572: Pname on = has_oper(NEW);
1573: Pname od = has_oper(DELETE);
1574: mex = omex;
1575:
1576: if (dt && ct==0) error('w',"%s has%n but noK",string,dt);
1577: if (on && od==0) error('w',"%s has%n but no operator delete()",string,on);
1578: if (od && on==0) error('w',"%s has%n but no operator new()",string,od);
1579:
1580: if (dt==0 && od && od && od->n_table==memtbl) make_dtor = 1;
1581:
1582: for (Pname m=memtbl->get_mem(i=1); m; m=memtbl->get_mem(++i) ) {
1583: /*
1584: The members have been declared.
1585: now look at each to see if it needs defining
1586: */
1587: Ptype t = m->tp;
1588:
1589: if (t == 0) continue; // public declarations
1590:
1591: switch (t->base) {
1592: default:
1593: if (ct==0
1594: && m->n_stclass!=ENUM
1595: && m->n_stclass!=STATIC) {
1596: if (t->is_ref()) error("R%n inC %sWoutK",m,string);
1597: if (t->tconst()
1598: && vec_const==0
1599: && m->n_evaluated==0)
1600: error("const%n inC %sWoutK",m,string);
1601: }
1602: case VEC:
1603: break;
1604: case FCT:
1605: case OVERLOAD:
1606: case CLASS:
1607: case ENUM:
1608: continue;
1609: }
1610:
1611: Pname cn = t->is_cl_obj();
1612: if (cn == 0) cn = cl_obj_vec;
1613: if (cn == 0) continue;
1614:
1615: Pclass cl = Pclass(cn->tp);
1616: c_xref |= cl->c_xref;
1617: //error('d',"m %n %t %d",m,cl,cl->c_xref);
1618: if (cl->has_ctor()) {
1619: if (m->n_stclass == STATIC)
1620: ; // error('s',"staticM%n ofC%nWK",m,cn);
1621: else if (in_union)
1622: error("M%n ofC%nWK in union",m,cn);
1623: else if (ct == 0) {
1624: // does mctor have a default constructor?
1625: if (make_ctor==0 && cl->has_ictor()==0)
1626: error("%t needs aK; it has aMWK requiringAs",this);
1627: make_ctor = 1;
1628: }
1629: }
1630:
1631: if (cl->has_dtor()) {
1632: if (m->n_stclass==STATIC)
1633: ; // error('s',"staticM%n ofC%nW destructor",m,cn);
1634: else if (in_union)
1635: error("M%n ofC%nW destructor in union",m,cn);
1636: else if (dt==0)
1637: make_dtor = 1;
1638: }
1639: }
1640:
1641: if (has_dtor()==0 && make_dtor==0) {
1642: // can dtor be inherited (from single base class)?
1643: Pclass bcl = 0;
1644: for (Pbcl b = baselist; b; b = b->next) {
1645: switch (b->base) {
1646: case NAME:
1647: if (bcl == 0) {
1648: Pname d = b->bclass->has_dtor();
1649: if (d==0) break;
1650: if (strict_opt == 0) {
1651: if (d->n_scope==PUBLIC
1652: && Pfct(d->tp)->f_virtual==0) {
1653: bcl = b->bclass;
1654: break;
1655: }
1656: }
1657: }
1658: // two dtors or non-public dtors force creation
1659: make_dtor = 1;
1660: goto zbzb;
1661: case VIRTUAL:
1662: if (b->bclass->has_dtor()) make_dtor = 1;
1663: goto zbzb;
1664: }
1665: }
1666: if (bcl) c_dtor = bcl->has_dtor();
1667: zbzb:;
1668: }
1669:
1670: if (make_dtor && dt==0) { // make x::~x() {}
1671:
1672: // must be done before vtbls are made in case dtor is virtual
1673: //error('d',"%t: make_dtor",this);
1674: Pname n = new name(string);
1675: Pfct f = new fct(defa_type,0,1);
1676: f->f_inline = /*IDTOR; */ 1;
1677: n->tp = f;
1678: n->n_oper = DTOR;
1679: dt = n->dcl(memtbl,PUBLIC);
1680: delete n;
1681: Pfct(dt->tp)->body = /*0; */ new block(curloc,0,0);
1682: dt = has_dtor();
1683: }
1684:
1685: if (virt_count && find_vptr(this)==0) {
1686: // we only need a vptr if this class
1687: // has virtual functions and none
1688: // of its first bases have vptrs
1689: //error('d',"%s virt_count %d",string,virt_count);
1690: extern Ptype Pvptr_type;
1691: Pname vp = new name("__vptr");
1692: vp->tp = Pvptr_type;
1693: (void) vp->dcl(memtbl,0);
1694: delete vp;
1695: c_xref |= C_VPTR;
1696: }
1697: else
1698: // no more bit fields. absorb bit_offset
1699: if (bit_offset) byte_offset += (bit_offset/BI_IN_BYTE+1);
1700:
1701: for (Pbcl b = baselist; b; b = b->next) { // allocate virtual base pointers
1702: if (b->base != VIRTUAL) continue;
1703: Pclass bcl = b->bclass;
1704:
1705: // search non-virtual bases for this virtual base
1706: for (Pbcl bb = baselist; bb; bb = bb->next)
1707: if (bb->base == NAME) {
1708: for (Pbcl l = bb->bclass->baselist; l; l=l->next)
1709: if (l->base==VIRTUAL && l->bclass==bcl) goto eee;
1710: }
1711: {
1712: if (obj_align<AL_WPTR) obj_align = AL_WPTR;
1713: if (max_align<AL_WPTR) max_align = AL_WPTR;
1714: int waste = byte_offset%AL_WPTR;
1715: if (waste) byte_offset += AL_WPTR-waste; // align
1716: b->ptr_offset = byte_offset+1; // ensure != 0
1717: byte_offset += sizeof(int*);
1718: }
1719: eee:;
1720: }
1721:
1722: real_size = byte_offset; // the rest may be optimized away
1723:
1724: for (b = baselist; b; b = b->next) { // allocate virtual class objects
1725: if (b->base != VIRTUAL) continue;
1726: Pclass bcl = b->bclass;
1727:
1728: // if necessary
1729: if (b->obj_offset = has_allocated_base(bcl)) continue;
1730:
1731: int ba = bcl->align();
1732: if (obj_align<ba) obj_align = ba;
1733: if (max_align<ba) max_align = ba;
1734: int waste = byte_offset%ba;
1735: if (waste) byte_offset += ba-waste; // align
1736: b->obj_offset = byte_offset; // offset in this
1737: b->allocated = 1;
1738: //error('d',"virtual %t in %t at %d",bcl,this,b->obj_offset);
1739: byte_offset += bcl->tsizeof();
1740: }
1741:
1742: // no more data members.
1743: // pad object (so that copying into a base object
1744: // doesn't destroy derevid class members):
1745: if (byte_offset==0) { // empty struct: waste a member
1746: Pname c = new name (make_name('W'));
1747: c->tp = char_type;
1748: (void) c->dcl(memtbl,0);
1749: real_size = byte_offset = 1;
1750: }
1751: if (byte_offset < SZ_STRUCT) byte_offset = SZ_STRUCT;
1752: int waste = byte_offset%max_align;
1753: if (waste) byte_offset += max_align-waste;
1754: obj_size = byte_offset;
1755: obj_align = max_align;
1756:
1757: // make vtbls
1758: // this cannot be done until the bases
1759: // have been allocated in this class
1760: // so that the offsets (deltas) are known
1761: if (all_virt(this,0,1,0)) {
1762: if (has_ctor()==0) make_ctor = 1;
1763: }
1764: else if (has_vvtab)
1765: error("virtualB: conflicting vtable initialization");
1766:
1767: Pname hito = has_itor();
1768:
1769: if (hito) c_xref |= C_XREF; // has user defined X(X&)
1770: //error('d',"%t hito %d ctor %d",this,hito,make_ctor);
1771: if (hito==0 && c_xref&(C_VPTR|C_VBASE|C_XREF)) {
1772: // X(X&) needed if bitwise copy is illegal
1773: // or if any constructor is defined
1774:
1775: hito = make_itor(0);
1776: // if the base has B::B(void)
1777: // the derived should have D::D(void)
1778: if (baselist) {
1779: int mc = 1; // can make and ictor
1780: for (Pbcl b = baselist; b; b = b->next) {
1781: if (b->bclass->has_ctor()
1782: && b->bclass->has_ictor()==0)
1783: mc = 0;
1784: }
1785: make_ctor = mc;
1786: /*
1787: int mc = 1; // can make an ictor
1788: for (Pbcl b = baselist; b; b = b->next) {
1789: if (b->bclass->has_ctor()) {
1790: Pname c = b->bclass->has_ictor();
1791: // no copy constructor?
1792: // non-public copy constructor?
1793: if (c==0 || c->n_scope==0) mc = 0;
1794: }
1795: }
1796: make_ctor = mc;
1797: */
1798: }
1799: else
1800: make_ctor = 1;
1801: }
1802:
1803: if (c_ctor==0 && make_ctor==0) { // can ctor be inherited (from single base class)?
1804: /*
1805: int bb = 0;
1806: for (Pbcl b = baselist; b; b = b->next) {
1807: switch (b->base) {
1808: case NAME:
1809: { Pname c = b->bclass->has_ctor();
1810: // if (b->bclass->has_ctor() == 0) break;
1811: if (c == 0) break;
1812: if (c->n_scope==PUBLIC && bb++==0) break;
1813: }
1814: // no break: two bases: needs ctor
1815: case VIRTUAL:
1816: make_ctor = 1; // virtual base: need ctor
1817: goto zaza;
1818: }
1819: }
1820: */
1821: Pname btor = 0;
1822: Pclass bc = 0;
1823: for (Pbcl b = baselist; b; b = b->next) {
1824: switch (b->base) {
1825: case NAME:
1826: { Pname c = b->bclass->has_ctor();
1827: if (c == 0) break;
1828: if (c->n_scope==PUBLIC && b==baselist) {
1829: bc = b->bclass;
1830: btor = bc->has_ictor();
1831: break;
1832: }
1833: }
1834: // no break: two bases: needs ctor
1835: case VIRTUAL:
1836: make_ctor = 1; // virtual base: need ctor
1837: goto zaza;
1838: }
1839: }
1840: // c_ctor = btor;
1841: //error('d',"btor %n",btor);
1842: if (bc) {
1843: if (btor)
1844: make_ctor = 1;
1845: else
1846: error("K needed for %s, BC%t hasK",string,bc);
1847: }
1848: zaza:;
1849: }
1850:
1851: if (make_ctor && ct==0) { // make x::x() {}
1852: //error('d',"%t: make_ctor",this);
1853: Pname n = new name(string);
1854: Pfct f = new fct(defa_type,0,1);
1855: f->f_inline = 1; // ICTOR; // ICTOR means ``define ctor() if used''
1856: n->tp = f;
1857: n->n_oper = TNAME;
1858: ct = n->dcl(memtbl,PUBLIC);
1859: delete n;
1860: Pfct(ct->tp)->body = /* 0; */ new block(curloc,0,0);
1861: }
1862:
1863: defined |= DEFINED;
1864:
1865: if (ansi_opt) {
1866: char* s = csu==UNION || csu==ANON ? "union" : "struct";
1867: fprintf(out_file,"%s %s;",s,string);
1868: }
1869: //error('d',"defined %s",string);
1870:
1871: // fix argument lists for inlines
1872: for (p=memtbl->get_mem(i=1); p; p=memtbl->get_mem(++i)) {
1873: Pfct f = Pfct(p->tp);
1874: if (f==0) continue; // public declarations
1875:
1876: switch (f->base) {
1877: case FCT:
1878: if (hito && f->argtype) fix_args(f,this);
1879: if (p->n_oper == CTOR) f->s_returns = this_type;
1880: if (f->body) {
1881: p->n_sto = STATIC;
1882: // if (debug_opt) p->dcl_print(0);
1883: }
1884: break;
1885: case OVERLOAD:
1886: { Pgen g = Pgen(f);
1887: for (Plist gl=g->fct_list; gl; gl=gl->l) {
1888: Pname n = gl->f;
1889: Pfct f = Pfct(n->tp);
1890:
1891: if (hito && f->argtype) fix_args(f,this);
1892: if (n->n_oper == CTOR) f->s_returns = this_type;
1893: if (f->body) {
1894: n->n_sto = STATIC;
1895: // if (debug_opt) n->dcl_print(0);
1896: }
1897: }
1898: }
1899: }
1900: }
1901: //error('d',"args_fixed");
1902:
1903: // define members defined inline
1904: for (p=memtbl->get_mem(i=1); p; p=memtbl->get_mem(++i)) {
1905: Pfct f = Pfct(p->tp);
1906: if (f==0) continue; // public declarations
1907:
1908: switch (f->base) {
1909: case FCT:
1910: if (f->body) {
1911: f->dcl(p);
1912: p->simpl();
1913: if (debug_opt) p->dcl_print(0);
1914: }
1915: break;
1916: case OVERLOAD:
1917: { Pgen g = Pgen(f);
1918: for (Plist gl=g->fct_list; gl; gl=gl->l) {
1919: Pname n = gl->f;
1920: Pfct f = Pfct(n->tp);
1921:
1922: if (f->body) {
1923: f->dcl(n);
1924: n->simpl();
1925: if (debug_opt) p->dcl_print(0);
1926: }
1927: }
1928: }
1929: }
1930: }
1931: //error('d',"functions defined");
1932: byte_offset = byte_old;
1933: bit_offset = bit_old;
1934: max_align = max_old;
1935:
1936: cc->unstack(); // friends are not in class scope
1937:
1938: // define friends defined inline and modify return types if necessary
1939: for (Plist fl=friend_list; fl; fl=fl->l) {
1940: Pname p = fl->f;
1941: Pfct f = Pfct(p->tp);
1942:
1943: switch (f->base) {
1944: case FCT:
1945: if (hito && f->argtype) fix_args(f,this);
1946: if (f->body
1947: && (f->defined&(DEFINED|SIMPLIFIED)) == 0) {
1948: p->n_sto = STATIC;
1949: // if (debug_opt) p->dcl_print(0);
1950: }
1951: break;
1952: case OVERLOAD:
1953: { Pgen g = Pgen(f);
1954: for (Plist gl=g->fct_list; gl; gl=gl->l) {
1955: Pname n = gl->f;
1956: Pfct f = Pfct(n->tp);
1957:
1958: if (hito && f->argtype) fix_args(f,this);
1959: if (f->body
1960: && (f->defined&(DEFINED|SIMPLIFIED)) == 0) {
1961: n->n_sto = STATIC;
1962: // if (debug_opt) n->dcl_print(0);
1963: }
1964: }
1965: }
1966: }
1967: }
1968:
1969: // define friends defined inline and modify return types if necessary
1970: for (fl=friend_list; fl; fl=fl->l) {
1971: Pname p = fl->f;
1972: Pfct f = Pfct(p->tp);
1973:
1974: switch (f->base) {
1975: case FCT:
1976: if (f->body
1977: && (f->defined&(DEFINED|SIMPLIFIED)) == 0) {
1978: f->dcl(p);
1979: p->simpl();
1980: if (debug_opt) p->dcl_print(0);
1981: }
1982: break;
1983: case OVERLOAD:
1984: { Pgen g = Pgen(f);
1985: for (Plist gl=g->fct_list; gl; gl=gl->l) {
1986: Pname n = gl->f;
1987: Pfct f = Pfct(n->tp);
1988:
1989: if (f->body
1990: && (f->defined&(DEFINED|SIMPLIFIED)) == 0) {
1991: f->dcl(n);
1992: n->simpl();
1993: if (debug_opt) p->dcl_print(0);
1994: }
1995: }
1996: }
1997: }
1998: }
1999:
2000: if (tbl != gtbl) this->simpl();
2001:
2002: extern Pname statStat;
2003: if ( statStat && strcmp(statStat->string,string)==0) {
2004: //error('d', "classdef::dcl: statstat: %n this %s", statStat, string);
2005: statStat->hide();
2006: statStat = 0;
2007: }
2008: //error('d',"classdef::dcl -> %d",this);
2009: }
2010:
2011: void enumdef::dcl(Pname n, Ptable tbl)
2012: {
2013: // if (this == 0) error('i',"0->enumdef::dcl(%p)",tbl);
2014: Pname px;
2015: Pname p = mem;
2016: // error('d',"enumdef(%n,%d)",n,tbl);
2017: Pbase b = new basetype(EOBJ,n);
2018: b->b_const = 1;
2019:
2020: #define FIRST_ENUM 0
2021: int enum_count = FIRST_ENUM;
2022: no_of_enumerators = mem->no_of_names();
2023: int largest = 0;
2024:
2025: if (p == 0) mem = new name(make_name('e'));
2026:
2027: for (; p; p=px) {
2028: px = p->n_list;
2029: // error( 'd', "p %n", p );
2030: if (p->n_initializer) {
2031: Pexpr i = p->n_initializer->typ(tbl);
2032: Neval = 0;
2033: long ii = i->eval();
2034: if (largest_int<ii) error("long enumerator");
2035: enum_count = int(ii);
2036: if (Neval) error("%s",Neval);
2037: DEL(i);
2038: p->n_initializer = 0;
2039: }
2040: p->n_evaluated = 1;
2041: largest |= enum_count;
2042: p->n_val = enum_count++;
2043: p->tp = b;
2044:
2045: Pname nn = tbl->insert(p,0);
2046: if (Nold) {
2047: if (nn->n_stclass == ENUM) {
2048: // error( (p->n_val!=nn->n_val)?0:'w',"enumerator%n declared twice",nn);
2049: // if (p->n_val!=nn->n_val)
2050: error("enumerator%n declared twice",nn);
2051:
2052: }
2053: else
2054: error("incompatibleDs of%n",nn);
2055: }
2056: else {
2057: nn->n_stclass = ENUM; // no store will be allocated
2058: if (Eppp == PROTECTED)
2059: nn->n_protect = PROTECTED;
2060: else if (Eppp == PUBLIC)
2061: nn->n_scope = PUBLIC;
2062: }
2063: p->string = nn->string;
2064: // delete p;
2065: }
2066:
2067: // mem = 0;
2068:
2069: // chose a shorter representation for the enum?
2070: // if (largest&0133 == largest)
2071: // e_type = char_type;
2072: // else if largest&077777 == largest)
2073: // e_type = short_type;
2074: // else
2075: e_type = int_type;
2076:
2077: defined |= DEFINED;
2078: }
2079:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.