![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dcl2.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront|
Return to dcl2.c CVS log | Up to [Research Unix] / researchv10no / cmd / cfront / ooptcfront |
1.1 ! root 1: /*ident "@(#)ctrans:src/dcl2.c 1.3.4.22" */ ! 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: dcl2.c: ! 11: ! 12: *************************************************************************/ ! 13: ! 14: #include "cfront.h" ! 15: #include "size.h" ! 16: ! 17: Pname conv_dominates(Pname on1, Pname on2) ! 18: /* ! 19: compare for duplicates and dominance: ! 20: ! 21: on1 and on2 are two conversion operator functions ! 22: return the the one that dominates the other (according to the ! 23: class hierarchy) otherwise 0 (0 thus indicats ambiguous conversion) ! 24: */ ! 25: { ! 26: Ptype r1 = Pfct(on1->tp)->returns; ! 27: Ptype r2 = Pfct(on2->tp)->returns; ! 28: //error('d',"conv_dominates(%n,%n)",on1,on2); ! 29: if (r1==r2 || r1->check(r2,0)==0) return on1; ! 30: Pptr p1 = r1->is_ptr_or_ref(); ! 31: Pptr p2 = r2->is_ptr_or_ref(); ! 32: if (p1 && p2) { ! 33: Pname cn1 = p1->typ->is_cl_obj(); ! 34: Pname cn2 = p2->typ->is_cl_obj(); ! 35: if (cn1 && cn2) { ! 36: // is_cl_obj() returns b_name ! 37: // Pclass c1 = Pclass(Pbase(cn1->tp)->b_name->tp); ! 38: // Pclass c2 = Pclass(Pbase(cn2->tp)->b_name->tp); ! 39: Pclass c1 = Pclass(cn1->tp); ! 40: Pclass c2 = Pclass(cn2->tp); ! 41: if (c1 && c2) { ! 42: if (c1==c2 || c1->has_base(c2)) ! 43: return on1; ! 44: else if (c2->has_base(c1)) ! 45: return on2; ! 46: } ! 47: } ! 48: } ! 49: return 0; ! 50: } ! 51: ! 52: ! 53: Pstmt curr_loop; ! 54: Pstmt curr_switch; ! 55: Pblock curr_block; ! 56: ! 57: void stmt::reached() ! 58: { ! 59: register Pstmt ss = s_list; ! 60: ! 61: if (ss == 0) return; ! 62: ! 63: switch (ss->base) { ! 64: case LABEL: ! 65: case CASE: ! 66: case DEFAULT: ! 67: break; ! 68: default: ! 69: error('w',"S after%k not reached",base); ! 70: for (; ss; ss=ss->s_list) { // delete unreacheable code ! 71: switch (ss->base) { ! 72: case LABEL: ! 73: case CASE: ! 74: case DEFAULT: // reachable ! 75: s_list = ss; ! 76: return; ! 77: case DCL: // the dcl may be used later ! 78: // keep to avoid cascading errors ! 79: case IF: ! 80: case DO: ! 81: case WHILE: ! 82: case SWITCH: ! 83: case FOR: ! 84: case BLOCK: // may hide a label ! 85: s_list = ss; ! 86: return; ! 87: } ! 88: } ! 89: s_list = 0; ! 90: } ! 91: } ! 92: ! 93: bit arg_err_suppress; ! 94: ! 95: Pexpr check_cond(Pexpr e, TOK b, Ptable tbl) ! 96: { ! 97: //error('d',"check_cond(%k %k) tbl %d",e->base,b,tbl); ! 98: Pname cn; ! 99: ! 100: if (e == dummy) error("empty condition for %k",b); ! 101: ! 102: if (cn = e->tp->is_cl_obj()) { ! 103: Pclass cl = Pclass(cn->tp); ! 104: int i = 0; ! 105: Pname found = 0; ! 106: for (Pname on = cl->conv; on; on=on->n_list) { ! 107: Pfct f = Pfct(on->tp); ! 108: Ptype t = f->returns; ! 109: xx: ! 110: switch (t->base) { ! 111: case TYPE: ! 112: t = Pbase(t)->b_name->tp; ! 113: goto xx; ! 114: case FLOAT: ! 115: case DOUBLE: ! 116: case LDOUBLE: ! 117: case PTR: ! 118: if (b == DEREF) break; ! 119: case CHAR: ! 120: case SHORT: ! 121: case INT: ! 122: case LONG: ! 123: case EOBJ: ! 124: // if (found==0 || found->tp->check(on->tp,0)) { ! 125: //error('d',"found %n on %n",found,on); ! 126: { Pname xx = found; ! 127: if (found == 0) { ! 128: i = 1; ! 129: found = on; ! 130: } ! 131: else if ((found = conv_dominates(found,on)) == 0) { ! 132: i = 2; ! 133: found = on; ! 134: error("two conversions for%nO in%kE: %n and %n",cn,b,xx,on); ! 135: return e; ! 136: } ! 137: } ! 138: } ! 139: } ! 140: //error('d',"i %d",i); ! 141: switch (i) { ! 142: case 0: ! 143: error("%nO in%kE",cn,b); ! 144: return e; ! 145: /* ! 146: case 1: ! 147: { Pname xx = new name(found->string); ! 148: Pref r = new ref(DOT,e,xx); ! 149: Pexpr rr = r->typ(tbl); ! 150: Pexpr c = new expr(G_CALL,rr,0); ! 151: ! 152: if (e->lval(0)) { ! 153: // Pref r = new ref(DOT,e,found); ! 154: // r->tp = found->tp; ! 155: // Pexpr c = new expr(G_CALL,r,0); ! 156: // c->fct_name = found; ! 157: return c->typ(tbl); ! 158: } ! 159: else { // (temp=init,temp.coerce()) ! 160: Pname tmp = make_tmp('U',e->tp,tbl); ! 161: Pexpr ass = init_tmp(tmp,e,tbl); ! 162: // Pref r = new ref(DOT,tmp,found); ! 163: // Pexpr rr = r->typ(tbl); ! 164: // Pexpr c = new expr(G_CALL,rr,0); ! 165: // c->fct_name = found; ! 166: ass = new expr(CM,ass,c); ! 167: return ass->typ(tbl); ! 168: } ! 169: } ! 170: */ ! 171: case 1: ! 172: { Pname xx = new name(found->string); ! 173: Pexpr c; ! 174: ! 175: if (e->lval(0)) { ! 176: Pref r = new ref(DOT,e,xx); ! 177: Pexpr rr = r->typ(tbl); ! 178: c = new expr(G_CALL,rr,0); ! 179: } ! 180: else { // (temp=init,temp.coerce()) ! 181: Pname tmp = make_tmp('U',e->tp,tbl); ! 182: Pexpr ass = init_tmp(tmp,e,tbl); ! 183: Pref r = new ref(DOT,tmp,xx); ! 184: Pexpr rr = r->typ(tbl); ! 185: c = new expr(G_CALL,rr,0); ! 186: c = new expr(CM,ass,c); ! 187: } ! 188: return c->typ(tbl); ! 189: } ! 190: // default: ! 191: // error("%d possible conversions for%nO in%kE",i,cn,b); ! 192: // return e; ! 193: } ! 194: ! 195: } ! 196: if (e->tp->memptr()) { ! 197: e = new mdot("i",e); ! 198: e->i1 = 9; ! 199: e = new expr(NE,e,zero); ! 200: } ! 201: else if (e->tp->num_ptr(b) == FCT) ! 202: error("%k(F)",b); ! 203: return e; ! 204: } ! 205: ! 206: extern int catch_delete_bugs; ! 207: ! 208: void stmt::dcl() ! 209: /* ! 210: typecheck statement "this" in scope "curr_block->tbl" ! 211: */ ! 212: { ! 213: Pstmt ss; ! 214: Pname n; ! 215: Pname nn; ! 216: Pstmt ostmt = Cstmt; ! 217: ! 218: if(permanent == 3 && catch_delete_bugs) ! 219: error ('i', "stmt::dcl of a deleted stmt."); ! 220: ! 221: for (ss=this; ss; ss=ss->s_list) { ! 222: Pstmt old_loop, old_switch; ! 223: Cstmt = ss; ! 224: Ptable tbl = curr_block->memtbl; ! 225: //error('d',"stmt::dcl %k",ss->base); ! 226: switch (ss->base) { ! 227: case BREAK: ! 228: inline_restr |= 16; ! 229: if (curr_loop==0 && curr_switch==0) ! 230: error("break not in loop or switch"); ! 231: ss->reached(); ! 232: break; ! 233: ! 234: case CONTINUE: ! 235: inline_restr |= 32; ! 236: if (curr_loop == 0) error("continue not in loop"); ! 237: ss->reached(); ! 238: break; ! 239: ! 240: case DEFAULT: ! 241: if (curr_switch == 0) { ! 242: error("default not in switch"); ! 243: break; ! 244: } ! 245: if (curr_switch->has_default) error("two defaults in switch"); ! 246: curr_switch->has_default = ss; ! 247: ss->s->s_list = ss->s_list; ! 248: ss->s_list = 0; ! 249: ss->s->dcl(); ! 250: break; ! 251: ! 252: case SM: ! 253: { if (ss->e ==0) break; ! 254: TOK b = ss->e->base; ! 255: switch (b) { ! 256: case DUMMY: ! 257: ss->e = 0; ! 258: break; ! 259: // check for unused results ! 260: // don't check operators that are likely ! 261: // to be overloaded to represent "actions": ! 262: // ! ~ < <= > >= << >> ! 263: case EQ: ! 264: case NE: ! 265: case PLUS: ! 266: case MINUS: ! 267: case REF: ! 268: case DOT: ! 269: case MUL: ! 270: case DIV: ! 271: case ADDROF: ! 272: case AND: ! 273: case OR: ! 274: case ER: ! 275: case DEREF: ! 276: case ANDAND: ! 277: case OROR: ! 278: case NAME: ! 279: case VALUE: ! 280: if (ss->e->tp) break; // avoid looking at generated code ! 281: ss->e = ss->e->typ(tbl); ! 282: if (ss->e->base == CALL) break; ! 283: if (ss->e->tp->base != VOID) { ! 284: error('w',"result of%kE not used",b); ! 285: if (ss->e->not_simple()==0) ss->e = dummy; ! 286: } ! 287: break; ! 288: default: ! 289: ss->e = ss->e->typ(tbl); ! 290: } ! 291: break; ! 292: } ! 293: case RETURN: ! 294: { Pname fn = cc->nof; ! 295: Pfct f = Pfct(fn->tp); ! 296: Ptype rt = f->returns; ! 297: Pexpr v = ss->e; ! 298: //error('d',"rt %t",rt); ! 299: if (v != dummy) { ! 300: while (rt->base == TYPE) rt = Pbase(rt)->b_name->tp; ! 301: extern ref_initializer; ! 302: if (rt->base == RPTR) { ! 303: ref_initializer++; ! 304: v = v->typ(tbl); ! 305: ref_initializer--; ! 306: } else ! 307: v = v->typ(tbl); ! 308: ! 309: if (fn->n_oper==CTOR ! 310: || fn->n_oper==DTOR ! 311: || (rt->base==VOID && v->tp!=void_type)) { ! 312: error("unexpected return value"); ! 313: // refuse to return the value: ! 314: ss->e = dummy; ! 315: } ! 316: else { ! 317: lx: ! 318: switch (rt->base) { ! 319: case TYPE: ! 320: rt = Pbase(rt)->b_name->tp; ! 321: goto lx; ! 322: case RPTR: ! 323: switch (v->base) { ! 324: case NAME: ! 325: if (Pname(v)->n_scope==FCT ! 326: || Pname(v)->n_scope==ARG) ! 327: error('w',"R to localV returned"); ! 328: break; ! 329: case ICON: ! 330: case CCON: ! 331: case FCON: ! 332: case STRING: ! 333: if (Pptr(rt)->typ->tconst()==0) ! 334: error('w',"R to literal returned"); ! 335: } ! 336: v = ref_init(Pptr(rt),v,tbl); ! 337: if (v->base==G_CM ! 338: && v->e2->base==G_ADDROF ! 339: && v->e2->e2->base==NAME) ! 340: error('w',"R to temporary returned (return value is not lvalue or of wrongT)"); ! 341: case ANY: ! 342: break; ! 343: case COBJ: ! 344: if (v->base == DEREF) { ! 345: Pexpr v1 = v->e1; ! 346: if (v1->base==CAST) { ! 347: Pexpr v2 = v1->e1; ! 348: if (v2->base == G_CM) { // *(T)(e1,e2) => (e1,*(T)e2) ! 349: Pexpr v3 = v2->e2; ! 350: v2->e2 = v; ! 351: v2->tp = v->tp; ! 352: v = v2; ! 353: v1->e1 = v3; ! 354: } ! 355: } ! 356: } ! 357: if (f->f_result) { ! 358: if (v->base==G_CM && rt->check(v->tp,0/*ASSIGN*/)==0) ! 359: v = replace_temp(v,f->f_result); ! 360: else { ! 361: v = class_init(f->f_result->contents(),rt,v,tbl); ! 362: Pname rcn = rt->is_cl_obj(); ! 363: if (Pclass(rcn->tp)->has_itor()==0) { ! 364: // can happen for virtuals and for user defined conversions ! 365: v->tp = rt; ! 366: v = new expr(ASSIGN,f->f_result->contents(),v); ! 367: v->tp = rt; ! 368: } ! 369: } ! 370: } ! 371: else ! 372: v = class_init(0,rt,v,tbl); ! 373: break; ! 374: case PTR: ! 375: { Pexpr x = v; ! 376: v = ptr_init(Pptr(rt),v,tbl); ! 377: if (v->base == ADDROF ! 378: && v->e2->base == NAME ! 379: && Pname(v->e2)->n_stclass == AUTO) ! 380: error('w',"P to local variable%n returned",Pname(v->e2)); ! 381: // if (v==x ||v->e2==x) goto def; ! 382: if (Pchecked == 0) goto def; ! 383: goto ret_save; ! 384: // break; ! 385: } ! 386: case INT: ! 387: case CHAR: ! 388: case LONG: ! 389: case SHORT: ! 390: if (Pbase(rt)->b_unsigned ! 391: && v->base==UMINUS ! 392: && v->e2->base==ICON) ! 393: error('w',"negative retured fromF returning unsigned"); ! 394: default: ! 395: def: ! 396: { ! 397: Pexpr x = try_to_coerce(rt,v,"return value",tbl); ! 398: if (x) ! 399: v = x; ! 400: else if (rt->check(v->tp,ASSIGN)) ! 401: error("bad return valueT for%n:%t (%tX)",fn,v->tp,rt); ! 402: } ! 403: ! 404: } ! 405: ret_save: ! 406: ss->ret_tp = rt; ! 407: ss->e = v; ! 408: } ! 409: } ! 410: else { ! 411: if (rt->base != VOID) error("return valueX"); ! 412: } ! 413: ss->reached(); ! 414: break; ! 415: } ! 416: ! 417: case DO: // in DO the stmt is before the test ! 418: inline_restr |= 8; ! 419: old_loop = curr_loop; ! 420: curr_loop = ss; ! 421: if (ss->s->base == DCL) error("D as onlyS in do-loop"); ! 422: ss->s->dcl(); ! 423: ss->e = ss->e->typ(tbl); ! 424: ss->e = check_cond(ss->e,DO,tbl); ! 425: curr_loop = old_loop; ! 426: break; ! 427: ! 428: case WHILE: ! 429: inline_restr |= 8; ! 430: old_loop = curr_loop; ! 431: curr_loop = ss; ! 432: ss->e = ss->e->typ(tbl); ! 433: ss->e = check_cond(ss->e,WHILE,tbl); ! 434: if (ss->s->base == DCL) error("D as onlyS in while-loop"); ! 435: ss->s->dcl(); ! 436: curr_loop = old_loop; ! 437: break; ! 438: ! 439: case SWITCH: ! 440: { int ne = 0; ! 441: inline_restr |= 4; ! 442: old_switch = curr_switch; ! 443: curr_switch = ss; ! 444: ss->e = ss->e->typ(tbl); ! 445: ss->e = check_cond(ss->e,SWITCH,tbl); ! 446: if (ss->s->base == DCL) error("D as onlyS in switchS"); ! 447: { Ptype tt = ss->e->tp; ! 448: sii: ! 449: switch (tt->base) { ! 450: case TYPE: ! 451: tt = Pbase(tt)->b_name->tp; goto sii; ! 452: case EOBJ: ! 453: ne = Penum(Pbase(tt)->b_name->tp)->no_of_enumerators; ! 454: case ZTYPE: ! 455: case ANY: ! 456: case CHAR: ! 457: case SHORT: ! 458: case INT: ! 459: case LONG: ! 460: case FIELD: ! 461: break; ! 462: default: ! 463: error("%t switchE",ss->e->tp); ! 464: } ! 465: } ! 466: ss->s->dcl(); ! 467: if (ne) { /* see if the number of cases is "close to" ! 468: but not equal to the number of enumerators ! 469: */ ! 470: int i = 0; ! 471: Pstmt cs; ! 472: for (cs=ss->case_list; cs; cs=cs->case_list) i++; ! 473: if (i && i!=ne) { ! 474: if (ne < i) { ! 475: ee: error('w',"switch (%t)W %d cases (%d enumerators)",ss->e->tp,i,ne); ! 476: } ! 477: else { ! 478: switch (ne-i) { ! 479: case 1: if (3<ne) goto ee; ! 480: case 2: if (7<ne) goto ee; ! 481: case 3: if (23<ne) goto ee; ! 482: case 4: if (60<ne) goto ee; ! 483: case 5: if (99<ne) goto ee; ! 484: } ! 485: } ! 486: } ! 487: } ! 488: curr_switch = old_switch; ! 489: break; ! 490: } ! 491: case CASE: ! 492: if (curr_switch == 0) { ! 493: error("case not in switch"); ! 494: break; ! 495: } ! 496: ss->e = ss->e->typ(tbl); ! 497: ss->e->tp->num_ptr(CASE); ! 498: { Ptype tt = ss->e->tp; ! 499: iii: ! 500: switch (tt->base) { ! 501: case TYPE: ! 502: tt = Pbase(tt)->b_name->tp; goto iii; ! 503: case ZTYPE: ! 504: case ANY: ! 505: case CHAR: ! 506: case SHORT: ! 507: case INT: ! 508: case LONG: ! 509: case EOBJ: ! 510: Neval = 0; ! 511: long i = ss->e->eval(); ! 512: if (Neval == 0) { ! 513: Pstmt cs; ! 514: if (largest_int<i) error("long case value"); ! 515: for (cs=curr_switch->case_list; cs; cs=cs->case_list) { ! 516: if (cs->case_value == i) error("case %d used twice in switch",i); ! 517: } ! 518: ss->case_value = int(i); ! 519: ss->case_list = curr_switch->case_list; ! 520: curr_switch->case_list = ss; ! 521: } ! 522: else ! 523: error("bad case label: %s",Neval); ! 524: break; ! 525: default: ! 526: error("%t caseE",ss->e->tp); ! 527: } ! 528: } ! 529: // if (1) { ! 530: // Neval = 0; ! 531: // long i = ss->e->eval(); ! 532: // if (Neval == 0) { ! 533: // Pstmt cs; ! 534: // if (largest_int<i) error("long case value"); ! 535: // for (cs=curr_switch->case_list; cs; cs=cs->case_list) { ! 536: // if (cs->case_value == i) error("case %d used twice in switch",i); ! 537: // } ! 538: // ss->case_value = int(i); ! 539: // ss->case_list = curr_switch->case_list; ! 540: // curr_switch->case_list = ss; ! 541: // } ! 542: // else ! 543: // error("bad case label: %s",Neval); ! 544: // } ! 545: if (ss->s->s_list) error('i',"case%k",ss->s->s_list->base); ! 546: ss->s->s_list = ss->s_list; ! 547: ss->s_list = 0; ! 548: ss->s->dcl(); ! 549: break; ! 550: ! 551: case GOTO: ! 552: inline_restr |= 2; ! 553: ss->reached(); ! 554: case LABEL: ! 555: /* Insert label in function mem table; ! 556: labels have function scope. ! 557: */ ! 558: n = ss->d; ! 559: nn = cc->ftbl->insert(n,LABEL); ! 560: ! 561: /* Set a ptr to the mem table corresponding to the scope ! 562: in which the label actually occurred. This allows the ! 563: processing of goto's in the presence of ctors and dtors ! 564: */ ! 565: if (ss->base == LABEL) { ! 566: nn->n_realscope = curr_block->memtbl; ! 567: inline_restr |= 1; ! 568: } ! 569: ! 570: if (Nold) { ! 571: if (ss->base == LABEL) { ! 572: if (nn->n_initializer) error("twoDs of label%n",n); ! 573: nn->n_initializer = (Pexpr)1; ! 574: } ! 575: if (n != nn) ss->d = nn; ! 576: } ! 577: else { ! 578: if (ss->base == LABEL) nn->n_initializer = (Pexpr)1; ! 579: nn->where = ss->where; ! 580: } ! 581: if (ss->base == GOTO) ! 582: nn->use(); ! 583: else { ! 584: if (ss->s->s_list) error('i',"label%k",ss->s->s_list->base); ! 585: ss->s->s_list = ss->s_list; ! 586: ss->s_list = 0; ! 587: nn->assign(); ! 588: } ! 589: if (ss->s) ss->s->dcl(); ! 590: break; ! 591: ! 592: case IF: ! 593: { ! 594: Pexpr ee = ss->e->typ(tbl); ! 595: if (ee->base == ASSIGN) { ! 596: Neval = 0; ! 597: (void)ee->e2->eval(); ! 598: if (Neval == 0) ! 599: error('w',"constant assignment in condition"); ! 600: } ! 601: ss->e = ee = check_cond(ee,IF,tbl); ! 602: ! 603: if (ss->s->base == DCL) error("D as onlyS after `if'"); ! 604: ! 605: // pointer to member returns with a tp set to 0 ! 606: if ( ee->tp ) switch (ee->tp->base) { ! 607: case INT: ! 608: case EOBJ: ! 609: case ZTYPE: ! 610: { long i; ! 611: Neval = 0; ! 612: i = ee->eval(); ! 613: ! 614: if (Neval == 0) { ! 615: Pstmt sl = ss->s_list; ! 616: if (i) { ! 617: DEL(ss->else_stmt); ! 618: ss->s->dcl(); ! 619: *ss = *ss->s; ! 620: } ! 621: else { ! 622: DEL(ss->s); ! 623: if (ss->else_stmt) { ! 624: ss->else_stmt->dcl(); ! 625: *ss = *ss->else_stmt; ! 626: } ! 627: else { ! 628: ss->base = SM; ! 629: ss->e = dummy; ! 630: ss->s = 0; ! 631: } ! 632: } ! 633: ss->s_list = sl; ! 634: continue; ! 635: } ! 636: } ! 637: } ! 638: ss->s->dcl(); ! 639: if (ss->else_stmt) { ! 640: if (ss->else_stmt->base == DCL) error("D as onlyS after `else'"); ! 641: ss->else_stmt->dcl(); ! 642: } ! 643: break; ! 644: } ! 645: case FOR: ! 646: inline_restr |= 8; ! 647: old_loop = curr_loop; ! 648: curr_loop = ss; ! 649: if (ss->for_init) { ! 650: Pstmt fi = ss->for_init; ! 651: switch (fi->base) { ! 652: case SM: ! 653: if (fi->e == dummy) { ! 654: ss->for_init = 0; ! 655: break; ! 656: } ! 657: default: ! 658: fi->dcl(); ! 659: break; ! 660: case DCL: ! 661: // if () ! 662: // { ! 663: // // for (dcl; e1; e2) stmt1 stmt2 ! 664: // // => { dcl; for( ; e1; e2) stmt1 } stmt2 ! 665: // ss->base = BLOCK; ! 666: // ss->d = fi->d; ! 667: // ss->s = new forstmt(ss->where,new estmt(SM,ss->where,dummy,0),ss->e,ss->e2,ss->s); ! 668: // Pblock(ss)->dcl(tbl); ! 669: // continue; ! 670: // } ! 671: // else { ! 672: fi->dcl(); ! 673: switch (fi->base) { ! 674: case BLOCK: ! 675: { ! 676: // { ... for( { a } b ; c) d ; e } ! 677: // => { ... { a for ( ; b ; c) d ; e }} ! 678: Pstmt tmp = new stmt (SM,curloc,0); ! 679: *tmp = *ss; // tmp = for ! 680: tmp->for_init = 0; ! 681: *ss = *fi; // ss = { } ! 682: if (ss->s) ! 683: ss->s->s_list = tmp; ! 684: else ! 685: ss->s = tmp; ! 686: curr_block = Pblock(ss); ! 687: tbl = curr_block->memtbl; ! 688: Cstmt = ss = tmp; // rest of for and s_list ! 689: break; ! 690: } ! 691: } ! 692: // } ! 693: ! 694: } ! 695: } ! 696: if (ss->e == dummy) ! 697: ss->e = 0; ! 698: else { ! 699: ss->e = ss->e->typ(tbl); ! 700: ss->e = check_cond(ss->e,FOR,tbl); ! 701: } ! 702: if (ss->s->base == DCL) error("D as onlyS in for-loop"); ! 703: ss->s->dcl(); ! 704: ss->e2 = (ss->e2 == dummy) ? 0 : ss->e2->typ(tbl); ! 705: curr_loop = old_loop; ! 706: break; ! 707: ! 708: case DCL: /* declaration after statement */ ! 709: { ! 710: /* collect all the contiguous DCL nodes from the ! 711: head of the s_list. find the next statement ! 712: */ ! 713: int non_trivial = 0; ! 714: int count = 0; ! 715: Pname tail = ss->d; ! 716: for (Pname nn=tail; nn; nn=nn->n_list) { ! 717: // find tail; ! 718: // detect non-trivial declarations ! 719: count++; ! 720: ! 721: if (nn->n_list) tail = nn->n_list; ! 722: Pname n = tbl->look(nn->string,0); ! 723: ! 724: if (n && n->n_table==tbl) non_trivial = 2; ! 725: if (non_trivial == 2) continue; ! 726: if ((nn->n_sto==STATIC && nn->tp->base!=FCT) ! 727: || nn->tp->is_ref() ! 728: || (nn->tp->tconst() && fct_const==0)) { ! 729: non_trivial = 2; ! 730: continue; ! 731: } ! 732: ! 733: Pexpr in = nn->n_initializer; ! 734: if (in) ! 735: switch (in->base) { ! 736: case ILIST: ! 737: case STRING: ! 738: non_trivial = 2; ! 739: continue; ! 740: default: ! 741: non_trivial = 1; ! 742: } ! 743: Pname cln = nn->tp->is_cl_obj(); ! 744: if (cln == 0) cln = cl_obj_vec; ! 745: if (cln == 0) continue; ! 746: if (Pclass(cln->tp)->has_ctor()) { ! 747: non_trivial = 2; ! 748: continue; ! 749: } ! 750: if (Pclass(cln->tp)->has_dtor()) non_trivial = 2; ! 751: } ! 752: ! 753: while( ss->s_list && ss->s_list->base==DCL ) { ! 754: Pstmt sx = ss->s_list; ! 755: tail = tail->n_list = sx->d; // add to tail ! 756: for (nn=sx->d; nn; nn=nn->n_list) { ! 757: // find tail; ! 758: // detect non-trivial declarations ! 759: count++; ! 760: if (nn->n_list) tail = nn->n_list; ! 761: Pname n = tbl->look(nn->string,0); ! 762: if (n && n->n_table==tbl) non_trivial = 2; ! 763: if (non_trivial == 2) continue; ! 764: if ((nn->n_sto==STATIC && nn->tp->base!=FCT) ! 765: || nn->tp->is_ref() ! 766: || (nn->tp->tconst() && fct_const==0)) { ! 767: non_trivial = 2; ! 768: continue; ! 769: } ! 770: Pexpr in = nn->n_initializer; ! 771: if (in) ! 772: switch (in->base) { ! 773: case ILIST: ! 774: case STRING: ! 775: non_trivial = 2; ! 776: continue; ! 777: } ! 778: non_trivial = 1; ! 779: Pname cln = nn->tp->is_cl_obj(); ! 780: if (cln == 0) cln = cl_obj_vec; ! 781: if (cln == 0) continue; ! 782: if (Pclass(cln->tp)->has_ctor()) { ! 783: non_trivial = 2; ! 784: continue; ! 785: } ! 786: if (Pclass(cln->tp)->has_dtor()) continue; ! 787: } ! 788: ss->s_list = sx->s_list; ! 789: /* delete sx; */ ! 790: } ! 791: ! 792: Pstmt next_st = ss->s_list; ! 793: if (non_trivial==2 // must ! 794: || (non_trivial==1 // might ! 795: && ( curr_block->own_tbl==0 // why not? ! 796: || inline_restr&3 /* label seen */) ! 797: ) ! 798: ) { ! 799: if (curr_switch && non_trivial==2) { ! 800: Pstmt cs = curr_switch->case_list; ! 801: Pstmt ds = curr_switch->has_default; ! 802: Pstmt bl; ! 803: if (cs == 0) ! 804: bl = ds; ! 805: else if (ds == 0) ! 806: bl = cs; ! 807: else if (cs->where.line<ds->where.line) ! 808: bl = ds; ! 809: else ! 810: bl = cs; ! 811: ! 812: if ((bl==0 || bl->s->base!=BLOCK) && curr_switch->s->memtbl==tbl) ! 813: error('s',"non trivialD in switchS (try enclosing it in a block)"); ! 814: } ! 815: ! 816: /* Create a new block, ! 817: put all the declarations at the head, ! 818: and the remainder of the slist as the ! 819: statement list of the block. ! 820: */ ! 821: ss->base = BLOCK; ! 822: ! 823: /* check that there are no redefinitions since the last ! 824: "real" (user-written, non-generated) block ! 825: */ ! 826: for( nn=ss->d; nn; nn=nn->n_list ) { ! 827: Pname n; ! 828: if( curr_block->own_tbl ! 829: && (n=curr_block->memtbl->look(nn->string,0)) ! 830: && n->n_table->real_block==curr_block->memtbl->real_block ! 831: && n->tp->base!=FCT && n->tp->base!=OVERLOAD ! 832: && nn->lex_level == n->lex_level ) ! 833: error("twoDs of%n",n); ! 834: } ! 835: ! 836: /* attach the remainder of the s_list ! 837: as the statement part of the block. ! 838: */ ! 839: ss->s = next_st; ! 840: ss->s_list = 0; ! 841: ! 842: /* create the table in advance, in order to set the ! 843: real_block ptr to that of the enclosing table ! 844: */ ! 845: ss->memtbl = new table(count+4,tbl,0); ! 846: ss->memtbl->real_block = curr_block->memtbl->real_block; ! 847: Pblock(ss)->dcl(ss->memtbl); ! 848: } ! 849: else { /* to reduce the number of symbol tables, ! 850: do not make a new block, ! 851: instead insert names in enclosing block, ! 852: and make the initializers into expression ! 853: statements. ! 854: */ ! 855: Pstmt sss = ss; ! 856: for( nn=ss->d; nn; nn=nn->n_list ) { ! 857: Pname n; ! 858: //error('d',"nn %n",nn); ! 859: if( curr_block->own_tbl ! 860: && (n=curr_block->memtbl->look(nn->string,0)) ! 861: && n->n_table->real_block==curr_block->memtbl->real_block ! 862: && n->tp->base!=FCT && n->tp->base!=OVERLOAD ! 863: && nn->lex_level == n->lex_level ) ! 864: { ! 865: printf( "\ndump tables: bl_level: %d", bl_level ); ! 866: /* ! 867: //extern void display_table( Ptable,int=0 );display_table(curr_block->memtbl); ! 868: //extern void display_name( Pname ); display_name( nn ); display_name(n); ! 869: */ ! 870: error("twoDs of%n",n); ! 871: } ! 872: //error("twoDs of%n",n); ! 873: /*Pname */n = nn->dcl(tbl,FCT); ! 874: ! 875: if (n == 0) { ! 876: if (ss) { ! 877: ss->base = SM; ! 878: ss->e = 0; ! 879: } ! 880: continue; ! 881: } ! 882: ! 883: Pexpr in = n->n_initializer; ! 884: n->n_initializer = 0; ! 885: ! 886: if (ss) { ! 887: sss->base = SM; ! 888: ss = 0; ! 889: } ! 890: else ! 891: sss = sss->s_list = new estmt(SM,sss->where,0,0); ! 892: if (in) { ! 893: switch (in->base) { ! 894: case G_CALL: /* constructor? */ ! 895: { ! 896: Pname fn = in->fct_name; ! 897: if (fn && fn->n_oper==CTOR) break; ! 898: } ! 899: default: ! 900: in = new expr(ASSIGN,n,in); ! 901: in->tp = n->tp; ! 902: } ! 903: // sss->e = in->typ(tbl); ! 904: sss->e = in; ! 905: } ! 906: else ! 907: sss->e = dummy; ! 908: } ! 909: ! 910: ss = sss; ! 911: ss->s_list = next_st; ! 912: } ! 913: break; ! 914: } ! 915: ! 916: case BLOCK: ! 917: Pblock(ss)->dcl(tbl); ! 918: break; ! 919: ! 920: case ASM: ! 921: /* save string */ ! 922: { ! 923: char* s = (char*)ss->e; ! 924: int ll = strlen(s); ! 925: char* s2 = new char[ll+1]; ! 926: strcpy(s2,s); ! 927: ss->e = Pexpr(s2); ! 928: break; ! 929: } ! 930: default: ! 931: error('i',"badS(%p %d)",ss,ss->base); ! 932: } ! 933: } ! 934: Cstmt = ostmt; ! 935: } ! 936: ! 937: extern int in_class_dcl; ! 938: void block::dcl(Ptable tbl) ! 939: /* ! 940: Note: for a block without declarations memtbl denotes the table ! 941: for the enclosing scope. ! 942: A function body has its memtbl created by fct::dcl(). ! 943: */ ! 944: { ! 945: int bit_old = bit_offset; ! 946: int byte_old = byte_offset; ! 947: int max_old = max_align; ! 948: Pblock block_old = curr_block; ! 949: ! 950: if (base != BLOCK) error('i',"block::dcl(%d)",base); ! 951: ! 952: curr_block = this; ! 953: //error('d',"block %k %k",d?d->base:0,s?s->base:0); ! 954: if (d) { ! 955: own_tbl = 1; ! 956: if (memtbl == 0) { ! 957: int nmem = d->no_of_names()+4; ! 958: memtbl = new table(nmem,tbl,0); ! 959: memtbl->real_block = this; ! 960: /* this is a "real" block from the ! 961: source text, and not one created by DCL's ! 962: inside a block. */ ! 963: } ! 964: else ! 965: if (memtbl != tbl) error('i',"block::dcl(?)"); ! 966: ! 967: Pname nx; ! 968: for (Pname n=d; n; n=nx) { ! 969: nx = n->n_list; ! 970: n->dcl(memtbl,FCT); ! 971: switch (n->tp->base) { ! 972: case CLASS: ! 973: case ANON: ! 974: case ENUM: ! 975: break; ! 976: default: ! 977: delete n; ! 978: } ! 979: } ! 980: } ! 981: else ! 982: memtbl = tbl; ! 983: ! 984: if (s) { ! 985: Pname odcl = Cdcl; ! 986: Pname m; ! 987: int i; ! 988: ! 989: s->dcl(); ! 990: ! 991: if (own_tbl) ! 992: for (m=memtbl->get_mem(i=1); m; m=memtbl->get_mem(++i)) { ! 993: Ptype t = m->tp; ! 994: ! 995: if (in_class_dcl) m->lex_level -= 1; ! 996: ! 997: if (t == 0) { ! 998: if (m->n_assigned_to == 0) ! 999: error("label %sU",m->string); ! 1000: if (m->n_used == 0) ! 1001: error('w',"label %s not used", m->string); ! 1002: continue; ! 1003: } ! 1004: ll: ! 1005: switch (t->base) { ! 1006: case TYPE: t = Pbase(t)->b_name->tp; goto ll; ! 1007: case CLASS: ! 1008: case ANON: ! 1009: case ENUM: ! 1010: case FCT: ! 1011: case VEC: continue; ! 1012: } ! 1013: ! 1014: if (m->n_addr_taken == 0) { ! 1015: if (m->n_used) { ! 1016: if (m->n_assigned_to) { ! 1017: } ! 1018: else { ! 1019: switch (m->n_scope) { ! 1020: case FCT: ! 1021: Cdcl = m; ! 1022: if (m->string[0] != '_' && m->string[1] != '_' ) ! 1023: error('w',&m->where,"%n used but not set",m); ! 1024: } ! 1025: } ! 1026: } ! 1027: else { ! 1028: if (m->n_assigned_to) { ! 1029: } ! 1030: else if (m->string[0]!='_' || m->string[1]!='_') { ! 1031: switch (m->n_scope) { ! 1032: case ARG: ! 1033: case FCT: ! 1034: Cdcl = m; ! 1035: error('w',&m->where,"%n not used",m); ! 1036: } ! 1037: } ! 1038: } ! 1039: } ! 1040: } ! 1041: Cdcl = odcl; ! 1042: } ! 1043: ! 1044: d = 0; ! 1045: ! 1046: if (bit_offset) byte_offset += SZ_WORD; ! 1047: bit_offset = bit_old; ! 1048: byte_offset = byte_old; ! 1049: curr_block = block_old; ! 1050: } ! 1051: ! 1052: extern int ZB_BOUNDARY; ! 1053: ! 1054: void name::field_align() ! 1055: /* ! 1056: adjust alignment ! 1057: */ ! 1058: { ! 1059: Pbase fld = (Pbase) tp; ! 1060: ! 1061: int a; ! 1062: a = (F_SENSITIVE) ? fld->b_fieldtype->align() : ZB_BOUNDARY; ! 1063: if (max_align < a) ! 1064: max_align = a; ! 1065: ! 1066: if (fld->b_bits == 0) { /* # force word alignment # */ ! 1067: int b; ! 1068: if (bit_offset && bit_offset != ZB_BOUNDARY * BI_IN_BYTE) ! 1069: fld->b_bits = (BI_IN_BYTE * ZB_BOUNDARY) - bit_offset; ! 1070: else if (b = byte_offset % ZB_BOUNDARY) ! 1071: fld->b_bits = b * BI_IN_BYTE; ! 1072: /* # else # */ ! 1073: /* # fld->b_bits = BI_IN_WORD; # */ ! 1074: if (max_align < ZB_BOUNDARY) ! 1075: max_align = ZB_BOUNDARY; ! 1076: } else if (bit_offset == 0) { /* # take care of part of word # */ ! 1077: int b = byte_offset % ZB_BOUNDARY; ! 1078: if (b) { ! 1079: byte_offset -= b; ! 1080: bit_offset = b * BI_IN_BYTE; ! 1081: } ! 1082: } ! 1083: /*#error('d',"byteoff %d bitoff %d bits %d",byte_offset,bit_offset,fld->b_bits); #*/ ! 1084: int x = (bit_offset += fld->b_bits); ! 1085: ! 1086: if (BI_IN_WORD < x) { ! 1087: fld->b_offset = 0; ! 1088: byte_offset += SZ_WORD; ! 1089: bit_offset = fld->b_bits; ! 1090: } else { ! 1091: fld->b_offset = bit_offset; ! 1092: if (BI_IN_WORD == x) { ! 1093: bit_offset = 0; ! 1094: byte_offset += SZ_WORD; ! 1095: } else ! 1096: bit_offset = x; ! 1097: } ! 1098: n_offset = byte_offset; ! 1099: } ! 1100: ! 1101: /* ODI notes -- ! 1102: delete bug catching code. ! 1103: fix to bitfield alignment on 68K ! 1104: */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.