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