![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dcl3.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 dcl3.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ptcfront |
1.1 ! root 1: /*ident "@(#)ctrans:src/dcl3.c 1.12" */ ! 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: dcl3.c: ! 11: Routines used by ::dcl fucntions: fct::dcl() etc. ! 12: ! 13: *****************************************************************************/ ! 14: ! 15: #include "cfront.h" ! 16: #include "size.h" ! 17: #include "template.h" ! 18: #include <ctype.h> ! 19: ! 20: static void vbase_pointers(Pname fn, Pclass cl) ! 21: /* ! 22: insert argument for virtual base pointers (if any) ! 23: after f_this and before f_argtype ! 24: */ ! 25: { ! 26: //error('d',"vbase_pointers(%n,%t) %d %k",fn,cl,fn->tp,fn->n_oper); ! 27: Pfct f = Pfct(fn->tp); ! 28: if (fn->n_oper == CTOR) { ! 29: Pname d = 0; ! 30: for (Pbcl b = cl->baselist; b; b=b->next) { ! 31: if (b->base != VIRTUAL) continue; ! 32: Pname a = new name(b->bclass->string); ! 33: a->tp = b->bclass->this_type; ! 34: a->n_list = d; ! 35: a->n_table = f->body ? f->body->memtbl : 0; ! 36: a->where = fn->where; ! 37: d = a; ! 38: } ! 39: ! 40: if (d) { ! 41: for (Pname dd =d;;) { ! 42: if (d->n_list == 0) { ! 43: d->n_list = f->f_args->n_list; ! 44: break; ! 45: } ! 46: d = d->n_list; ! 47: } ! 48: f->f_args->n_list = dd; ! 49: } ! 50: } ! 51: if (fn->n_oper == DTOR) { // add __free argument ! 52: //error('d',"add __free to %n",fn); ! 53: Pname fa = new name; ! 54: fa->tp = int_type; ! 55: fa->n_scope = ARG; ! 56: fa->where = fn->where; ! 57: ! 58: Pname a = f->f_args; ! 59: if (a == 0) ! 60: f->f_args = fa; ! 61: else { ! 62: for(;;a = a->n_list) { ! 63: // error('d',"a %d %t",a,a->tp); ! 64: if (a->n_list == 0) { ! 65: a->n_list = fa; ! 66: break; ! 67: } ! 68: } ! 69: } ! 70: } ! 71: } ! 72: ! 73: void make_res(Pfct f) ! 74: /* ! 75: returns X where X(X&) has been declared ! 76: add "_result" argument of type X* ! 77: */ ! 78: { ! 79: Pname cl = f->returns->is_cl_obj(); ! 80: if (cl==0 || Pclass(cl->tp)->has_itor()==0) return; ! 81: ! 82: Pname rv = new name("_result"); ! 83: rv->tp = f->returns->addrof(); ! 84: rv->n_scope = FCT; // not a ``real'' argument ! 85: rv->n_used = 1; ! 86: rv->n_list = f->argtype; ! 87: if (f->f_this) ! 88: f->f_this->n_list = rv; ! 89: else ! 90: f->f_args = rv; ! 91: f->f_result = rv; ! 92: f->s_returns = void_type; ! 93: } ! 94: ! 95: void name::check_oper(Pname cn) ! 96: /* ! 97: check declarations of operators, ctors, dtors ! 98: */ ! 99: { ! 100: // error('d', "%n->check_oper( %n ): n_oper: %k", this, cn, n_oper ); ! 101: switch (n_oper) { ! 102: case CALL: ! 103: case DEREF: ! 104: case REF: ! 105: if (cn == 0) error("operator%s must be aM",keys[n_oper]); ! 106: break; ! 107: case ASPLUS: ! 108: case ASMINUS: ! 109: case ASMUL: ! 110: case ASDIV: ! 111: case ASMOD: ! 112: case ASAND: ! 113: case ASOR: ! 114: case ASER: ! 115: case ASLS: ! 116: case ASRS: ! 117: if ( warning_opt ) { ! 118: if ( cn == 0 || Pfct(tp)->f_static ) ! 119: error('w', "operator%s should be a non-staticMF",keys[n_oper]); ! 120: } ! 121: break; ! 122: case ASSIGN: ! 123: if (cn == 0) ! 124: error(strict_opt?0:'w',"non-member operator%k() (anachronism)",n_oper); ! 125: break; ! 126: case NOT: /* unary operators only */ ! 127: case COMPL: ! 128: // case INCR: ! 129: // case DECR: ! 130: Pfct f = Pfct(tp); ! 131: if (cn && f->argtype) ! 132: error("%n::%n takes noA",cn, this); ! 133: else if (f->nargs == 2) ! 134: error("%n takes 1A only",this); ! 135: break; ! 136: case INCR: ! 137: case DECR: ! 138: // check for postscript instance ! 139: f = Pfct(tp); ! 140: if (cn) { // member ! 141: if ( f->argtype && f->nargs == 1 ) { ! 142: Pname n = f->argtype; ! 143: if ( n->tp->base != INT ) ! 144: error("%n must takeA ofT int, not %t",this,n->tp); ! 145: } ! 146: } ! 147: else ! 148: if (f->nargs == 2) { // non-member ! 149: Pname n = f->argtype->n_list; ! 150: if ( n->tp->base != INT ) ! 151: error("%n must takeA ofT int, not %t",this,n->tp); ! 152: } ! 153: break; ! 154: ! 155: case 0: ! 156: case TNAME: /* may be a constructor */ ! 157: if (cn && ((strcmp(cn->string,string)==0) || ! 158: ((Pclass(cn->tp)->class_base == ! 159: instantiated_template_class) && ! 160: (strcmp(string, ! 161: Ptclass(cn->tp)->unparametrized_tname()->string) == 0)))) ! 162: { ! 163: if (tp->base == FCT) { ! 164: Pfct f = Pfct(tp); ! 165: if (f->returns!=defa_type) ! 166: error("%s::%s()W returnT",string,string); ! 167: f->returns = void_type; ! 168: string = "__ct"; ! 169: n_oper = CTOR; ! 170: } ! 171: else ! 172: error('s',"struct%nM%n",cn,cn); ! 173: } ! 174: else ! 175: n_oper = 0; ! 176: break; ! 177: case DTOR: /* must be a destructor */ ! 178: //error('d',"dtor %s",string); ! 179: if (cn == 0) { ! 180: n_oper = 0; ! 181: error("destructor ~%s() not inC",string); ! 182: } ! 183: else ! 184: if ((strcmp(cn->string,string) == 0) || ! 185: ((Pclass(cn->tp)->class_base == ! 186: instantiated_template_class) && ! 187: (strcmp(string, ! 188: Ptclass(cn->tp)->unparametrized_tname()->string)==0))) ! 189: { ! 190: dto: ! 191: Pfct f = (Pfct)tp; ! 192: string = "__dt"; ! 193: if (tp->base != FCT) { ! 194: error("%s::~%s notF",cn->string,cn->string); ! 195: tp = new fct(void_type,0,1); ! 196: } ! 197: else if (f->returns!=defa_type/* && f->returns!=void_type*/) { ! 198: if ( f->returns != void_type || ! 199: f->body != 0 || friend_in_class == 0 ) ! 200: error("%s::~%s()W returnT",cn->string,cn->string); ! 201: } ! 202: ! 203: if (f->argtype) { ! 204: error("%s::~%s()WAs",cn->string,cn->string); ! 205: f->nargs = 0; ! 206: f->nargs_known = 1; ! 207: f->argtype = 0; ! 208: } ! 209: f->returns = void_type; ! 210: } ! 211: else { ! 212: if (strcmp(string,"__dt") == 0) goto dto; ! 213: error("~%s in %s",string,cn->string); ! 214: n_oper = 0; ! 215: } ! 216: break; ! 217: case TYPE: ! 218: // cond stores the type of the operator function ! 219: // error('d',"type %t",cond); ! 220: if (cn == 0) { ! 221: // error("operator%t() not aM",Ptype(n_initializer)); ! 222: error("operator%t() not aM",Ptype(cond)); ! 223: n_oper = 0; ! 224: // n_initializer = 0; ! 225: cond = 0; ! 226: } ! 227: else { ! 228: Pfct f = Pfct(tp); ! 229: // n_initializer = 0; ! 230: Ptype tx = Ptype(cond); ! 231: cond = 0; ! 232: if (f->base != FCT) error("badT for%n::operator%t()",cn,tx); ! 233: if (f->returns != defa_type) { ! 234: // if (f->returns->check(tx,0)) error("bad resultT for%n::operator%t()",cn,tx); ! 235: error("resultT for%n::operator%t()",cn,tx); ! 236: DEL(f->returns); ! 237: } ! 238: if (f->argtype) { ! 239: error("%n::operator%t()WAs",cn,tx); ! 240: f->argtype = 0; ! 241: } ! 242: f->returns = tx; ! 243: Pname nx = tx->is_cl_obj(); ! 244: if (nx && can_coerce(tx,cn->tp)) error("both %n::%n(%n) and %n::operator%t()",cn,cn,nx,tx); ! 245: char buf[1024]; ! 246: char* bb = tx->signature(buf); ! 247: int l2 = bb-buf; ! 248: if (1023<l2) error('i',"N::check_oper():N buffer overflow"); ! 249: char* p = new char[l2+5]; ! 250: p[0] = '_'; ! 251: p[1] = '_'; ! 252: p[2] = 'o'; ! 253: p[3] = 'p'; ! 254: strcpy(p+4,buf); ! 255: string = p; ! 256: } ! 257: break; ! 258: } ! 259: } ! 260: ! 261: Pexpr vbase_args(Pfct a, Pname bn) ! 262: /* ! 263: constructor a calls the constructor bn for a base class ! 264: generate argument list needed for virtual base arguments ! 265: */ ! 266: { ! 267: Pfct b = Pfct(bn->tp); ! 268: //error('d',"vbase_args%n: %t %k",bn,b,b->base); ! 269: Pexpr args = 0; ! 270: Pexpr tail = 0; ! 271: if (b->base == OVERLOAD) b = Pfct(Pgen(b)->fct_list->f->tp); // doesn't matter which ! 272: for (Pname d = b->f_args->n_list; d!=b->argtype; d=d->n_list) { ! 273: for (Pname dd = a->f_args->n_list; dd; dd=dd->n_list) ! 274: // using strcmp is a trick ! 275: if (strcmp(dd->string,d->string)==0) break; ! 276: ! 277: Pexpr aa = new expr(ELIST,dd,0); ! 278: if (args == 0) ! 279: args = aa; ! 280: else ! 281: tail->e2 = aa; ! 282: tail = aa; ! 283: } ! 284: return args; ! 285: } ! 286: ! 287: void fct::init_bases(Pclass cl, Pexpr) ! 288: /* ! 289: in "cl"'s constructor "this" generate code to initialize base classes ! 290: and members using the initializers "f->f_init" ! 291: ! 292: this->f_init == list of names of classes to be initialized ! 293: COLON(b) => base class b ! 294: => constructor call in f_init->n_initializer ! 295: COLON() => unnamed base class ! 296: => constructor call in f_init->n_initializer ! 297: NAME(m) => member m ! 298: => constructor call in m->n_initializer ! 299: */ ! 300: { ! 301: Ptable ftbl = body->memtbl; ! 302: DB( if(Ddebug>=1) error('d',"init_bases %t init %d",cl,f_init); ); ! 303: ! 304: // explicit initializers ! 305: if ( cl && cl->csu == UNION && f_init && f_init->n_list ) ! 306: error(&f_init->where,"multipleIrs in unionK %s:: %s",cl->string,cl->string); ! 307: for (Pname nx, nn=f_init; nn; delete nn,(nn=nx) ) { ! 308: Pexpr i = nn->n_initializer; ! 309: nn->n_initializer = 0; ! 310: nx = nn->n_list; ! 311: ! 312: // error('d',"init_base %s %d",nn->string,i); ! 313: if (nn->string) { ! 314: // lookup in case type name hides a "real" member ! 315: { Pname mmm = cl->memtbl->look(nn->string,0); ! 316: if ( mmm ) nn->base = mmm->base; ! 317: } ! 318: if (nn->base == TNAME) { // base class ! 319: char *bn; ! 320: while ( nn->tp && nn->tp->base == TYPE ) ! 321: nn->tp = Pbase(nn->tp)->b_name->tp; ! 322: if ( nn->tp && nn->tp->base == COBJ ) ! 323: bn = Pbase(nn->tp)->b_name->string; ! 324: else ! 325: bn = nn->string; ! 326: for (Pbcl l = cl->baselist; l; l=l->next) { ! 327: Pclass bcl = l->bclass; ! 328: if ((strcmp(bcl->string,bn) == 0) || ! 329: ((bcl->class_base == ! 330: instantiated_template_class) && ! 331: ((strcmp(nn->string, ! 332: Ptclass(bcl)->unparametrized_tname()->string)) == 0))) ! 333: { ! 334: ! 335: // l->init is zeroed out in ctor_simpl ! 336: // if error_count, simpl() not invoked ! 337: if (l->init && error_count == 0) ! 338: error("twoIrs for%t",bcl); ! 339: else ! 340: l->init = base_init(bcl,i,ftbl,l->obj_offset); ! 341: goto con; ! 342: } ! 343: } ! 344: error(&nn->where,"unexpectedAL: noBC%n",nn); ! 345: con: ! 346: continue; ! 347: } ! 348: else { // member initializer ! 349: Pname m = cl->memtbl->look(nn->string,0); ! 350: if (m && m->n_table==cl->memtbl) ! 351: m->n_initializer = mem_init(m,i,ftbl); ! 352: else ! 353: error(&nn->where,"%n not inC %s",nn,cl->string); ! 354: } ! 355: } ! 356: else { // unnamed base class ! 357: Pbcl l = cl->baselist; ! 358: if (l == 0) { ! 359: error("unexpectedAL: noBC called"); ! 360: continue; ! 361: } ! 362: ! 363: if (l->next) { ! 364: bit cnt = 0, rvb = 0; // remote virtual base classes ! 365: for (Pbcl ll = l; ll; ll = ll->next, ++cnt ) ! 366: if (ll->base==VIRTUAL && ll->promoted) ++rvb; ! 367: if ( rvb ) ! 368: error("unnamedBCIr: %dBCes(%d non-explicit virtualBC%s)",cnt,rvb,rvb==1?"":"es"); ! 369: else error("unnamedBCIr: %dBCes",cnt); ! 370: continue; ! 371: } ! 372: ! 373: if (l->init) ! 374: error("twoIrs for%t",l->bclass); ! 375: else { ! 376: error(strict_opt?0:'w',&nn->where,"N ofBC%t missing from BCIr (anachronism)",l->bclass); ! 377: l->init = base_init(l->bclass,i,ftbl,l->obj_offset); ! 378: } ! 379: } ! 380: } // for ! 381: ! 382: for (Pbcl l = cl->baselist; l; l=l->next) { ! 383: // default initialization of base classes ! 384: Pname ctor; ! 385: Pclass bcl = l->bclass; ! 386: if (l->init==0 && (ctor=bcl->has_ctor())) ! 387: l->init = base_init(bcl,0,ftbl,l->obj_offset); ! 388: } ! 389: } ! 390: ! 391: int inline_restr; /* report use of constructs that the inline expanded ! 392: cannot handle here */ ! 393: ! 394: void fct::dcl(Pname n) ! 395: { ! 396: int nmem = TBLSIZE; ! 397: Pname a; ! 398: Pname ll; ! 399: Ptable ftbl; ! 400: ! 401: Pptr cct = 0; ! 402: int const_old = const_save; ! 403: ! 404: int bit_old = bit_offset; ! 405: int byte_old = byte_offset; ! 406: int max_old = max_align; ! 407: ! 408: if (base != FCT) error('i',"F::dcl(%d)",base); ! 409: if (body == 0) error('i',"F::dcl(body=%d)",body); ! 410: if (n==0 || n->base!=NAME) error('i',"F::dcl(N=%d %d)",n,(n)?n->base:0); ! 411: DB( if(Ddebug>=1) error('d',"fct::dcl(%n) %k %d %t",n,n->n_scope,body->own_tbl,this); ); ! 412: if (body->own_tbl) return; // done already ! 413: ! 414: // if (f_inline==0 ) n->n_dcl_printed = 1; // beware of recursive calls, no decl needed ! 415: // if (f_inline && debug_opt) n->n_dcl_printed = 2; ! 416: if (body->memtbl == 0) body->memtbl = new table(nmem+3,gtbl,0); ! 417: body->own_tbl = 1; ! 418: ftbl = body->memtbl; ! 419: ftbl->real_block = body; ! 420: ! 421: max_align = 0;//AL_FRAME; ! 422: bit_offset = 0; ! 423: ! 424: cc->stack(); ! 425: cc->nof = n; ! 426: cc->ftbl = ftbl; ! 427: ! 428: switch (n->n_scope) { ! 429: case 0: ! 430: case PUBLIC: ! 431: { cc->not = n->n_table->t_name; ! 432: cc->cot = Pclass(cc->not->tp); ! 433: cc->tot = cc->cot->this_type; ! 434: // if (f_this==0 || cc->tot==0) error('i',"F::dcl(%n): f_this=%d cc->tot=%d",n,f_this,cc->tot); ! 435: if (f_this) f_this->n_table = ftbl; // fake for inline printout ! 436: cc->c_this = f_this; ! 437: ! 438: ! 439: Pclass cl = Pclass(cc->not->tp); ! 440: ! 441: if (cl->c_body!=3 ! 442: || n->n_initializer ! 443: || n->n_sto==STATIC ! 444: || f_inline ! 445: || f_imeasure ! 446: || f_virtual==0) ! 447: ; ! 448: else { // could be the function where we need to ! 449: // output the vtbl ! 450: int i; ! 451: for (Pname nn=cl->memtbl->get_mem(i=1); nn; nn=cl->memtbl->get_mem(++i) ) { ! 452: Ptype t = nn->tp; ! 453: if (t) ! 454: switch (t->base) { ! 455: case FCT: ! 456: if (nn == n) goto prnt; ! 457: if (nn->n_initializer ! 458: || nn->n_sto==STATIC ! 459: || Pfct(nn->tp)->f_inline ! 460: || Pfct(nn->tp)->f_imeasure ! 461: || Pfct(nn->tp)->f_virtual==0) break; ! 462: goto zaq; ! 463: ! 464: case OVERLOAD: ! 465: { for (Plist gl=Pgen(t)->fct_list; gl; gl=gl->l) { ! 466: Pname nn = gl->f; ! 467: if (nn == n) goto prnt; ! 468: if (nn->n_initializer ! 469: || nn->n_sto==STATIC ! 470: || Pfct(nn->tp)->f_inline ! 471: || Pfct(nn->tp)->f_imeasure ! 472: || Pfct(nn->tp)->f_virtual==0) continue; ! 473: goto zaq; ! 474: } ! 475: } ! 476: } ! 477: } ! 478: goto zaq; ! 479: prnt: ! 480: cl->print_all_vtbls(cl); ! 481: goto zaq; ! 482: } ! 483: } ! 484: } ! 485: zaq: ! 486: // protect against: class x; x f(); class x { x(x&); .... ! 487: if (f_result == 0) make_res(this); ! 488: if (f_result) f_result->n_table = ftbl; // fake for inline printout ! 489: ! 490: returns->tsizeof(); // make sure size is known ! 491: ! 492: Pname ax; ! 493: for (a=argtype, ll=0; a; a=ax) { ! 494: ax = a->n_list; ! 495: Pname nn = a->dcl(ftbl,ARG); ! 496: Pname cn = nn->tp->is_cl_obj(); ! 497: if (cn == 0) cn = cl_obj_vec; ! 498: if (cn) (void)cn->tp->tsizeof(); // make sure it is printed ! 499: nn->n_assigned_to = nn->n_used = nn->n_addr_taken = 0; ! 500: nn->n_list = 0; ! 501: ! 502: switch (nn->tp->base) { ! 503: case CLASS: ! 504: case ENUM: /* unlink types declared in arg list */ ! 505: nn->dcl_print(0); ! 506: break; ! 507: default: ! 508: if (ll) ! 509: ll->n_list = nn; ! 510: else ! 511: f_args = argtype = nn; ! 512: ll = nn; ! 513: } ! 514: delete a; ! 515: } ! 516: ! 517: if (f_result) { // link in f_result ! 518: f_args = f_result; ! 519: f_result->n_list = argtype; ! 520: } ! 521: ! 522: if (f_this) { // link in f_this ! 523: f_args = f_this; ! 524: f_this->n_list = f_result ? f_result : argtype; ! 525: } ! 526: ! 527: if (n->n_oper==CTOR || n->n_oper==DTOR) vbase_pointers(n,cc->cot); ! 528: ! 529: if (n->n_oper == CTOR) { ! 530: const_save = 1; ! 531: init_bases(cc->cot,f_init); ! 532: } ! 533: else if (f_init) ! 534: error(0,"unexpectedAL: not aK"); ! 535: ! 536: PERM(returns); ! 537: const_save = f_inline&&debug_opt==0; ! 538: inline_restr = 0; ! 539: body->dcl(ftbl); ! 540: ! 541: defined |= DEFINED; ! 542: if (f_inline && inline_restr && returns->base!=VOID) { ! 543: f_inline = 0; ! 544: char* s = (inline_restr & 32) ? "continue" ! 545: : (inline_restr & 16) ? "break" ! 546: : (inline_restr & 8) ? "loop" ! 547: : (inline_restr & 4) ? "switch" ! 548: : (inline_restr & 2) ? "goto" ! 549: : (inline_restr & 1) ? "label" ! 550: : "" ; ! 551: if (warning_opt) { ! 552: error('w', "\"inline\" ignored, %n contains %s",n,s); ! 553: error('w', "out-of-line copy of %n created",n); ! 554: } ! 555: // if (cc->cot) ! 556: n->simpl(); //BS6 ! 557: n->dcl_print(0); ! 558: } ! 559: const_save = const_old; ! 560: ! 561: if (f_inline && debug_opt==0) isf_list = new name_list(n,isf_list); ! 562: ! 563: bit_offset = bit_old; ! 564: byte_offset = byte_old; ! 565: max_align = max_old; ! 566: cc->unstack(); ! 567: ! 568: //error('d',"fct-> returns %t",returns); ! 569: } ! 570: ! 571: Pexpr fct::base_init(Pclass bcl, Pexpr i, Ptable ftbl, int offset) ! 572: /* ! 573: have base class bcl and expr list i ! 574: return "( *(base*)this ) . ctor( i )" ! 575: ctor call generated in expr.typ() ! 576: */ ! 577: { ! 578: Ptype ty = bcl->this_type; ! 579: Pexpr th = rptr(ty,f_this,offset); // base* ! 580: Pname ctor = bcl->has_ctor(); ! 581: ! 582: //error('d',"fct::B_init(C %t, i %d, %d) ctor %n",bcl,i,i?i->tp:0,ctor); ! 583: ! 584: Pexpr ii = (i && i->base==ELIST)?i->e1:i; ! 585: ! 586: if (ii ! 587: && ii->base==DEREF ! 588: && ii->e1->base==CAST ! 589: && th->base==CAST) th->i2 = ii->e1->i2; ! 590: ! 591: if (ctor == 0) { ! 592: if (i && i->base!=ELIST) i = new expr(ELIST,i,0); ! 593: ! 594: Pexpr v = new texpr(VALUE,bcl,i); // ?.base(i) ! 595: v->e2 = new expr(DEREF,th,0); // (*(base*)this).base(i) ! 596: v = v->typ(ftbl); // *base(&*(base*)this,i) ! 597: //error('d',"v %k",v->base); ! 598: switch (v->base) { ! 599: case DEREF: ! 600: return v->e1; // base(&*(base*)this,i) ! 601: case ASSIGN: // degenerate base(base&): *(base*)this=i ! 602: th = new texpr(CAST,ty,f_this); ! 603: v = new expr(CM,v,th); // (*(base*)this=i,(base*)this); ! 604: return v->typ(ftbl); ! 605: default: ! 606: return 0; ! 607: } ! 608: } ! 609: ! 610: ! 611: Pname icn; ! 612: if (i) { ! 613: ii = ii->typ(ftbl); ! 614: if (bcl->has_itor()==0 ! 615: && (icn=ii->tp->is_cl_obj()) ! 616: && (Pclass(icn->tp)==bcl || Pclass(icn->tp)->has_base(bcl))) { ! 617: // degenerate base(base&): *(base*)this=i ! 618: // memberwise copy ! 619: //error('d',"copy %t",ty); ! 620: // th = new cast(ty,f_this); ! 621: // th = th->contents(); ! 622: th = new texpr(CAST,ty,f_this); ! 623: th = th->contents(); ! 624: th = th->typ(ftbl); ! 625: if (Pclass(icn->tp)!=bcl) { // cast needed ! 626: Pptr r = new ptr(RPTR,Pptr(ty)->typ); ! 627: ii = new texpr(CAST,r,ii); ! 628: ii = ii->typ(ftbl); ! 629: } ! 630: ii = new expr(ASSIGN,th,ii); ! 631: ii->tp = th->tp; ! 632: // simulate `return this': ! 633: // *(base*)this=i,(base*)this ! 634: ii = new expr(CM,ii,new cast(ty,f_this)); ! 635: ii->tp = th->tp; ! 636: return ii; ! 637: // return ii->typ(ftbl); // don't find cl::operator=() ! 638: } ! 639: if (i->base == ELIST) i->e1 = ii; ! 640: } ! 641: //Pexpr x = call_ctor(ftbl,th,ctor,i,REF,vbase_args(this,ctor)); ! 642: //error('d',"call %n %t -> %d %k",ctor,ctor->tp,x,x->base); ! 643: // return x; ! 644: return call_ctor(ftbl,th,ctor,i,REF,vbase_args(this,ctor)); ! 645: } ! 646: ! 647: ! 648: Pexpr fct::mem_init(Pname mn, Pexpr i, Ptable ftbl) ! 649: /* ! 650: return "member_ctor( m, i )" ! 651: */ ! 652: { ! 653: // a new entry for B::B_pub, in general, has no tp and no ! 654: // real info: all the tp-> only work on our systems because ! 655: // 0 pointer dereference isn't system memory. it core dumps ! 656: // in set_const since no test is made on this == 0. ! 657: //error('d',"mem_init %n",mn); ! 658: ! 659: // if (mn->n_stclass == STATIC) error('s',"MIr for static%n",mn); ! 660: switch (mn->n_stclass) { ! 661: case STATIC: ! 662: error("MIr for static%n",mn); ! 663: break; ! 664: case ENUM: ! 665: error("MIr for enumeration constant%n", mn); ! 666: break; ! 667: } ! 668: ! 669: Pname member = (mn->base==PUBLIC && mn->n_qualifier) ? mn->n_qualifier : mn; ! 670: ! 671: if (i) i = i->typ(ftbl); ! 672: Pname cn = member->tp->is_cl_obj(); // first find the class name ! 673: ! 674: // if (member->n_stclass == STATIC) error('s',"MIr for static%n",member); ! 675: // if (i) i = i->typ(ftbl); ! 676: // Pname cn = member->tp->is_cl_obj(); // first find the class name ! 677: Pref tn = new ref(REF,f_this,member); ! 678: tn->tp = member->tp; ! 679: //error('d',"MI for %n %t = %t",member,member->tp,i?i->tp:0); ! 680: //error('d',"fthis %d %t member %n tp %t",f_this,f_this->tp,member,tn->tp); ! 681: if (cn) { ! 682: Pclass mcl = Pclass(cn->tp); // then find the classdef ! 683: Pname ctor = mcl->has_ctor(); ! 684: Pname icn; ! 685: ! 686: if (i ! 687: && mcl->has_itor()==0 ! 688: && (icn=i->tp->is_cl_obj()) ! 689: && Pclass(icn->tp)==mcl) { // bitwise copy ! 690: Pexpr init = new expr(ASSIGN,tn,i); ! 691: init->tp = tn->tp; ! 692: // return init->typ(ftbl); // don't look for mcl.operator=() ! 693: member->assign(); ! 694: return init; ! 695: } ! 696: ! 697: if (ctor) return call_ctor(ftbl,tn,ctor,i,DOT); ! 698: ! 699: error("Ir forM%nW noK",member); ! 700: return 0; ! 701: } ! 702: ! 703: if (cl_obj_vec) { ! 704: if (i && i->base == ELIST) ! 705: error("illegalIrL for %t%nWinM initializationL",mn->tp,mn); ! 706: else error('s',"Ir forCM %t%nWK",mn->tp,mn); ! 707: return 0; ! 708: } ! 709: ! 710: if (i && i->base == ELIST) { ! 711: if (i->e2) error("Ir for%n not a simpleE",member); ! 712: i = i->e1; ! 713: } ! 714: ! 715: if (member->tp->is_ref() && (i == 0)) { ! 716: error("empty Ir for reference %n", member); ! 717: return 0 ; ! 718: } ! 719: ! 720: // error( 'd', "fct_mem_init: %n %k", member, member->tp->base ); ! 721: switch (member->tp->base) { ! 722: // case RPTR: ! 723: // if ( i == 0 ) { ! 724: // error( "empty Ir for reference %n", member ); ! 725: // return 0; ! 726: // } ! 727: // break; ! 728: case VEC: ! 729: case FCT: ! 730: case OVERLOAD: ! 731: error("Ir for%n ofT %t",member,member->tp); ! 732: return 0; ! 733: } ! 734: ! 735: //error('d',"tp %t",member->tp); ! 736: if (member->tp->tconst()) { ! 737: int save_ignore_const = ignore_const; ! 738: ignore_const = 1; ! 739: i = new expr(ASSIGN,tn,i); ! 740: i = i->typ(ftbl); ! 741: ignore_const = save_ignore_const; ! 742: return i; ! 743: } ! 744: ! 745: Pptr pt; ! 746: if (pt = member->tp->is_ref()) { ! 747: switch (pt->typ->base) { ! 748: case FCT: ! 749: case OVERLOAD: ! 750: i = ptr_init(pt,i,ftbl); ! 751: break; ! 752: default: ! 753: i = ref_init(pt,i,ftbl); ! 754: } ! 755: i = new expr(ASSIGN,tn,i); ! 756: i->tp = tn->tp; ! 757: member->assign(); // cannot call typ: would cause dereference ! 758: return i; ! 759: } ! 760: ! 761: i = new expr(ASSIGN,tn,i); ! 762: return i->typ(ftbl); // typ performs the type check on the assignment ! 763: } ! 764: ! 765: Pexpr replace_temp(Pexpr e, Pexpr n) ! 766: /* ! 767: e is on the form ! 768: f(&temp,arg) , temp ! 769: or ! 770: &temp->ctor(arg) , temp ! 771: or ! 772: x->f(&temp,arg) , temp ! 773: change it to ! 774: f(n,arg) ! 775: or ! 776: n->ctor(arg) ! 777: */ ! 778: { ! 779: Pexpr c = e->e1; // f(&temp,arg) or &temp->ctor(args) ! 780: Pexpr ff = c->e1; ! 781: Pexpr a = c->e2; // maybe ELIST(&temp,arg) ! 782: Pexpr tmp = e->e2; ! 783: ! 784: //error('d',"suppress(%d %k) %n",tmp->base,tmp->base,tmp->base==NAME?tmp:0); ! 785: if (tmp->base==DEREF) tmp = tmp->e1; ! 786: if (tmp->base==CAST) tmp = tmp->e1; ! 787: if (tmp->base==ADDROF || tmp->base==G_ADDROF) tmp = tmp->e2; ! 788: if (tmp->base != NAME) return e; //error('i',"replace %k",tmp->base); ! 789: tmp->tp = any_type; // temporary not used: suppress it ! 790: ! 791: //error('d',"replace_temp(%k %k) c %k ff %k",e->base,n->base,c->base,ff->base); ! 792: switch (ff->base) { ! 793: case REF: ! 794: if (ff->e1->base==G_ADDROF && ff->e1->e2==tmp) ! 795: a = ff; // &tmp -> f() ! 796: break; ! 797: case DOT: ! 798: if (ff->e1->base==NAME && ff->e1==tmp) { ! 799: a = ff; // tmp . f() ! 800: a->base = REF; ! 801: } ! 802: break; ! 803: } ! 804: a->e1 = n; ! 805: return c; ! 806: } ! 807: ! 808: Pname classdef::has_ictor() ! 809: /* ! 810: does this class have a constructor taking no arguments? ! 811: */ ! 812: { ! 813: Pname c = has_ctor(); ! 814: if (c == 0) return 0; ! 815: ! 816: Pfct f = Pfct(c->tp); ! 817: ! 818: switch (f->base) { ! 819: default: ! 820: error('i',"%s: badK (%k)",string,c->tp->base); ! 821: ! 822: case FCT: ! 823: switch (f->nargs) { ! 824: case 0: return c; ! 825: default: if (f->argtype->n_initializer) return c; ! 826: } ! 827: return 0; ! 828: ! 829: case OVERLOAD: ! 830: { for (Plist l=Pgen(f)->fct_list; l; l=l->l) { ! 831: Pname n = l->f; ! 832: f = (Pfct)n->tp; ! 833: switch (f->nargs) { ! 834: case 0: return n; ! 835: default: if (f->argtype->n_initializer) return n; ! 836: } ! 837: } ! 838: return 0; ! 839: } ! 840: } ! 841: } ! 842: ! 843: int add_first; // fudge, use ctor arg instead ! 844: Pname gen::add(Pname n) ! 845: /* ! 846: add "n" to the tail of "fct_list" ! 847: (overloaded names are searched in declaration order) ! 848: ! 849: detect: multiple identical declarations ! 850: declaration after use ! 851: multiple definitions ! 852: */ ! 853: { ! 854: Pfct f = Pfct(n->tp); ! 855: Pname nx; ! 856: //error('d',"add(%n) %d",n,add_first); ! 857: if (f->base != FCT) error("%n: overloaded nonF",n); ! 858: ! 859: if ( fct_list && (nx=find(f,1)) ) { ! 860: //error('d',"found %n %t",nx,nx->tp); ! 861: Linkage l1 = Pfct(nx->tp)->f_linkage; ! 862: Linkage l2 = f->f_linkage; ! 863: if ( l2 != linkage_default && l1 != l2 ) ! 864: error("inconsistent linkage specifications for%n",n); ! 865: Nold = 1; ! 866: } ! 867: else { ! 868: if (add_first==0 && f->f_signature==0) f->sign(); ! 869: //error('d',"signature: %d \"%s\" fct_list %d",f->f_signature,f->f_signature,fct_list); ! 870: nx = new name; ! 871: *nx = *n; ! 872: // nx->n_tbl_list = Pname(n->string); ! 873: nx->n_gen_fct_name = n->string; ! 874: PERM(nx); ! 875: Nold = 0; ! 876: if (fct_list) { ! 877: int clink = (f->f_linkage==linkage_C); ! 878: Plist gl=fct_list; ! 879: for(;;) { ! 880: if (clink ! 881: && Pfct(gl->f->tp)->f_linkage == linkage_C ) { ! 882: error("two%ns with c linkage",n); ! 883: if(f->f_signature==0) f->sign(); ! 884: } ! 885: if (gl->l) ! 886: gl = gl->l; ! 887: else ! 888: break; ! 889: } ! 890: gl->l = new name_list(nx,0); ! 891: } ! 892: else ! 893: fct_list = new name_list(nx,0); ! 894: nx->n_list = 0; ! 895: } ! 896: return nx; ! 897: } ! 898: ! 899: void fct::sign() ! 900: { ! 901: switch ( f_linkage ) { ! 902: case linkage_C: ! 903: f_signature = ""; ! 904: return; ! 905: case linkage_Cplusplus: ! 906: case linkage_default: ! 907: break; ! 908: } ! 909: char buf[1024]; ! 910: char* bb = signature(buf); ! 911: int ll = bb-buf; ! 912: if (1023 < ll) error('i',"gen::add():N buffer overflow"); ! 913: char* p = new char[ll+1]; ! 914: strcpy(p,buf); ! 915: f_signature = p; ! 916: //error('d',"fct::sign %s",p); ! 917: } ! 918: ! 919: Pname gen::find(Pfct f, bit warn) ! 920: { ! 921: for (Plist gl=fct_list; gl; gl=gl->l) { ! 922: Pname n = match(gl->f,f,warn); ! 923: if (n) return n; ! 924: } ! 925: return 0; ! 926: } ! 927: ! 928: Pname gen::match(Pname nx, Pfct f, bit warn) ! 929: { ! 930: Pfct fx = Pfct(nx->tp); ! 931: Pname a, ax; ! 932: int op = 0; // overloading problem: const, ref, vec/ptr, or basetype ! 933: //error('d',"fx %d %d f %d %d",fx->nargs_known,fx->nargs,f->nargs_known,f->nargs); ! 934: ! 935: if (f->nargs_known != fx->nargs_known) return 0; // the bets are off ! 936: // must rely on checks at ! 937: // call points ! 938: if (f->f_const != fx->f_const) return 0; ! 939: ! 940: if (fx->nargs != f->nargs ! 941: && fx->nargs_known==1 ! 942: && f->nargs_known==1) return 0; // no warning for potential ! 943: // problems due to default args ! 944: ! 945: for (ax=fx->argtype, a=f->argtype; a&&ax; ax=ax->n_list, a=a->n_list) { ! 946: Ptype at = ax->tp; ! 947: Ptype atp = a->tp; ! 948: //error('d',"at %t atp %t",at,atp); ! 949: if (at->check(atp,OVERLOAD) == 0) { ! 950: //error('d',"at %t atp %t cp %d vrp %d",at,atp,const_problem,vrp_equiv); ! 951: continue; ! 952: } ! 953: //error('d',"warn %d",warn); ! 954: if (warn == 0) goto xx; ! 955: ! 956: /* ! 957: warn against: ! 958: overload f(X&), f(X); error ! 959: overload f(int), f(const); error ! 960: overload f(int*), f(int[10]); warn ! 961: etc. ! 962: */ ! 963: ! 964: //error('d',"vrp_equiv %d const_problem %d",vrp_equiv,const_problem); ! 965: if (const_problem) { // differ only in X vs const X ! 966: if (at->is_ptr_or_ref()) return 0; ! 967: op++; ! 968: continue; ! 969: } ! 970: ! 971: aaa: ! 972: switch (atp->base) { ! 973: case TYPE: ! 974: atp = Pbase(atp)->b_name->tp; ! 975: goto aaa; ! 976: // case EOBJ: ! 977: // atp = Penum(Pbase(atp)->b_name->tp)->e_type; ! 978: // goto aaa; ! 979: case RPTR: // differ only by X vs X& ? ! 980: if (Pptr(atp)->typ->check(at,0)==0) { ! 981: op++; ! 982: continue; ! 983: } ! 984: } ! 985: ! 986: atl: ! 987: switch (at->base) { ! 988: case TYPE: ! 989: at = Pbase(at)->b_name->tp; ! 990: goto atl; ! 991: // case EOBJ: ! 992: // at = Penum(Pbase(at)->b_name->tp)->e_type; ! 993: // goto atl; ! 994: case RPTR: // differ only by X& vs X ? ! 995: if (Pptr(at)->typ->check(atp,0)==0) { ! 996: op++; ! 997: continue; ! 998: } ! 999: break; ! 1000: // case CHAR: // differ only by int vs char ? ! 1001: // case SHORT: ! 1002: // case INT: ! 1003: // if (atp->base!=at->base && atp->base==EOBJ) { ! 1004: // op++; ! 1005: // continue; ! 1006: // } ! 1007: // break; ! 1008: } ! 1009: //error('d',"return 0"); ! 1010: //goto xx; ! 1011: // some argument is really different ! 1012: // e.g. f(int), f(char*); ! 1013: return 0; ! 1014: } ! 1015: ! 1016: // arguments checked. Now look at leftover args, return type,etc. ! 1017: ! 1018: // if (warn && a && fx->nargs_known==ELLIPSIS) error('w',"... in%n'sAT hidesATs from the overloading mechanism",nx); ! 1019: ! 1020: if (a || ax) return 0; ! 1021: ! 1022: if (op == 0) { ! 1023: if (warn && fx->returns->check(f->returns,0)) ! 1024: error("two different return valueTs for%n: %t and %t",nx,fx->returns,f->returns); ! 1025: ! 1026: return nx; ! 1027: } ! 1028: xx: ! 1029: if (warn && op) ! 1030: error("the overloading mechanism cannot tell a%t from a%t",fx,f); ! 1031: ! 1032: return 0; ! 1033: } ! 1034: ! 1035: int name::no_of_names() ! 1036: { ! 1037: register int i = 0; ! 1038: register Pname n; ! 1039: for (n=this; n; n=n->n_list) i++; ! 1040: return i; ! 1041: } ! 1042: ! 1043: static Pexpr lvec[20], *lll, *curr_e; ! 1044: static Pexpr last_il = 0; ! 1045: static Pexpr list_back = 0; ! 1046: static Pexpr last_el = 0, *last_lll; ! 1047: ! 1048: void new_list(Pexpr lx) ! 1049: { ! 1050: if (lx->base != ILIST) error('i',"IrLX"); ! 1051: ! 1052: lll = last_lll = lvec; ! 1053: lll++; ! 1054: *lll = last_el = lx->e1; ! 1055: } ! 1056: ! 1057: Pexpr next_elem() ! 1058: { ! 1059: Pexpr e; ! 1060: Pexpr lx; ! 1061: ! 1062: if (lll == lvec) return 0; ! 1063: ! 1064: lx = *lll; ! 1065: ! 1066: if (list_back) { ! 1067: e = list_back; ! 1068: list_back = 0; ! 1069: return e; ! 1070: } ! 1071: ! 1072: if (lx == 0) { /* end of list */ ! 1073: lll--; ! 1074: return 0; ! 1075: } ! 1076: ! 1077: switch (lx->base) { ! 1078: case ELIST: ! 1079: e = lx->e1; ! 1080: curr_e = &lx->e1; ! 1081: last_el = lx; ! 1082: last_lll = lll; ! 1083: *lll = lx->e2; ! 1084: switch (e->base) { ! 1085: case ILIST: ! 1086: lll++; ! 1087: *lll = e->e1; ! 1088: last_il = e; ! 1089: return Pexpr(1); // start of new ILIST ! 1090: case ELIST: ! 1091: error("nestedEL"); ! 1092: return 0; ! 1093: default: ! 1094: { ! 1095: if (need_sti(e)) error('s',"generalIr inIrL"); ! 1096: return e; ! 1097: } ! 1098: } ! 1099: case IVAL: ! 1100: case ZERO: ! 1101: lll--; ! 1102: return 0; ! 1103: default: ! 1104: error('i',"IrL %k",lx->base); ! 1105: } ! 1106: } ! 1107: ! 1108: static Pexpr insert_init(Pexpr newval) { ! 1109: // splice an initializer in front of the next element in the ! 1110: // initializer list. Provides initializers for unnamed bitfields. ! 1111: Pexpr t = new expr(ELIST,last_el->e1,last_el->e2); ! 1112: ! 1113: last_el->e1=newval; ! 1114: last_el->e2=t; ! 1115: lll = last_lll; ! 1116: *lll = last_el; ! 1117: return next_elem(); ! 1118: } ! 1119: ! 1120: void skip_ilist() ! 1121: // skip ilist use to represent pointer to member function literal ! 1122: { ! 1123: Pexpr e = next_elem(); ! 1124: e = next_elem(); ! 1125: } ! 1126: ! 1127: void list_check(Pname nn, Ptype t, Pexpr il, Ptable tbl) ! 1128: /* ! 1129: see if the list "lll" can be assigned to something of type "t" ! 1130: "nn" is the name of the variable for which the assignment is taking place. ! 1131: "il" is the last list element returned by next_elem() ! 1132: */ ! 1133: { ! 1134: Pexpr e; ! 1135: bit lst = 0; ! 1136: int i; ! 1137: Pclass cl; ! 1138: int tdef = 0; ! 1139: ! 1140: //error('d',"list_check%n: %t (%d)",nn,t,il); ! 1141: if (il == Pexpr(1)) { ! 1142: lst = 1; ! 1143: e = il; ! 1144: } ! 1145: else if (il) ! 1146: list_back = il; ! 1147: ! 1148: zzz: ! 1149: switch (t->base) { ! 1150: case TYPE: ! 1151: t = Pbase(t)->b_name->tp; ! 1152: tdef = 1; ! 1153: ! 1154: // did it used to be a VEC before arg_fudge was applied? ! 1155: if (t->base==PTR && Pvec(t)->size) ! 1156: t->base=VEC; ! 1157: goto zzz; ! 1158: ! 1159: case VEC: ! 1160: { Pvec v = Pvec(t); ! 1161: Ptype vt = v->typ; ! 1162: ! 1163: if (v->size) { /* get at most v->size initializers */ ! 1164: if (v->typ->base == CHAR) { ! 1165: e = next_elem(); ! 1166: if (e->base == STRING) { // v[size] = "..." ! 1167: int isz = Pvec(e->tp)->size; ! 1168: if (v->size < isz) error("Ir too long (%d characters) for%n[%d]",isz,nn,v->size); ! 1169: break; ! 1170: } ! 1171: else ! 1172: list_back = e; ! 1173: } ! 1174: for (i=0; i<v->size; i++) { // check next list element type ! 1175: Pfct MP = 0; ! 1176: ee: ! 1177: e = next_elem(); ! 1178: if (e == 0) goto xsw; // too few initializers are ok ! 1179: vtz: ! 1180: //error('d',"vtz: %d",vt->base); ! 1181: switch (vt->base) { ! 1182: case TYPE: ! 1183: vt = Pbase(vt)->b_name->tp; ! 1184: goto vtz; ! 1185: case VEC: ! 1186: case COBJ: ! 1187: list_check(nn,vt,e); ! 1188: break; ! 1189: case PTR: ! 1190: if ((MP = vt->memptr()) && ! 1191: e==Pexpr(1)) { ! 1192: if (vt->check(last_il->tp,ASSIGN)) ! 1193: error("badIrT for%n:%t (%tX)",v,last_il->tp,vt); ! 1194: skip_ilist(); ! 1195: break; ! 1196: } ! 1197: if (MP && e && e->base==ZERO) { ! 1198: *curr_e = new expr(ELIST,zero,zero); ! 1199: *curr_e = new expr(ILIST,*curr_e,zero); ! 1200: (*curr_e)->tp = zero_type; ! 1201: break; ! 1202: } ! 1203: if (MP && e && e->tp->base==OVERLOAD) { ! 1204: Pexpr op = ptof(Pfct(Pptr(vt)->typ),e,tbl); ! 1205: if(op) { ! 1206: *curr_e = op; ! 1207: break; ! 1208: } ! 1209: } ! 1210: // no break ! 1211: default: ! 1212: { ! 1213: if (e == (Pexpr)1) { ! 1214: error("unexpectedIrL"); ! 1215: goto ee; ! 1216: } ! 1217: ! 1218: if (vt->check(e->tp,ASSIGN)) ! 1219: error("badIrT for%n:%t (%tX)",nn,e->tp,vt); ! 1220: ! 1221: Pptr p; ! 1222: if (vt->check(e->tp,0) ! 1223: && (p=vt->is_ptr()) ! 1224: && Ptype(p)!=zero_type ! 1225: && p->typ!=char_type) { ! 1226: Pexpr te = e; ! 1227: Ptype t = p->typ; ! 1228: while ( t->base == TYPE ) t = Pbase(t)->b_name->tp; ! 1229: if ( t->base == COBJ ) ! 1230: te = ptr_init( p, e, tbl ); ! 1231: if ( te == e ) ! 1232: *curr_e = new cast(vt,e); ! 1233: else *curr_e = te; ! 1234: } ! 1235: } ! 1236: } ! 1237: } ! 1238: if ( lst && (e=next_elem()) ) error("end ofIrLX after array"); ! 1239: xsw:; ! 1240: } ! 1241: else { /* determine v->size */ ! 1242: i = 0; ! 1243: (void) v->typ->tsizeof(); ! 1244: xx: ! 1245: while ( e=next_elem() ) { // get another initializer ! 1246: Pfct MP = 0; ! 1247: i++; ! 1248: vtzz: ! 1249: //error('d',"vtzz"); ! 1250: switch (vt->base) { ! 1251: case TYPE: ! 1252: vt = Pbase(vt)->b_name->tp; ! 1253: goto vtzz; ! 1254: case VEC: ! 1255: case COBJ: ! 1256: list_check(nn,vt,e); ! 1257: break; ! 1258: case PTR: ! 1259: if((MP = vt->memptr()) && ! 1260: e==Pexpr(1)) { ! 1261: if (vt->check(last_il->tp,ASSIGN)) ! 1262: error("badIrT for%n:%t (%tX)",v,last_il->tp,vt); ! 1263: skip_ilist(); ! 1264: break; ! 1265: } ! 1266: if (MP && e && e->base==ZERO) { ! 1267: *curr_e = new expr(ELIST,zero,zero); ! 1268: *curr_e = new expr(ILIST,*curr_e,zero); ! 1269: (*curr_e)->tp = zero_type; ! 1270: break; ! 1271: } ! 1272: if (MP && e && e->tp->base==OVERLOAD) { ! 1273: Pexpr op = ptof(Pfct(Pptr(vt)->typ),e,tbl); ! 1274: if(op) { ! 1275: *curr_e = op; ! 1276: break; ! 1277: } ! 1278: } ! 1279: // no break ! 1280: default: ! 1281: { if (e == Pexpr(1)) { ! 1282: error("unexpectedIrL"); ! 1283: goto xx; ! 1284: } ! 1285: ! 1286: if (vt->check(e->tp,ASSIGN)) ! 1287: error("badIrT for%n:%t (%tX)",nn,e->tp,vt); ! 1288: ! 1289: Pptr p; ! 1290: if (vt->check(e->tp,0) ! 1291: && (p=vt->is_ptr()) ! 1292: && Ptype(p)!=zero_type ! 1293: && p->typ!=char_type) { ! 1294: Pexpr te = e; ! 1295: Ptype t = p->typ; ! 1296: while ( t->base == TYPE ) t = Pbase(t)->b_name->tp; ! 1297: if ( t->base == COBJ ) ! 1298: te = ptr_init( p, e, tbl ); ! 1299: if ( te == e ) ! 1300: *curr_e = new cast(vt,e); ! 1301: else *curr_e = te; ! 1302: } ! 1303: } ! 1304: } ! 1305: } ! 1306: if (tdef==0) v->size = i; ! 1307: } ! 1308: break; ! 1309: } ! 1310: ! 1311: case CLASS: ! 1312: cl = Pclass(t); ! 1313: goto ccc; ! 1314: ! 1315: case COBJ: /* initialize members */ ! 1316: cl = Pclass(Pbase(t)->b_name->tp); ! 1317: ccc: ! 1318: if (cl->defined == 0) { ! 1319: lll = lvec; // we are lost: ignore rest of list ! 1320: return; ! 1321: } ! 1322: ! 1323: if (cl->c_body == 1) cl->dcl_print(0); ! 1324: ! 1325: { Ptable tbl = cl->memtbl; ! 1326: Pname m; ! 1327: ! 1328: if (cl->baselist) { ! 1329: if (cl->baselist->next) error("IrL forO ofC with multipleBCs"); ! 1330: list_check(nn,cl->baselist->bclass,0); ! 1331: } ! 1332: ! 1333: for (m=tbl->get_mem(i=1); m; m=tbl->get_mem(++i)) { ! 1334: Ptype mt = m->tp; ! 1335: Pfct MP = 0; ! 1336: switch (mt->base) { ! 1337: case FCT: ! 1338: case OVERLOAD: ! 1339: case CLASS: ! 1340: case ENUM: ! 1341: continue; ! 1342: } ! 1343: if (m->n_stclass == STATIC || ! 1344: m->n_stclass == ENUM ) continue; ! 1345: /* check assignment to next member */ ! 1346: dd: ! 1347: while (mt->base == TYPE) ! 1348: mt = Pbase(mt)->b_name->tp; ! 1349: ! 1350: if ((MP = mt->memptr()) && ! 1351: e==Pexpr(1) && ! 1352: last_il->tp->base == PTR) { ! 1353: if(i==1) lst=0; ! 1354: } ! 1355: else e = next_elem(); ! 1356: ! 1357: if (e == 0) return; //break; ! 1358: ! 1359: if( ! 1360: mt->base == FIELD ! 1361: && ! 1362: m->string[0]=='_' ! 1363: && ! 1364: m->string[1]=='_' ! 1365: && ! 1366: m->string[2]=='F' // unnamed bitfield ! 1367: ) { ! 1368: e = insert_init(zero); ! 1369: } ! 1370: ! 1371: //error('d',"mtz%n: %d",m,mt->base); ! 1372: switch (mt->base) { ! 1373: case CLASS: ! 1374: case ENUM: ! 1375: break; ! 1376: case VEC: ! 1377: case COBJ: ! 1378: list_check(nn,m->tp,e); ! 1379: break; ! 1380: case PTR: ! 1381: if (MP && e==Pexpr(1)) { ! 1382: if (mt->check(last_il->tp,ASSIGN)) ! 1383: error("badIrT for%n:%t (%tX)",m,last_il->tp,mt); ! 1384: skip_ilist(); ! 1385: break; ! 1386: } ! 1387: if (MP && e && e->base==ZERO) { ! 1388: *curr_e = new expr(ELIST,zero,zero); ! 1389: *curr_e = new expr(ILIST,*curr_e,zero); ! 1390: (*curr_e)->tp = zero_type; ! 1391: break; ! 1392: } ! 1393: if (MP && e && e->tp->base==OVERLOAD) { ! 1394: Pexpr op = ptof(Pfct(Pptr(mt)->typ),e,tbl); ! 1395: if(op) { ! 1396: *curr_e = op; ! 1397: break; ! 1398: } ! 1399: } ! 1400: // no break ! 1401: default: ! 1402: { if (e == Pexpr(1)) { ! 1403: error("unexpectedIrL"); ! 1404: goto dd; ! 1405: } ! 1406: ! 1407: if (mt->check(e->tp,ASSIGN)) ! 1408: error("badIrT for%n:%t (%tX)",m,e->tp,m->tp); ! 1409: ! 1410: if(MP && e && e->base==CAST) ! 1411: *curr_e = e->e1; ! 1412: ! 1413: Pptr p; ! 1414: if (mt->check(e->tp,0) ! 1415: && (p=mt->is_ptr()) ! 1416: && Ptype(p)!=zero_type ! 1417: && p->typ!=char_type) ! 1418: *curr_e = new cast(mt,e); ! 1419: } ! 1420: } ! 1421: } ! 1422: if (lst && (e=next_elem()) ) error("end ofIrLX afterCO"); ! 1423: break; ! 1424: } ! 1425: default: ! 1426: e = next_elem(); ! 1427: ! 1428: if (e == 0) { ! 1429: error("noIr forO"); ! 1430: break; ! 1431: } ! 1432: ! 1433: if (e == Pexpr(1)) { ! 1434: error("unexpectedIrL"); ! 1435: break; ! 1436: } ! 1437: //error('d',"t %t e->tp %t",t,e->tp); ! 1438: if (t->check(e->tp,ASSIGN)) error("badIrT for%n:%t (%tX)",nn,e->tp,t); ! 1439: Pptr p; ! 1440: if (t->check(e->tp,0) ! 1441: && (p=t->is_ptr()) ! 1442: && Ptype(p)!=zero_type ! 1443: && p->typ!=char_type) ! 1444: *curr_e = new cast(t,e); ! 1445: if (lst && (e=next_elem()) ) error("end ofIrLX afterO"); ! 1446: break; ! 1447: } ! 1448: } ! 1449: ! 1450: int ! 1451: is_anon(char* string) { ! 1452: // error('d',"is_anon: %s", string ); ! 1453: if ( string == 0 ) ! 1454: return 0; ! 1455: ! 1456: if ( string[0]=='_' && string[1]=='_' && ! 1457: (string[2]=='C' || string[2]=='E')) ! 1458: return 1; ! 1459: return 0; ! 1460: } ! 1461: ! 1462: Pname dclass(Pname n, Ptable tbl) ! 1463: { ! 1464: Pclass cl; ! 1465: Pbase bt; ! 1466: Pname bn; ! 1467: Pname ntbl = tbl->t_name; ! 1468: Ptype ntp = 0; ! 1469: TOK tscope; ! 1470: ! 1471: Pname nx = ktbl->look(n->string,0); // TNAME ! 1472: if (ntbl && ntbl->tp) ntp = ntbl->tp; ! 1473: ! 1474: tscope = ntp&&ntp->base==CLASS?NESTED:(n->lex_level?LOCAL:HIDDEN); ! 1475: ! 1476: DB( if(Ddebug>=1) error( 'd', &n->where, "dclass n %n %d nx %d", n,n->lex_level, nx); ); ! 1477: // error( 'd', &n->where, "dclass n %n ll %d nx %d tbl: %n", n,n->lex_level, nx, tbl->t_name); ! 1478: if (nx == 0 || n->lex_level || ! 1479: ntp && is_anon(n->string) == 0 && ntp->base == CLASS ! 1480: && (ktbl->look(n->string,tscope))) ! 1481: { ! 1482: if ( nx && ntp && ntp->base == CLASS ) { ! 1483: bt = (Pbase)nx->tp; ! 1484: bn = bt->b_name; ! 1485: cl = bn ? (Pclass)bn->tp : 0; ! 1486: if (cl && cl->lcl && ! 1487: strcmp(cl->lcl,"FUDGE007")==0) ! 1488: goto bbb; ! 1489: else { bt=0; bn=0; cl=0; } ! 1490: } ! 1491: ! 1492: int tn = 0; ! 1493: for (nx=ktbl->look(n->string,tscope); nx; nx=nx->n_tbl_list) ! 1494: { ! 1495: if (nx->n_key != tscope) continue; ! 1496: if (tscope==LOCAL && ! 1497: nx->lex_level != n->lex_level ) continue; ! 1498: ! 1499: if (nx->tp->base != COBJ) { ! 1500: tn = 1; ! 1501: continue; ! 1502: } ! 1503: ! 1504: bt = (Pbase)nx->tp; ! 1505: bn = bt->b_name; ! 1506: cl = (Pclass)bn->tp; ! 1507: ! 1508: if (cl == 0) continue; ! 1509: ! 1510: // is this class nested within class table? ! 1511: if (tscope==NESTED && ! 1512: strcmp(ntbl->string,cl->in_class->string)) ! 1513: continue; ! 1514: else ! 1515: if ( tscope==LOCAL && ! 1516: (cl->lcl==0 || strcmp(cl->lcl,Pclass(n->tp)->lcl))) ! 1517: continue; ! 1518: ! 1519: goto bbb; ! 1520: } ! 1521: ! 1522: if (tn) ! 1523: error("%n redefined using Tdef",n); ! 1524: else ! 1525: error('i',"%n is not aCN",n); ! 1526: } ! 1527: else { ! 1528: bt = Pbase(nx->tp); // COBJ ! 1529: if ( bt->base != COBJ ) { ! 1530: error("%n redefined using typedef",n); ! 1531: Pname tn = ktbl->look(n->string,HIDDEN); ! 1532: if ( tn->tp->base == COBJ ) ! 1533: bt = Pbase(tn->tp); ! 1534: else error('i',"%n is not a CN", n ); ! 1535: } ! 1536: bn = bt->b_name; ! 1537: } ! 1538: bbb: ! 1539: bn->where = nx->where; ! 1540: Pname bnn = tbl->insert(bn,CLASS); // copy for member lookup ! 1541: cl = Pclass(bn->tp); ! 1542: ! 1543: if (cl->class_base == template_class) ! 1544: error("C%n defined previously asYC", bn); ! 1545: ! 1546: if (cl->defined&(DEFINED|SIMPLIFIED)) ! 1547: error("C%n defined twice",n); ! 1548: else { ! 1549: if (bn->n_scope == ARG) bn->n_scope = ARGT; ! 1550: cl->dcl(bn,tbl); ! 1551: } ! 1552: n->tp = cl; ! 1553: return bnn; ! 1554: } ! 1555: ! 1556: Pname denum(Pname n, Ptable tbl) ! 1557: { ! 1558: Penum en; ! 1559: Pbase bt; ! 1560: Pname bn; ! 1561: Pname ntbl = tbl->t_name; ! 1562: Ptype ntp = 0; ! 1563: TOK tscope; ! 1564: ! 1565: Pname nx = ktbl->look(n->string,0); // TNAME ! 1566: if (ntbl && ntbl->tp) ntp = ntbl->tp; ! 1567: ! 1568: // note: ***** add for local enumeration declaration ! 1569: // error( 'd', &n->where, "denum n %n ll %d nx %d tbl: %n", n,n->lex_level, nx, tbl->t_name); ! 1570: if (nx == 0 || /* n->lex_level ||*/ ! 1571: ntp && is_anon(n->string)==0 && ntp->base == CLASS ) ! 1572: { ! 1573: int tn = 0; ! 1574: tscope = ntp&&ntp->base==CLASS?NESTED:(/*n->lex_level?LOCAL:*/HIDDEN); ! 1575: for (nx=ktbl->look(n->string,tscope); nx; nx=nx->n_tbl_list) ! 1576: { ! 1577: if (nx->n_key != tscope) continue; ! 1578: // if (tscope==LOCAL && ! 1579: // nx->lex_level != n->lex_level ) continue; ! 1580: ! 1581: bt = (Pbase)nx->tp; ! 1582: bn = bt->b_name; ! 1583: en = (Penum)bn->tp; ! 1584: ! 1585: // is this class nested within class table? ! 1586: if (tscope==NESTED && en->in_class && ! 1587: strcmp(ntbl->string,en->in_class->string)) ! 1588: continue; ! 1589: } ! 1590: } ! 1591: else { ! 1592: bt = (Pbase)nx->tp; ! 1593: bn = bt->b_name; ! 1594: en = (Penum)bn->tp; ! 1595: } ! 1596: ! 1597: Pname bnn = tbl->insert(bn,CLASS); ! 1598: if (en->defined&(DEFINED|SIMPLIFIED)) ! 1599: error("enum%n defined twice",n); ! 1600: else { ! 1601: if (bn->n_scope == ARG) bn->n_scope = ARGT; ! 1602: en->dcl(bn,tbl); ! 1603: } ! 1604: n->tp = en; ! 1605: return bnn; ! 1606: } ! 1607: ! 1608: ! 1609: is_probably_temp( char *str ) ! 1610: { ! 1611: // error( 'd', "is_probably_temp( %s )", str ); ! 1612: ! 1613: if ( str[0] != '_' || str[1] != '_' ) ! 1614: return 0; ! 1615: ! 1616: switch (str[2]) { ! 1617: default: ! 1618: return 0; ! 1619: case 'A': case 'C': case 'D': case 'E': case 'F': ! 1620: case 'I': case 'K': case 'L': case 'M': case 'N': ! 1621: case 'Q': case 'R': case 'S': case 'T': case 'U': ! 1622: case 'V': case 'W': case 'X': ! 1623: if (isdigit(str[3])) ! 1624: return 1; ! 1625: return 0; ! 1626: } ! 1627: ! 1628: } ! 1629: ! 1630: static void ! 1631: check_for_local( Pexpr ee ) ! 1632: { ! 1633: static Pname n[2] = {0,0}; // try not to flag multiple errors ! 1634: static index = 0; ! 1635: ! 1636: if ( ee==0 ) return; ! 1637: ! 1638: // error('d', "check_for_local( %k ) e1: %d e2: %d", ee->base, ee->e1, ee->e2); ! 1639: ! 1640: switch ( ee->base ) { ! 1641: case NAME: ! 1642: { ! 1643: Pname nn = Pname(ee); ! 1644: if ((nn->n_scope==FCT || nn->n_scope==ARG) ! 1645: && is_probably_temp(nn->string) == 0 ! 1646: && n[0]!=nn && n[1]!=nn) ! 1647: { ! 1648: error("local%n used as defaultA", nn ); ! 1649: n[index] = nn; ! 1650: index = index==0?1:0; ! 1651: } ! 1652: // no break; ! 1653: } ! 1654: case TNAME: case STRING: case IVAL: ! 1655: case ICON: case CCON: case FCON: ! 1656: case ZERO: case DUMMY: case SIZEOF: ! 1657: return; ! 1658: case QUEST: ! 1659: check_for_local( ee->cond ); ! 1660: break; ! 1661: case MDOT: ! 1662: check_for_local( ee->mem ); ! 1663: return; ! 1664: } ! 1665: ! 1666: check_for_local( ee->e1 ); ! 1667: check_for_local( ee->e2 ); ! 1668: } ! 1669: ! 1670: void dargs(Pname, Pfct f, Ptable tbl) ! 1671: { ! 1672: int argnamesize = 0; // if +a1, make sure arg names can be printed ! 1673: int oo = const_save; ! 1674: const_save = 1; ! 1675: if ( ansi_opt ) { ! 1676: Pname th = f->f_this; ! 1677: if ( th && th->string ) argnamesize += strlen(th->string) + 1; ! 1678: th = f->f_result; ! 1679: if ( th && th->string ) argnamesize += strlen(th->string) + 1; ! 1680: } ! 1681: ! 1682: for (Pname a=f->argtype; a; a=a->n_list) { ! 1683: Pexpr init; ! 1684: ! 1685: if (a->tp == 0) { ! 1686: error( "A has noT" ); ! 1687: a->tp = any_type; ! 1688: a->n_list = 0; ! 1689: continue; ! 1690: } ! 1691: if (ansi_opt && a->string) argnamesize += strlen(a->string) + 1; ! 1692: ! 1693: Pname cln = a->tp->is_cl_obj(); ! 1694: //error('d',"dargs %t",a->tp); ! 1695: if (cln && Pclass(cln->tp)->has_itor()) // mark X(X&) arguments ! 1696: a->n_xref = 1; ! 1697: else { ! 1698: Ptype t = a->tp; ! 1699: while (t->base == TYPE) t = Pbase(t)->b_name->tp; ! 1700: if (t->base == FCT) a->tp = new ptr(PTR,a->tp); ! 1701: } ! 1702: ! 1703: // if (init = a->n_initializer) { // default argument ! 1704: if ( a->n_key != NESTED && ! 1705: (init = a->n_initializer)) { // default argument ! 1706: Pptr pt; ! 1707: if (init == dummy) { ! 1708: error("emptyIr"); ! 1709: a->n_initializer = 0; ! 1710: continue; ! 1711: } ! 1712: if (cln) { ! 1713: if (init->base==VALUE) { ! 1714: switch (init->tp2->base) { ! 1715: case CLASS: ! 1716: if (Pclass(init->tp2)!=Pclass(cln->tp)) goto inin2; ! 1717: break; ! 1718: default: ! 1719: Pname n2 = init->tp2->is_cl_obj(); ! 1720: if (n2==0 || Pclass(n2->tp)!=Pclass(cln->tp)) goto inin2; ! 1721: } ! 1722: ! 1723: a->n_initializer = init = 0; ! 1724: error('s',"K as defaultA"); ! 1725: } ! 1726: else { ! 1727: inin2: ! 1728: if (init->base == ILIST) error("list as AIr"); ! 1729: Pexpr i = init->typ(tbl); ! 1730: init = class_init(a,a->tp,i,tbl); ! 1731: if (i!=init && init->base==DEREF) { ! 1732: error('s',"K needed forAIr"); ! 1733: init = 0; ! 1734: } ! 1735: else { ! 1736: dosimpl(init,cc->nof); ! 1737: // init->simpl(); ! 1738: init->permanent = 2; ! 1739: } ! 1740: a->n_initializer = init; ! 1741: } ! 1742: } ! 1743: else if (pt = a->tp->is_ref()) { ! 1744: ref_initializer++; ! 1745: init = init->typ(tbl); ! 1746: ref_initializer--; ! 1747: int tcount = stcount; ! 1748: init = ref_init(pt,init,tbl); ! 1749: if (tcount != stcount) { ! 1750: error('s',"needs temporaryV to evaluateAIr"); ! 1751: init = 0; ! 1752: } ! 1753: else { ! 1754: dosimpl(init,cc->nof); ! 1755: // init->simpl(); ! 1756: init->permanent = 2; ! 1757: } ! 1758: a->n_initializer = init; ! 1759: } ! 1760: else { ! 1761: Pptr p = a->tp->is_ptr(); ! 1762: init = init->typ(tbl); ! 1763: if (p) init = ptr_init(p,init,tbl); ! 1764: ! 1765: if (a->tp->check(init->tp,ARG)) { ! 1766: int i = can_coerce(a->tp,init->tp); ! 1767: ! 1768: switch (i) { ! 1769: case 1: ! 1770: if (Ncoerce) { ! 1771: Pname cn = init->tp->is_cl_obj(); ! 1772: Pname xx = new name(Ncoerce->string); ! 1773: Pref r = new ref(DOT,init,xx); ! 1774: init = new expr(G_CALL,r,0); ! 1775: init = init->typ(tbl); ! 1776: } ! 1777: break; ! 1778: default: ! 1779: error("%d possible conversions for defaultA",i); ! 1780: case 0: ! 1781: error("badIrT%t forA%n (%tX)",init->tp,a,a->tp); ! 1782: DEL(init); ! 1783: a->n_initializer = init = 0; ! 1784: } ! 1785: } ! 1786: ! 1787: if (init) { ! 1788: dosimpl(init,cc->nof); ! 1789: // init->simpl(); ! 1790: init->permanent = 2; ! 1791: a->n_initializer = init; ! 1792: Neval = 0; ! 1793: long i = init->eval(); ! 1794: if (Neval == 0) { ! 1795: a->n_evaluated = 1; ! 1796: a->n_val = i; ! 1797: } ! 1798: } ! 1799: } ! 1800: if ( a->n_initializer ) ! 1801: check_for_local(a->n_initializer); ! 1802: } ! 1803: } ! 1804: if ( ansi_opt && argnamesize ) { ! 1805: char* ps = new char[ argnamesize ]; ! 1806: Pname a = f->f_this; ! 1807: if ( a && a->string ) { ! 1808: int i = strlen(a->string) + 1; ! 1809: if ( (argnamesize -= i) < 0 ) goto bad; ! 1810: strcpy(ps,a->string); ! 1811: a->string = ps; ! 1812: ps += i; ! 1813: } ! 1814: a = f->f_result; ! 1815: if ( a && a->string ) { ! 1816: int i = strlen(a->string) + 1; ! 1817: if ( (argnamesize -= i) < 0 ) goto bad; ! 1818: strcpy(ps,a->string); ! 1819: a->string = ps; ! 1820: ps += i; ! 1821: } ! 1822: for ( a = f->argtype; a; a = a->n_list ) { ! 1823: if ( a->string == 0 ) continue; ! 1824: int i = strlen(a->string) + 1; ! 1825: if ( (argnamesize -= i) < 0 ) goto bad; ! 1826: strcpy(ps,a->string); ! 1827: a->string = ps; ! 1828: ps += i; ! 1829: } ! 1830: if ( argnamesize ) bad:error('i',"bad argN size for%t",f); ! 1831: } ! 1832: const_save = oo; ! 1833: } ! 1834: ! 1835: void merge_init(Pname nn, Pfct f, Pfct nf) ! 1836: { ! 1837: // Pname a1 = f->f_args; if (a1==0) a1 = f->argtype; ! 1838: // Pname a2 = nf->f_args;//nf->argtype; ! 1839: Pname a1 = f->argtype; ! 1840: Pname a2 = nf->argtype; ! 1841: ! 1842: for (; a1; a1=a1->n_list, a2=a2->n_list) { ! 1843: int i1 = a1->n_initializer || a1->n_evaluated; ! 1844: int i2 = a2->n_initializer || a2->n_evaluated; ! 1845: ! 1846: if (i1 && i2) error(&a1->where,"twoIrs for%nA%n",nn,a1); ! 1847: ! 1848: if (i1) { ! 1849: a2->n_initializer = a1->n_initializer; ! 1850: a2->n_evaluated = a1->n_evaluated; ! 1851: a2->n_val = a1->n_val; ! 1852: } ! 1853: if (i2) { ! 1854: a1->n_initializer = a2->n_initializer; ! 1855: a1->n_evaluated = a2->n_evaluated; ! 1856: a1->n_val = a2->n_val; ! 1857: } ! 1858: ! 1859: } ! 1860: } ! 1861: ! 1862: Pexpr try_to_coerce(Ptype rt, Pexpr e, char* s, Ptable tbl) ! 1863: /* ! 1864: ``e'' is of class ``cn'' coerce it to type ``rt'' ! 1865: */ ! 1866: { ! 1867: int i; ! 1868: Pname cn; ! 1869: //error('d',"try_to_coerce(%t, %t, %s, %d)",rt,e->tp,s,tbl); ! 1870: ! 1871: if ((cn=e->tp->is_cl_obj()) && (i=can_coerce(rt,e->tp)) && Ncoerce) { ! 1872: if (1 < i) error("%d possible conversions for %s",i,s); ! 1873: //error('d',"coerce %n",Ncoerce); ! 1874: Pclass cl = Pclass(cn->tp); ! 1875: // Pref r = new ref(DOT,e,Ncoerce); ! 1876: // Pexpr rr = r->typ(tbl); ! 1877: // Pexpr c = new expr(G_CALL,rr,0); ! 1878: // c->fct_name = Ncoerce; ! 1879: Pname xx = new name(Ncoerce->string); ! 1880: Pref r = new ref(DOT,e,xx); ! 1881: Pexpr c = new expr(G_CALL,r,0); ! 1882: // return c->typ(tbl); ! 1883: c = c->typ(tbl); ! 1884: //error('d',"coerce -> %k %t",c->base,c->tp); ! 1885: return c; ! 1886: } ! 1887: //error('d',"coerce ->0"); ! 1888: return 0; ! 1889: } ! 1890: ! 1891: int in_class_dcl; ! 1892: ! 1893: Pname name::dofct(Ptable tbl, TOK scope) ! 1894: { ! 1895: Pfct f = Pfct(tp); ! 1896: Pname class_name; ! 1897: Ptable etbl; ! 1898: in_class_dcl = cc->not!=0; ! 1899: int just_made = 0; ! 1900: // int fvirt = 0; //BSopt ! 1901: DB( if(Ddebug>=1) error('d',"dofct %n %d %t %s",this,tp,tp,tbl==gtbl?"global":""); ); ! 1902: // error( 'd', "%n->dofct(): n_initializer: %d f->f_virtual: %d", this, n_initializer, f->f_virtual); ! 1903: ! 1904: if (f->f_inline) n_sto = STATIC; ! 1905: ! 1906: if (n_stclass) ! 1907: switch (n_stclass) { ! 1908: case EXTERN: ! 1909: case STATIC: ! 1910: case OVERLOAD: ! 1911: break; ! 1912: default: ! 1913: error("%n declared%k",this,n_stclass); ! 1914: n_stclass = EXTERN; ! 1915: } ! 1916: ! 1917: tp->dcl(tbl); // must be done before the type check ! 1918: ! 1919: if (n_qualifier) { // qualified name: c::f() checked above ! 1920: class_name = Pbase(n_qualifier->tp)->b_name; ! 1921: etbl = Pclass(class_name->tp)->memtbl; ! 1922: ! 1923: if (f->f_virtual) { ! 1924: error("virtual specifier illegal outsideCD(%n::%s())",class_name,this->string); ! 1925: f->f_virtual = 0; ! 1926: } ! 1927: ! 1928: ! 1929: if (n_sto ! 1930: && n_sto!=FRIEND // friend X::f(); ! 1931: && f->f_inline==0) { // inline causes n_sto==STATIC ! 1932: error("%k specified for QdN%n",n_sto,this); ! 1933: n_sto = 0; ! 1934: } ! 1935: } ! 1936: else { ! 1937: class_name = cc->not; ! 1938: ! 1939: // beware of local function declarations in member functions ! 1940: if (class_name && tbl!=cc->cot->memtbl) { ! 1941: class_name = 0; ! 1942: in_class_dcl = 0; ! 1943: } ! 1944: ! 1945: if (f->f_static && f->f_virtual) { ! 1946: error("virtual staticM"); ! 1947: f->f_virtual = 0; ! 1948: } ! 1949: ! 1950: if (n_oper) check_oper(class_name); ! 1951: etbl = tbl; ! 1952: } ! 1953: ! 1954: // Pfct(tp)->memof = class_name ? Pclass(class_name->tp) : 0; ! 1955: ! 1956: if (class_name) { ! 1957: Pclass cl; ! 1958: f->memof = cl = Pclass(class_name->tp); ! 1959: if (f->f_virtual==0 && find_virtual(f->memof,this)) ! 1960: f->f_virtual = VTOK; ! 1961: //error('d',"class_name: %s fct: %s virtual: %d", class_name->string, string, f->f_virtual ); ! 1962: ! 1963: if (f->f_static && f->f_virtual) { ! 1964: error("virtual staticM"); ! 1965: f->f_virtual = 0; ! 1966: } ! 1967: ! 1968: if ( cl->csu == UNION && f->f_virtual ) // don't worry about ANON ! 1969: error( "%n: cannot declare a virtualFWin union", this ); ! 1970: } ! 1971: ! 1972: if(f->f_const && f->memof==0) { ! 1973: error("onlyMFs can be constant"); ! 1974: } ! 1975: ! 1976: if (etbl==0 || etbl->base!=TABLE) error('i',"N::dcl: etbl=%d",etbl); ! 1977: ! 1978: switch (n_oper) { ! 1979: case CTOR: ! 1980: if (f->f_virtual) { ! 1981: error("virtualK"); ! 1982: f->f_virtual = 0; ! 1983: } ! 1984: ! 1985: // case DTOR: ! 1986: // f->f_const = 1; ! 1987: break; ! 1988: ! 1989: case REF: ! 1990: if (f->argtype) ! 1991: error("%n takes no argument",this); ! 1992: else if (f->returns->is_ptr() == 0) { ! 1993: Pname cn = f->returns->is_cl_obj(); ! 1994: if (cn==0 && f->returns->base==RPTR) cn = Pptr(f->returns)->typ->is_cl_obj(); ! 1995: if (cn==0 || Pclass(cn->tp)->has_oper(REF)==0) { ! 1996: if ( cn && class_name && // B B::operator->(); ! 1997: strcmp(cn->string, class_name->string)==0 ) ! 1998: error("%s::%n cannot return aR orCO ofC%n",cn->string,this,cn); ! 1999: else error("%n must return aP toCO, aR toCO, or aCO",this); ! 2000: tp = any_type; // suppress further checking ! 2001: } ! 2002: } ! 2003: break; ! 2004: ! 2005: case NEW: // void* operator new(long) ! 2006: if (f->f_virtual) ! 2007: error("virtual%n (operator new() is static)",this); ! 2008: if (class_name) f->f_static = 1; // if member: static by default ! 2009: if (f->nargs_known != 1) ! 2010: error("ATs must be fully specified for%n",this); ! 2011: else if (f->nargs<1) ! 2012: error("%n requires a firstA ofT size_t",this); ! 2013: else if (f->argtype->tp->check(size_t_type,0)) { ! 2014: if (strict_opt==0 ! 2015: && ( f->argtype->tp->check(long_type,0)==0 || ! 2016: f->argtype->tp->check(ulong_type,0)==0)) { ! 2017: error('w',"%n firstA should be size_t (anachronism)",this); ! 2018: f->argtype->tp = size_t_type; ! 2019: if (f->f_signature) f->sign(); ! 2020: } ! 2021: else ! 2022: error("%n requires a firstA ofT size_t",this); ! 2023: } ! 2024: else { ! 2025: Ptype t = f->s_returns ? f->s_returns : f->returns; ! 2026: if (t->check(Pvoid_type,0)) error("bad returnT for %n",this); ! 2027: } ! 2028: break; ! 2029: ! 2030: case DELETE: // void operator delete(void*) or ! 2031: // void operator delete(void*, long) ! 2032: if (f->f_virtual) ! 2033: error("virtual%n (operator delete() is static)",this); ! 2034: if (class_name) f->f_static = 1; // if member: static by default ! 2035: if (f->nargs_known != 1) ! 2036: error("ATs must be fully specified for%n",this); ! 2037: else { ! 2038: Ptype t = f->s_returns ? f->s_returns : f->returns; ! 2039: if (t->base != VOID) ! 2040: error("bad returnT for %n", this); ! 2041: else { ! 2042: switch (f->nargs) { ! 2043: default: ! 2044: error("%n takes 1 or 2As",this); ! 2045: break; ! 2046: case 1: ! 2047: case 2: ! 2048: { Pname a = f->argtype; ! 2049: if (a->tp->check(Pvoid_type,0)) ! 2050: error("%n's 1stA must be a void*",this); ! 2051: else if (a = a->n_list) { ! 2052: if (class_name == 0) ! 2053: error("%n takes only oneA",this); ! 2054: else if (a->tp->check(size_t_type,0)) { ! 2055: if (strict_opt==0 ! 2056: && a->tp->check(long_type,0)==0) { ! 2057: error('w',"%n's 2ndA should be a size_t (anachronism)",this); ! 2058: a->tp = size_t_type; ! 2059: if (f->f_signature) f->sign(); ! 2060: } ! 2061: else ! 2062: error("%n's 2ndA must be a size_t",this); ! 2063: } ! 2064: } ! 2065: } ! 2066: } ! 2067: } ! 2068: } ! 2069: break; ! 2070: ! 2071: case ASSIGN: ! 2072: if (class_name && f->nargs==1) { ! 2073: Ptype t = f->argtype->tp; ! 2074: Pname an = t->is_cl_obj(); // X::operator=(X) ? ! 2075: if (an==0 && (t=t->is_ref())) { // X::operator=(X&) ? ! 2076: t = Pptr(t)->typ; ! 2077: rx1: ! 2078: switch (t->base) { ! 2079: case TYPE: t = Pbase(t)->b_name->tp; goto rx1; ! 2080: case COBJ: an = Pbase(t)->b_name; ! 2081: } ! 2082: } ! 2083: if (an && an==class_name) Pclass(an->tp)->c_xref |= C_ASS; ! 2084: } ! 2085: else if (f->nargs == 2) { ! 2086: Ptype t = f->argtype->tp; ! 2087: Pname an1; ! 2088: if (t=t->is_ref()) { // operator=(X&,?) ? ! 2089: t = Pptr(t)->typ; ! 2090: rx2: ! 2091: switch (t->base) { ! 2092: case TYPE: t = Pbase(t)->b_name->tp; goto rx2; ! 2093: case COBJ: an1 = Pbase(t)->b_name; ! 2094: } ! 2095: } ! 2096: t = f->argtype->n_list->tp; ! 2097: Pname an2 = t->is_cl_obj(); // operator=(X&,X) ? ! 2098: if (an2==0 && (t=t->is_ref())) { // operator=(X&,X&) ? ! 2099: t = Pptr(t)->typ; ! 2100: rx3: ! 2101: switch (t->base) { ! 2102: case TYPE: t = Pbase(t)->b_name->tp; goto rx3; ! 2103: case COBJ: an2 = Pbase(t)->b_name; ! 2104: } ! 2105: } ! 2106: if (an1 && an1==an2) Pclass(an1->tp)->c_xref |= C_ASS; ! 2107: } ! 2108: } ! 2109: ! 2110: switch (scope) { ! 2111: case FCT: ! 2112: case ARG: ! 2113: if (n_sto == STATIC) error("D of staticF in aF"); ! 2114: else { // detect local re-definition ! 2115: Pname nx = gtbl->look(string,0); ! 2116: if (nx) { ! 2117: switch (nx->tp->base) { ! 2118: case FCT: ! 2119: if (tp->check(nx->tp,0)) ! 2120: error('w',"%n has been locally re-declared as%t",this,tp); ! 2121: else { ! 2122: if(Pfct(nx->tp)->f_signature==0) ! 2123: Pfct(nx->tp)->sign(); ! 2124: if (Pfct(tp)->f_signature == 0) ! 2125: Pfct(tp)->sign(); ! 2126: if ( strcmp(Pfct(nx->tp)->f_signature,Pfct(tp)->f_signature)) ! 2127: error('w',"%n of type %t has been locally re-declared with different linkage",this,tp); ! 2128: } ! 2129: break; ! 2130: case OVERLOAD: ! 2131: { Pname ny = Pgen(nx->tp)->find(f,0); ! 2132: if (ny == 0) ! 2133: error('w',"overloadedF%n has been locally declared as%t",this,tp); ! 2134: else { ! 2135: if(Pfct(ny->tp)->f_signature==0) ! 2136: Pfct(ny->tp)->sign(); ! 2137: if (Pfct(tp)->f_signature == 0) ! 2138: Pfct(tp)->sign(); ! 2139: if (strcmp(Pfct(ny->tp)->f_signature,Pfct(tp)->f_signature)) ! 2140: error('w',"overloadedF%n of type %t has been locally re-declared with different linkage",this,tp); ! 2141: } ! 2142: } ! 2143: break; ! 2144: } // switch nx->base ! 2145: } // if nx ! 2146: } // else ! 2147: } // switch scope ! 2148: ! 2149: Pname nn = etbl->insert(this,0); ! 2150: if ( f->body ) nn->where = where; ! 2151: nn->assign(); ! 2152: if (nn->tp->base==FCT) { ! 2153: Pfct nnf = (Pfct)nn->tp; ! 2154: if (nnf->f_this) nnf->f_this->where=where; ! 2155: } ! 2156: n_table = etbl; ! 2157: //error('d',"%n->dofct(): n_initializer:%d f->f_virtual:%d",this,n_initializer,f->f_virtual); ! 2158: if (n_initializer) { ! 2159: if (f->f_virtual == 0) error("Ir for non-virtualF%n",this); ! 2160: if (n_initializer != zero) error("virtualFIr must be 0"); ! 2161: } ! 2162: ! 2163: if (Nold) { ! 2164: Pfct nf = Pfct(nn->tp); ! 2165: // error('d',"old %n: %t and %t",nn,nf,tp); ! 2166: int flag = 0; ! 2167: Pname af=0,anf=0; ! 2168: if (nf->base==ANY || f->base==ANY) ! 2169: ; // wild card -- do nothing ! 2170: else ! 2171: if (nf->base == OVERLOAD) { ! 2172: string = nn->string; ! 2173: nn = Pgen(nf)->add(this); ! 2174: nn->where=where; ! 2175: if (Pfct(nn->tp)->f_this!=0) ! 2176: Pfct(nn->tp)->f_this->where=where; ! 2177: ! 2178: if (Nold == 0) { ! 2179: if (f->body && n_qualifier) { ! 2180: error("badAL for%n",this); ! 2181: return 0; ! 2182: } ! 2183: goto thth; ! 2184: } ! 2185: // else { ! 2186: // if (f->body==0 && friend_in_class==0) error('w',"%n redeclared",nn); ! 2187: // } ! 2188: nf = Pfct(nn->tp); ! 2189: if (f->body && nf->body) { ! 2190: // Preserve the original definition ! 2191: // in the case of a PT class; i.e, ! 2192: // the one supplied by the user ! 2193: if (!(class_name && ! 2194: (Pclass(class_name->tp)->class_base == ! 2195: instantiated_template_class) && ! 2196: nn->n_redefined)) ! 2197: { ! 2198: error("two definitions of%n",nn); ! 2199: f->body = 0; ! 2200: } ! 2201: return 0; ! 2202: } ! 2203: if (f->body) goto bdbd; ! 2204: goto stst; ! 2205: } ! 2206: else if (nf->base != FCT) { ! 2207: error("%n declared both as%t and asF",this,nf); ! 2208: f->body = 0; ! 2209: } ! 2210: else { ! 2211: // error('d',"%t->check(%t) -> %d %d",nf,f,nf->check(f,OVERLOAD)); ! 2212: if (nf->check(f,OVERLOAD) || const_problem) { ! 2213: if (f->body && n_qualifier) { ! 2214: error("%nT mismatch: %t and %t",nn,nf,f); ! 2215: return 0; ! 2216: } ! 2217: Pgen g = new gen; ! 2218: add_first = 1; ! 2219: Pname n1 = g->add(nn); ! 2220: add_first = 0; ! 2221: string = nn->string; ! 2222: Pname n2 = g->add(this); ! 2223: nn->tp = g; ! 2224: nn = n2; ! 2225: goto thth; ! 2226: } ! 2227: ! 2228: af = f->argtype; ! 2229: anf = nf->argtype; ! 2230: for (; af && anf; af=af->n_list,anf=anf->n_list) { ! 2231: Ptype at = af->tp; ! 2232: Ptype atp = anf->tp; ! 2233: if(!exact1(af,atp)) break; ! 2234: if(at->base!=PTR || ! 2235: Pptr(at)->b_const == Pptr(atp)->b_const) continue; ! 2236: int k = Pptr(at)->typ->tconst(); ! 2237: int l = Pptr(atp)->typ->tconst(); ! 2238: if(k==l) flag=1; ! 2239: } ! 2240: if ( flag && !af && !anf) { ! 2241: error("the overloading mechanism cannot tell a%t from a%t",nf,f); ! 2242: } ! 2243: ! 2244: if (in_class_dcl) { ! 2245: // error("twoDs of%n",this); ! 2246: // f->body = 0; ! 2247: // return 0; ! 2248: } ! 2249: else if (nf->f_static && f->f_inline==0 && n_sto==STATIC) { ! 2250: //error('d',"MF%n declared static outsideF",this); ! 2251: n_sto = 0; ! 2252: } ! 2253: else if (n_sto && n_sto!=nn->n_scope) { ! 2254: if (n_sto==EXTERN && nn->n_scope==STATIC) ! 2255: error('w',"%n declared extern after being declared static",this); ! 2256: else if (nf->f_inline==0 && f->f_inline==0) { ! 2257: if (nn->tp==new_fct->tp || nn->tp==del_fct->tp) ! 2258: nn->n_sto = n_sto; ! 2259: else ! 2260: error("%n declared as both%k and%k",this,n_sto,(nn->n_sto)?nn->n_sto:EXTERN); ! 2261: } ! 2262: } ! 2263: ! 2264: //error('d',"fct %n: %k %k scope %k",this,n_sto,nn->n_sto,nn->n_scope); ! 2265: //error('d',"link %d lcount %d sig %s",linkage,lcount,nf->f_signature); ! 2266: ! 2267: { ! 2268: Linkage l1 = nf->f_linkage; ! 2269: Linkage l2 = f->f_linkage; ! 2270: if ( l2!=linkage_default && l1!=l2) ! 2271: error("inconsistent linkage specifications for%n",this); ! 2272: } ! 2273: if (nf->body && f->body) { ! 2274: // Preserve the original definition ! 2275: // in the case of a PT class; i.e, ! 2276: // the one supplied by the user ! 2277: if (!(class_name && ! 2278: (Pclass(class_name->tp)->class_base == ! 2279: instantiated_template_class) && ! 2280: nn->n_redefined)) ! 2281: { ! 2282: error("two definitions of%n",this); ! 2283: f->body = 0; ! 2284: } ! 2285: return 0; ! 2286: } ! 2287: ! 2288: if (f->body) goto bdbd; ! 2289: ! 2290: goto stst; ! 2291: ! 2292: bdbd: ! 2293: // error('d',"nn %n init: %d f_virt: %d f->body: %d", nn,nn->n_initializer,nf->f_virtual,f->body); ! 2294: if (f->nargs_known && nf->nargs_known) merge_init(nn,f,nf); ! 2295: f->f_virtual = nf->f_virtual; ! 2296: f->f_this = nf->f_this; ! 2297: f->f_result = nf->f_result; ! 2298: f->s_returns = nf->s_returns; ! 2299: f->f_args = nf->f_args; ! 2300: // f->argtype = nf->argtype; ! 2301: f->f_signature = nf->f_signature; ! 2302: f->f_const = nf->f_const; ! 2303: f->f_static = nf->f_static; ! 2304: nn->tp = f; ! 2305: if (f->f_inline) { ! 2306: if (nf->f_inline==0) { ! 2307: if (nn->n_used && nn->n_sto!=STATIC) ! 2308: error("%n declared with external linkage and called before defined as inline",nn); ! 2309: // else if (nf->memof) ! 2310: // error('w',"%n declared as non-inline but defined as inline",nn); ! 2311: else if (nn->n_used) { ! 2312: nn->take_addr(); // force printout ! 2313: if (warning_opt) error('w',"%n called before defined as inline",nn); ! 2314: } ! 2315: } ! 2316: nf->f_inline = 1; ! 2317: nn->n_sto = STATIC; ! 2318: } ! 2319: else if (nf->f_inline) { ! 2320: // error('w',"%n defined as inline but not declared as inline",this); ! 2321: f->f_inline = 1; ! 2322: } ! 2323: goto stst2; ! 2324: ! 2325: stst: ! 2326: //error('d',"stst"); ! 2327: if (f->nargs_known && nf->nargs_known) merge_init(nn,f,nf); ! 2328: f->f_args = nf->f_args; ! 2329: // f->argtype = nf->argtype; ! 2330: stst2: ! 2331: //error('d',"stst2 %n printed %d",nn,nn->n_dcl_printed); ! 2332: if (f->f_inline) n_sto = STATIC; ! 2333: ! 2334: /* superceded above (line 1978 and following) ! 2335: if (n_sto ! 2336: && nn->n_scope!=n_sto ! 2337: && friend_in_class==0 ! 2338: && f->f_inline==0){ // allow re-def to "static" ! 2339: if (n_sto == STATIC) ! 2340: nn->n_sto = STATIC; ! 2341: else { ! 2342: error("%n both%k and%k",this,n_sto,nn->n_scope); ! 2343: } ! 2344: } ! 2345: */ ! 2346: ! 2347: //// addition for 2.1 ! 2348: ! 2349: if(n_sto == STATIC && nn->n_sto == EXTERN && ! 2350: (!strcmp(string,"__nw") || !strcmp(string,"__dl"))) ! 2351: nn->n_sto = STATIC; ! 2352: ! 2353: //// end of addition ! 2354: ! 2355: n_scope = nn->n_scope; // first specifier wins ! 2356: n_sto = nn->n_sto; ! 2357: } ! 2358: } ! 2359: else { // new function: make f_this for member functions ! 2360: thth: ! 2361: just_made = 1; ! 2362: if (f->f_inline) ! 2363: nn->n_sto = STATIC; ! 2364: else if (class_name==0 && n_sto==0 && f->body==0) ! 2365: nn->n_sto = EXTERN; ! 2366: //error('d',"thth %n %t static %d sto %k",nn,f,f->f_static,nn->n_sto); ! 2367: if (f->f_static) ! 2368: switch (n_oper) { // what about + ?? ! 2369: case CTOR: ! 2370: case DTOR: ! 2371: case TYPE: ! 2372: case CALL: ! 2373: case DEREF: ! 2374: case REF: ! 2375: case ASSIGN: ! 2376: error("%n cannot be a staticMF",nn); ! 2377: f->f_static = 0; ! 2378: } ! 2379: ! 2380: if (class_name ! 2381: && f->f_static==0 // no ``this'' in static members ! 2382: && n_oper!=NEW // X::operator new() static by default ! 2383: && n_oper!=DELETE // X::operator delete() static by default ! 2384: && etbl!=gtbl) { // beware of implicit declaration ! 2385: Pname cn = nn->n_table->t_name; ! 2386: Pname tt = new name("this"); ! 2387: tt->n_scope = ARG; ! 2388: // tt->where = no_where; ! 2389: tt->where = this->where; ! 2390: // tt->n_sto = ARG; ! 2391: tt->tp = Pclass(class_name->tp)->this_type; ! 2392: PERM(tt); ! 2393: Pfct(nn->tp)->f_this = f->f_this = Pfct(nn->tp)->f_args = f->f_args = tt; ! 2394: tt->n_list = f->argtype; ! 2395: //error('d',"nn %n tp %t const %d",nn,nn->tp,f->f_const); ! 2396: if (f->f_const /*&& n_oper!=CTOR && n_oper!=DTOR*/) { ! 2397: Pbase x = Pbase(Pptr(tt->tp)->typ); ! 2398: Pbase y = new basetype(COBJ,0); ! 2399: *y = *x; ! 2400: y->b_const = 1; ! 2401: tt->tp = new ptr(PTR,y); ! 2402: Pptr(tt->tp)->b_const = 1; ! 2403: PERM(tt->tp); ! 2404: } ! 2405: } ! 2406: else { ! 2407: Pfct(nn->tp)->f_args = f->f_args = f->f_result?f->f_result:f->argtype; ! 2408: Pfct(nn->tp)->f_signature = f->f_signature; ! 2409: Pfct(nn->tp)->f_const = f->f_const; ! 2410: Pfct(nn->tp)->f_static = f->f_static; ! 2411: } ! 2412: ! 2413: // if C++ linkage encode type in function name ! 2414: if (Pfct(nn->tp)->f_signature==0) Pfct(nn->tp)->sign(); ! 2415: ! 2416: if (f->f_result == 0) { ! 2417: //error('d',"re1 %n %t %d",this,f,f); ! 2418: make_res(f); ! 2419: } ! 2420: else if (f->f_this) ! 2421: f->f_this->n_list = f->f_result; ! 2422: ! 2423: if (nn->n_oper==CTOR || nn->n_oper==DTOR) vbase_pointers(nn,Pclass(class_name->tp)); ! 2424: ! 2425: if (f->f_virtual) { ! 2426: switch (nn->n_scope) { ! 2427: default: ! 2428: error("nonC virtual%n",this); ! 2429: break; ! 2430: case 0: ! 2431: case PUBLIC: ! 2432: // if (fvirt) //BSopt ! 2433: cc->cot->virt_count = 1; ! 2434: Pfct(nn->tp)->f_virtual = f->f_virtual; ! 2435: break; ! 2436: } ! 2437: } ! 2438: } ! 2439: ! 2440: /* an operator must take at least one class object or ! 2441: reference to class object argument ! 2442: */ ! 2443: ! 2444: if (just_made) ! 2445: switch (n_oper) { ! 2446: case CTOR: ! 2447: switch (f->nargs) { // check for X(X) and X(X&) ! 2448: case 0: ! 2449: break; ! 2450: default: // handle X(X&, int i = 0) ! 2451: { Pname n2 = f->argtype->n_list; ! 2452: if (n2->n_initializer==0 && n2->n_evaluated==0) break; ! 2453: } ! 2454: case 1: ! 2455: { ! 2456: Ptype t = f->argtype->tp; ! 2457: clll: ! 2458: switch (t->base) { ! 2459: case TYPE: ! 2460: t = Pbase(t)->b_name->tp; ! 2461: goto clll; ! 2462: case RPTR: /* X(X&) ? */ ! 2463: t = Pptr(t)->typ; ! 2464: cxll: ! 2465: switch (t->base) { ! 2466: case TYPE: ! 2467: t = Pbase(t)->b_name->tp; ! 2468: goto cxll; ! 2469: case COBJ: ! 2470: if (class_name == Pbase(t)->b_name) ! 2471: Pclass(class_name->tp)->c_itor = nn; ! 2472: } ! 2473: break; ! 2474: case COBJ: /* X(X) ? */ ! 2475: if (class_name == Pbase(t)->b_name) { ! 2476: error("badK %s(%s) use %s(%s&)",class_name->string,class_name->string,class_name->string,class_name->string); ! 2477: f->argtype->tp = any_type; ! 2478: } ! 2479: } ! 2480: } ! 2481: } ! 2482: if (Pclass(class_name->tp)->c_ctor == 0) Pclass(class_name->tp)->c_ctor = nn; ! 2483: break; ! 2484: ! 2485: case TYPE: ! 2486: // somewhat simple minded solution to the inheritance of ! 2487: // conversion operator problem ! 2488: nn->n_list = Pclass(class_name->tp)->conv; ! 2489: Pclass(class_name->tp)->conv = nn; ! 2490: break; ! 2491: ! 2492: case DTOR: ! 2493: Pclass(class_name->tp)->c_dtor = nn; ! 2494: break; ! 2495: ! 2496: case NEW: ! 2497: case DELETE: ! 2498: case CALL: ! 2499: case 0: ! 2500: break; ! 2501: ! 2502: default: ! 2503: for (Pname a=f->argtype; a; a=a->n_list) { ! 2504: if ( a->n_initializer ) ! 2505: error( "%n: operatorFs cannot take defaultA", this ); ! 2506: } ! 2507: ! 2508: if (f->nargs_known != 1) { ! 2509: error("ATs must be fully specified for%n",nn); ! 2510: } ! 2511: // this doesn't catch unary operator off by one errors ! 2512: // for simplicity, placed that check in check_oper(), above ! 2513: else if (class_name == 0) { ! 2514: switch (f->nargs) { ! 2515: case 1: ! 2516: case 2: ! 2517: for (a=f->argtype; a; a=a->n_list) { ! 2518: Ptype tx = a->tp; ! 2519: while (tx->base == TYPE) tx = Pbase(tx)->b_name->tp; ! 2520: if (tx->is_ref()) tx = Pptr(tx)->typ; ! 2521: if (tx->is_cl_obj()) goto cok; ! 2522: } ! 2523: error("%n must take at least oneCTA",nn); ! 2524: break; ! 2525: default: ! 2526: error("%n must take 1 or 2As",nn); ! 2527: } ! 2528: } ! 2529: else { ! 2530: switch (f->nargs) { ! 2531: case 0: ! 2532: case 1: ! 2533: break; ! 2534: default: ! 2535: error("%n must take 0 or 1As",nn); ! 2536: } ! 2537: } ! 2538: cok:; ! 2539: } ! 2540: ! 2541: int i = 0; // check that every argument after an argument with ! 2542: // initializer have an initializer ! 2543: for (Pname a = f->f_args/*f->argtype*/; a; a=a->n_list) { ! 2544: if (a->n_initializer) ! 2545: i = 1; ! 2546: else if (i) ! 2547: error("trailingA%n withoutIr",a); ! 2548: } ! 2549: ! 2550: /* ! 2551: the body cannot be checked until the name ! 2552: has been checked and entered into its table ! 2553: */ ! 2554: if (f->body) f->dcl(nn); ! 2555: return nn; ! 2556: } ! 2557:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.