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