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