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