![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to expr.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / pi|
Return to expr.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / pi |
1.1 ! root 1: #include "expr.pri" ! 2: #include "gram.h" ! 3: #include "symbol.h" ! 4: #include "format.pub" ! 5: #include "frame.pri" ! 6: #include "phrase.pub" ! 7: #include "symtab.pub" ! 8: #include "core.pub" ! 9: #include <CC/signal.h> /* floating point exceptions */ ! 10: SRCFILE("expr.c") ! 11: ! 12: #ifdef V9 ! 13: #define SIG_TYP SIG_ARG_TYP ! 14: #endif ! 15: ! 16: char *OpName(Op op) ! 17: { ! 18: switch(op){ ! 19: case O_DEREF: return "*"; ! 20: case O_REF: return "&"; ! 21: case O_INDEX: return "[]"; ! 22: case O_DOT: return "."; ! 23: case O_ARROW: return "->"; ! 24: case O_PLUS: return "+"; ! 25: case O_MINUS: return "-"; ! 26: case O_MULT: return "*"; ! 27: case O_DIV: return "/"; ! 28: case O_CALL: return "()"; ! 29: case O_MOD: return "%"; ! 30: case O_ASSIGN: return "="; ! 31: case O_COMMA: return ","; ! 32: case O_SIZEOF: return "sizeof"; ! 33: case O_TYPEOF: return "typeof"; ! 34: case O_QINDEX: return "[?]"; ! 35: case O_CAST: return "(cast)"; ! 36: case O_QCAST: return " ?"; ! 37: case O_QSTRUCT: return "struct ?"; ! 38: case O_QENUM: return "enum ?"; ! 39: case O_EQ: return "=="; ! 40: case O_NE: return "!="; ! 41: case O_LT: return "<"; ! 42: case O_GT: return ">"; ! 43: case O_LE: return "<="; ! 44: case O_GE: return ">="; ! 45: case O_LOGAND: return "&&"; ! 46: case O_LOGOR: return "||"; ! 47: case O_LOGNOT: return "!"; ! 48: case O_BITAND: return "&"; ! 49: case O_BITOR: return "|"; ! 50: case O_BITXOR: return "^"; ! 51: case O_1SCOMP: return "~"; ! 52: case O_FABS: return "fabs"; ! 53: case O_ENV: return "{}"; ! 54: case O_RANGE: return ".."; ! 55: case O_SPECIAL: return "special"; ! 56: case O_LSHIFT: return "<<"; ! 57: case O_RSHIFT: return ">>"; ! 58: default: return Name( "Op=%d", op ); ! 59: } ! 60: } ! 61: ! 62: int Prec( Op op ) /* for Expr::text() - not gram.y */ ! 63: { ! 64: switch(op){ ! 65: case O_ENV: return 1; ! 66: case O_CALL: ! 67: case O_INDEX: ! 68: case O_DOT: ! 69: case O_ARROW: return 2; ! 70: case O_MULT: ! 71: case O_DIV: ! 72: case O_MOD: return 3; ! 73: case O_PLUS: ! 74: case O_MINUS: return 4; ! 75: case O_LSHIFT: ! 76: case O_RSHIFT: return 5; ! 77: case O_LT: ! 78: case O_GT: ! 79: case O_LE: ! 80: case O_GE: return 6; ! 81: case O_EQ: ! 82: case O_NE: return 7; ! 83: case O_BITAND: return 8; ! 84: case O_BITXOR: return 9; ! 85: case O_BITOR: return 10; ! 86: case O_LOGAND: return 11; ! 87: case O_LOGOR: return 12; ! 88: case O_ASSIGN: return 13; ! 89: case O_COMMA: return 14; ! 90: case O_RANGE: return 15; ! 91: default: return 16; ! 92: } ! 93: } ! 94: ! 95: Expr *E_Id(char *id ) { return new Expr(E_ID,0,0,0,0,id,0,0); } ! 96: ! 97: Expr *E_Sym(Symbol *s ) { return new Expr(E_SYMNODE,0,0,0,0,0,0,s); } ! 98: ! 99: Expr *E_Unary(Op unary, Expr *sub) { return new Expr(E_UNARY,unary,sub,0,0,0,0,0); } ! 100: ! 101: Expr *E_Binary(Expr*l,Op binary,Expr*r) ! 102: { return new Expr(E_BINARY,binary,l,r,0,0,0,0); } ! 103: ! 104: Expr *E_IConst(long i) { return new Expr(E_LCONST,0,0,0,i,Token,LONG,0); } ! 105: ! 106: Expr *E_DConst(double d) { return new Expr(E_DCONST,0,0,0,d,Token,DOUBLE,0); } ! 107: ! 108: char *Expr::floaterror() ! 109: { ! 110: return val.floaterror(); ! 111: } ! 112: ! 113: char *Expr::under(Expr *e) ! 114: { ! 115: if( e->edisc != E_BINARY || Prec(e->op) < Prec(op) ) return e->text(); ! 116: return sf( "(%s)", e->text() ); ! 117: } ! 118: ! 119: Expr::Expr() {} ! 120: ! 121: Expr::Expr( EDisc d, Op o, Expr* s1, Expr* s2, Cslfd c, char* s, int t, Symbol *v) ! 122: { ! 123: type.pcc = t; ! 124: edisc = d; ! 125: op = o; ! 126: sub1 = s1; ! 127: sub2 = s2; ! 128: val = c; ! 129: id = s ? sf("%s",s) : ""; ! 130: sym = v; ! 131: evalerr = 0; ! 132: spy = 0; ! 133: addr = 0; ! 134: bitaddr = 0; ! 135: trace( "Expr(edisc=%d,op=%s,sub1=%d,sub2=%d,val.lng=%d,id=%s,symbol=%d", ! 136: edisc, OpName(op), sub1, sub2, val.lng, id?id:"", v); ! 137: } ! 138: ! 139: char *Expr::left(Expr *e) ! 140: { ! 141: switch( e->edisc ){ ! 142: case E_BINARY: switch( e->op ){ ! 143: case O_INDEX: ! 144: case O_DOT: ! 145: case O_ARROW: return e->text(); ! 146: } ! 147: case E_UNARY: return sf( "(%s)", e->text() ); ! 148: default: return e->text(); ! 149: } ! 150: } ! 151: ! 152: char *Expr::textunary() ! 153: { ! 154: trace( "%d.textunary()", this ); OK("textunary"); ! 155: switch( op ){ ! 156: case O_QCAST: ! 157: case O_QSTRUCT: ! 158: case O_QENUM: ! 159: return sf("(%0.*s%s )%s",val.lng,"*******",OpName(op),sub1->text()); ! 160: case O_CAST: ! 161: return sf("(%s)%s",type.text(),sub1->text()); ! 162: case O_QINDEX: ! 163: return sf( "%s[ ? ]", left(sub1) ); ! 164: case O_SIZEOF: ! 165: case O_TYPEOF: ! 166: case O_FABS: ! 167: case O_SPECIAL: ! 168: return sf( "%s(%s)", OpName(op), sub1->text() ); ! 169: } ! 170: if( sub1->edisc==E_BINARY && Prec(sub1->op)>=Prec(O_MULT) ) ! 171: return sf( "%s(%s)", OpName(op), sub1->text() ); ! 172: return sf( "%s%s", OpName(op), sub1->text() ); ! 173: } ! 174: ! 175: char *Expr::textbinary() ! 176: { ! 177: trace( "%d.textbinary()", this ); OK("textbinary"); ! 178: switch( op ){ ! 179: case O_ENV: ! 180: return sf( "{%s}%s", sub1->text(), sub2->text() ); ! 181: case O_COMMA: /* ??? */ ! 182: return sf( "%s,%s", sub1->text(), sub2->text() ); ! 183: case O_CALL: ! 184: return sf( "%s(%s)", sub1->text(), sub2?sub2->text():"" ); ! 185: case O_ASSIGN: ! 186: return sf("(%s:=%s)", left(sub1), sub2->text() ); ! 187: case O_INDEX: ! 188: return sf("%s[%s]", left(sub1), sub2->text() ); ! 189: case O_DOT: ! 190: case O_ARROW: ! 191: return sf("%s%s%s", left(sub1), OpName(op), sub2->text()); ! 192: } ! 193: if( sub1->edisc==E_BINARY && Prec(sub1->op) == Prec(op) ) ! 194: return sf("%s%s%s", sub1->text(), OpName(op), under(sub2)); ! 195: return sf("%s%s%s", under(sub1), OpName(op), under(sub2)); ! 196: } ! 197: ! 198: char *Expr::text() ! 199: { ! 200: trace( "%d.text()", this ); OK("text"); ! 201: switch( edisc ){ ! 202: case E_DCONST: if( !id || !*id ) return sf( "%g", val.dbl ); ! 203: case E_LCONST: if( !id || !*id ) return sf( "%d", val.lng ); ! 204: case E_ID: return id; ! 205: case E_UNARY: return textunary(); ! 206: case E_BINARY: return textbinary(); ! 207: case E_SYMNODE: ! 208: if( !sym || !sym->_text ) return "<symbol>"; ! 209: return sym->_text; ! 210: } ! 211: return "<expr>"; ! 212: } ! 213: ! 214: int Expr::format() ! 215: { ! 216: trace( "%d.format() %s %s", this, text(), type.text() ); OK(F_HEX); ! 217: return type.format(); ! 218: } ! 219: ! 220: void Expr::reformat(int over, int stars) ! 221: { ! 222: trace("%d.reformat(0x%X,%d) %s %s",this,over,stars,text(),type.text()); VOK; ! 223: switch( edisc ){ ! 224: case E_ID: break; // shut up cfront ! 225: case E_LCONST: ! 226: case E_DCONST: ! 227: type.reformat(over); ! 228: return; ! 229: case E_SYMNODE: ! 230: IF_LIVE(!sym) return; ! 231: ((Var*)sym)->type.reformat(over,stars); ! 232: return; ! 233: case E_UNARY: ! 234: switch( op ){ ! 235: case O_REF: ! 236: case O_SIZEOF: ! 237: case O_CAST: ! 238: type.reformat(over,stars); ! 239: return; ! 240: case O_DEREF: ! 241: sub1->reformat(over,stars+1); ! 242: return; ! 243: case O_MINUS: ! 244: case O_1SCOMP: ! 245: case O_LOGNOT: ! 246: sub1->reformat(over,stars); ! 247: return; ! 248: } ! 249: case E_BINARY: ! 250: switch( op ){ ! 251: case O_DIV: ! 252: case O_MULT: ! 253: case O_MOD: ! 254: case O_PLUS: ! 255: case O_MINUS: ! 256: case O_BITAND: ! 257: case O_BITOR: ! 258: case O_BITXOR: ! 259: sub1->reformat(over,stars); /* fall thru */ ! 260: case O_ARROW: ! 261: case O_DOT: ! 262: case O_COMMA: ! 263: sub2->reformat(over,stars); ! 264: return; ! 265: case O_ASSIGN: ! 266: case O_ENV: ! 267: case O_LSHIFT: ! 268: case O_RSHIFT: ! 269: sub1->reformat(over,stars); ! 270: return; ! 271: case O_INDEX: ! 272: sub1->reformat(over,stars+1); ! 273: return; ! 274: case O_CALL: ! 275: Func *func = (Func*) sub1->sym; ! 276: if( func->ok() ) ! 277: func->type.decref()->reformat(over,stars); ! 278: return; ! 279: } ! 280: } ! 281: } ! 282: ! 283: char *Expr::ascii(Frame *frame, int limit ) ! 284: { ! 285: static char buf[256]; ! 286: char *raw, *fail = "fail"; // fail is unique ! 287: Bls esc( "\"" ); ! 288: int i; ! 289: ! 290: trace("%d.ascii(%d)", this, frame); OK("ascii"); ! 291: if( !val.lng ) return "0"; ! 292: raw = frame->peekstring(val.lng, fail); ! 293: if( raw == fail ) return "<string error>"; ! 294: for( i = 0; raw[i] && i<limit; ++i ) ! 295: esc.af( "%s", FmtByte(raw[i]) ); ! 296: if( raw[i] ) esc.af("..."); ! 297: sprintf(buf, "%s\"", esc.text); ! 298: return buf; ! 299: } ! 300: ! 301: char *Expr::enumformat() ! 302: { ! 303: Var *m; ! 304: ! 305: trace( "%d.enumformat()", this ); OK("enumformat"); ! 306: TypMems tm(type.utype()); ! 307: while( m = tm.gen() ) ! 308: if( m->range.lo == val.lng ) ! 309: return m->text(); ! 310: return sf( "(enum %s)%d", type.utype()?type.utype()->text():"?", val.lng ); ! 311: } ! 312: ! 313: char *Expr::utypeformat(Frame *frame, Bls &build) ! 314: { ! 315: Var *m, g(0,0,0,0,"$pi.Expr::utypeformat"); ! 316: int i = 0; ! 317: Expr e; /* use constructor to guarantee zeros? */ ! 318: ! 319: trace("%d.utypeformat(%d,%d)", this, frame, &build); OK("utypeformat"); ! 320: build.af("{"); ! 321: TypMems tm(type.utype()); ! 322: while( m = tm.gen() ) if( m->showorhide==SHOW ){ ! 323: Bls local; ! 324: g = *m; ! 325: g._disc = U_GLB; ! 326: DType t = g.type; ! 327: e.bitaddr = 0; ! 328: if( t.pcc==BITS || t.pcc==UBITS ){ ! 329: e.bitaddr = g.range.lo; ! 330: g.range.lo = 0; ! 331: } ! 332: g.range.lo += addr; ! 333: e.edisc = E_SYMNODE; ! 334: e.sym = &g; ! 335: e.spy = 0; ! 336: e.op = 0; ! 337: build.af( "%s%s", i++?",":"", e.evaltext(frame,local) ); ! 338: } ! 339: build.af( "}" ); ! 340: return build.text; ! 341: } ! 342: ! 343: char *Expr::evaltextcomma(Frame *frame, Bls &build) ! 344: { ! 345: trace("%d.evaltextcomma(%d,%d)",this,frame,&build);OK("evaltextcomma"); ! 346: sub1->evaltext(frame,build); ! 347: if( evalerr = sub1->evalerr ) return build.text; ! 348: build.af(", "); ! 349: sub2->evaltext(frame,build); ! 350: evalerr = sub2->evalerr; ! 351: type = sub2->type; ! 352: val = sub2->val; ! 353: return build.text; ! 354: } ! 355: ! 356: char *Expr::evaltext(Frame *frame, Bls &build) ! 357: { ! 358: trace( "%d.evaltext(%d,%d)", this, frame, &build ); OK("evaltext"); ! 359: evalerr = 0; ! 360: doevaltext(frame, build); ! 361: if( evalerr ) setspy(0); ! 362: if( spy ) spy->b = build.text; ! 363: return build.text; ! 364: } ! 365: ! 366: char *Expr::doevaltext(Frame *frame, Bls &build) ! 367: { ! 368: char *error, *t; ! 369: Format form(0, frame->core->symtab()); ! 370: ! 371: trace( "%d.doevaltext(%d,%d)", this, frame, &build ); OK("doevaltext"); ! 372: switch( op ){ ! 373: case O_QINDEX: ! 374: case O_QCAST: ! 375: case O_QENUM: ! 376: case O_QSTRUCT: ! 377: build.af( "%s", text() ); ! 378: return build.text; ! 379: } ! 380: if( op == O_COMMA ) return evaltextcomma(frame,build); ! 381: if( error = eval(frame) ){ ! 382: build.af( "%s: %s", text(), error ); ! 383: evalerr = 1; ! 384: return build.text; ! 385: } ! 386: if( spy ) build.af(">>> "); ! 387: build.af( "%s", text() ); ! 388: if( type.pcc == VOID ){ ! 389: build.af( "=void" ); ! 390: return build.text; ! 391: } ! 392: form.format = format(); ! 393: if( form.format&(F_DOUBLE|F_FLOAT) && val.floaterror() ){ ! 394: build.af( "=<%s>", val.floaterror() ); ! 395: form.format &= ~(F_DOUBLE|F_FLOAT); ! 396: form.format |= F_NONE; ! 397: } ! 398: if( form.format&F_ARY ) val.lng = addr; ! 399: if( *(t = form.f(val.lng,val.dbl)) ) ! 400: build.af( "=%s", t ); ! 401: if( form.format&F_UTYPE ){ ! 402: build.af( "="); ! 403: utypeformat(frame,build); ! 404: } ! 405: if( form.format&F_ENUM ) ! 406: build.af( "=%s", enumformat() ); ! 407: if( form.format&F_STRING ) ! 408: build.af( "=%s", ascii(frame, form.format&F_LONGSTRING?200:20) ); ! 409: return build.text; ! 410: } ! 411: ! 412: char *Expr::getval( Frame *frame ) /* addr already fixed */ ! 413: { ! 414: trace( "%d.getval(%d)", this, frame ); OK("getval"); ! 415: if( sym ){ ! 416: switch( sym->disc() ){ ! 417: case U_FUNC: ! 418: type = ((Func*)sym)->type; ! 419: break; ! 420: default: ! 421: type = ((Var*)sym)->type; ! 422: ((Var*)sym)->show(SHOW); ! 423: } ! 424: } ! 425: if( !addr ) return "addressing error: 0"; ! 426: addr += (bitaddr>>5)*4; ! 427: if( type.isscalar() ){ ! 428: Cslfd *m = frame->peek(addr,0); ! 429: if( !m ) return sf( "addressing error: 0x%X", addr ); ! 430: val = *m; ! 431: } ! 432: if( type.isscalar() ) switch( type.pcc ){ ! 433: case BITS: ! 434: case UBITS: val.lng = (val.lng>>(bitaddr&31)); ! 435: int power = 1<<type.dim; ! 436: val.lng &= power-1; ! 437: if( type.pcc==BITS && val.lng&(power>>1) ) ! 438: val.lng |= ~(power-1); ! 439: addr = 0; break; ! 440: case CHAR: val.lng = (char) val.chr; break; ! 441: case UCHAR: val.lng = (unsigned char) val.chr; break; ! 442: case SHORT: val.lng = (short) val.sht; break; ! 443: case USHORT: val.lng = (unsigned short) val.sht; break; ! 444: case FLOAT: val.dbl = val.flt; break; ! 445: } ! 446: trace( "%s %d %d %s", sym?sym->_text:"", addr, val.lng, type.text() ); ! 447: return 0; ! 448: } ! 449: ! 450: char *Expr::invalidoperands(char *more) ! 451: { ! 452: trace( "%d.invalidoperands()", this ); OK("invalidoperands"); ! 453: char *colon = more ? ": " : ""; ! 454: if( !more ) more = ""; ! 455: return sf( "invalid operand(s) of %s%s%s", OpName(op), colon, more ); ! 456: } ! 457: ! 458: char *Expr::eval(Frame *frame) ! 459: { ! 460: trace( "%d.eval(%d)", this, frame ); OK("eval"); ! 461: switch(op){ ! 462: case O_QINDEX: ! 463: case O_QCAST: ! 464: case O_QSTRUCT: ! 465: case O_QENUM: ! 466: return "? stops evaluation"; ! 467: } ! 468: switch( edisc ){ ! 469: case E_DCONST: ! 470: case E_LCONST: ! 471: return 0; /* should all be there! */ ! 472: case E_UNARY: ! 473: return evalunary(frame); ! 474: case E_BINARY: ! 475: return evalbinary(frame); ! 476: case E_ID: ! 477: if( !(sym = frame->idtosym(id)) ) ! 478: return enumid(frame); ! 479: edisc = E_SYMNODE; /* fall thru */ ! 480: case E_SYMNODE: ! 481: if( !sym ) return "symbol table error"; ! 482: addr = frame->locate((Var*)sym); ! 483: return getval(frame); ! 484: default: ! 485: return "not an expression"; ! 486: } ! 487: } ! 488: ! 489: char *Expr::enumid(Frame *frame) ! 490: { ! 491: trace("%d.enumid(%s)", this, id); OK("enumid"); ! 492: UType *u; Var *v; ! 493: for( u = frame->symtab()->utypelist(); u; u = (UType*) u->rsib ){ ! 494: if( u->type.pcc != ENUMTY ) continue; ! 495: TypMems tm(u); ! 496: while( v = tm.gen() ) if( !strcmp(id, v->_text) ){ ! 497: edisc = E_LCONST; ! 498: val.lng = v->range.lo; ! 499: addr = 0; ! 500: type.pcc = LONG; ! 501: return 0; ! 502: } ! 503: } ! 504: return sf("not found: %s", id); ! 505: } ! 506: ! 507: char *Expr::evalindex(Frame *frame, Expr *ap, long i) ! 508: { ! 509: long size = 0; ! 510: ! 511: trace( "%d.index(%d,%d,%d)", this, frame, ap, i); OK("evalindex"); ! 512: if( ap && ap->type.decref() ){ ! 513: type = *ap->type.decref(); ! 514: size = type.size_of(); ! 515: } ! 516: if( !size ) return "cannot determine size for []"; ! 517: addr = ap->type.isptr() ? ap->val.lng : ap->addr; ! 518: if( !addr ) return "zero pointer for []"; ! 519: addr += size * i; ! 520: return getval(frame); ! 521: } ! 522: ! 523: char *Expr::evaldotarrow(Frame *frame) ! 524: { ! 525: DType t; ! 526: ! 527: trace( "%d.evaldotarrow(%d)", this, frame ); OK("evaldotarrow"); ! 528: addr = 0; ! 529: t = sub1->type; ! 530: if( op == O_DOT ) ! 531: addr = sub1->addr; ! 532: else { ! 533: if( !t.isptr() ) return invalidoperands("not a pointer"); ! 534: t = *t.decref(); ! 535: addr = sub1->val.lng; ! 536: } ! 537: if( !t.isstrun() ) return invalidoperands("not a struct/union"); ! 538: if( !addr ) return invalidoperands("zero address"); ! 539: if( sub2->edisc == E_ID && t.utype() ){ ! 540: TypMems tm(t.utype()); ! 541: while( sub2->sym = tm.gen() ) ! 542: if( !strcmp(sub2->sym->text(), sub2->id) ) break; ! 543: if( !sub2->sym ) return sf("not found: %s", sub2->id); ! 544: sub2->edisc = E_SYMNODE; ! 545: } ! 546: if( sub2->edisc != E_SYMNODE ) return invalidoperands(); ! 547: sym = sub2->sym; ! 548: t = ((Var*)sym)->type; ! 549: if( t.pcc==BITS || t.pcc==UBITS ) ! 550: bitaddr = sym->range.lo; ! 551: else ! 552: addr += sym->range.lo; ! 553: return getval(frame); ! 554: } ! 555: ! 556: Expr *Expr::actual(int a) ! 557: { ! 558: int m; ! 559: trace( "%d.actual(%d)", this, a ); ! 560: if( !this ) return 0; ! 561: if( op != O_COMMA ) return a == 1 ? this : 0; ! 562: for( m = 0; sub1->actual(m+1); ++m ) {} ! 563: return a<=m ? sub1->actual(a) : sub2->actual(a-m); ! 564: } ! 565: ! 566: char *Expr::evalcall(Frame *frame) ! 567: { ! 568: char *error = 0; ! 569: long i, nargs = 1, argwords = 0, regloc; ! 570: Var *formal; ! 571: Func *func; ! 572: Frame *called = 0; ! 573: ! 574: trace( "%d.evalcall(%d)", this, frame ); OK("evalcall"); ! 575: if( !sub1 )return "<fcn call>"; ! 576: switch( sub1->edisc ){ ! 577: default: return "<fcn call>"; ! 578: case E_ID: ! 579: sub1->sym = frame->symtab()->idtosym( U_FUNC, sub1->id ); ! 580: case E_SYMNODE: ! 581: func = (Func*) sub1->sym; ! 582: } ! 583: if( !func ) return sf( "not a function: %s", sub1->id ); ! 584: while( sub2->actual(nargs) ) ! 585: if( !(formal = func->argument(nargs)) ) ! 586: return "too many args in function call"; ! 587: else { ! 588: argwords += (formal->type.size_of()+3)/4; /* vax & 32 */ ! 589: ++nargs; ! 590: } ! 591: if( func->argument(nargs) ) ! 592: return "too few args in function call"; ! 593: --nargs; ! 594: Core *core = frame->core; ! 595: if( !core->online() ) ! 596: return "cannot call function in dump"; ! 597: Context *cc = core->newContext(); ! 598: if( cc->error ){ ! 599: delete cc; ! 600: return cc->error; ! 601: } ! 602: called = new Frame(core); ! 603: called->ap = core->apforcall(argwords*4); ! 604: if( !called->ap ) ! 605: { error = "function calling is broken"; goto Restore; } ! 606: for( i = 1; i <= nargs; ++i ){ ! 607: Expr *e; ! 608: e = E_Binary(E_Sym(func->argument(i)), O_ASSIGN, sub2->actual(i)); ! 609: if( error = e->sub1->eval(called) ) ! 610: { error = sf("formal arg: %s", error); goto Restore; } ! 611: if( error = e->sub2->eval(frame) ) ! 612: { error = sf("actual arg: %s", error); goto Restore; } ! 613: if( error = e->evalassign(called) ) ! 614: { error = sf("arg assign: %s", error); goto Restore; } ! 615: } ! 616: if( error = core->docall(func->range.lo, argwords) ) ! 617: goto Restore; ! 618: type = *func->type.decref(); ! 619: regloc = core->returnregloc(); ! 620: if( !regloc) ! 621: { error = "function return error"; goto Restore; } ! 622: if( type.isstrun() ) ! 623: switch( type.size_of() ){ ! 624: case 1: ! 625: case 2: ! 626: case 4: addr = regloc; ! 627: break; ! 628: default: ! 629: addr = core->peek(regloc)->lng; ! 630: } ! 631: else ! 632: val = *core->peek(regloc); /* doubles? */ ! 633: Restore: ! 634: if( called ) delete called; ! 635: cc->restore(); ! 636: if( cc->error && !error ) ! 637: error = cc->error; ! 638: delete cc; ! 639: return error; ! 640: } ! 641: ! 642: char *Expr::evalenv(Frame *frame) ! 643: { ! 644: Frame *env = frame ? frame->caller() : 0; ! 645: char *error; ! 646: ! 647: trace( "%d.evalenv(%d)", this, frame ); OK("evalenv"); ! 648: for( ; env; env = env->caller() ) ! 649: if( !strcmp(env->func->_text,sub2->text()) ) ! 650: break; ! 651: if( !env ){ ! 652: Frame sta(frame->core); ! 653: sta.func = (Func*) sta.core->symtab()->idtosym(U_FUNC,sub2->text()); ! 654: if( sta.func ) env = &sta; ! 655: } ! 656: if( !env ) return sf( "not found: %s()", sub2->text() ); ! 657: if( error = sub1->eval(env) ) return error; ! 658: type = sub1->type; ! 659: val = sub1->val; ! 660: addr = sub1->addr; ! 661: return 0; ! 662: } ! 663: ! 664: char *Expr::evalrange() ! 665: { ! 666: const int range = 32; ! 667: trace( "%d.evalrange()", this ); OK("evalrange"); ! 668: if( !sub1->type.isintegral() ! 669: || !sub2->type.isintegral() ! 670: || sub2->val.lng < sub1->val.lng ) ! 671: return invalidoperands(); ! 672: if( sub2->val.lng > sub1->val.lng+range ) ! 673: return sf( "range may not exceed %d", range ); ! 674: return 0; ! 675: } ! 676: ! 677: void Expr::catchfpe() /* VAX: put down operands that must succeed */ ! 678: { /* and restart the instruction */ ! 679: *fp1 = *fp2 = 1.0; ! 680: fpe = "floating point exception"; ! 681: } ! 682: ! 683: char *Expr::evalflop() /* VAX host */ ! 684: { ! 685: char *error; ! 686: trace( "%d.evalflop()", this ); OK("evalflop"); ! 687: if( !sub1->type.isreal() || !sub2->type.isreal() ) ! 688: return invalidoperands(); ! 689: if( (error = sub1->floaterror()) ! 690: || (error = sub2->floaterror()) ) ! 691: return invalidoperands(error); ! 692: type.pcc = DOUBLE; ! 693: double l = sub1->val.dbl; double r = sub2->val.dbl; ! 694: fp1 = &l; ! 695: fp2 = &r; ! 696: fpe = 0; ! 697: signal(SIGFPE, (SIG_TYP)&Expr::catchfpe); ! 698: switch( op ){ ! 699: case O_MULT: val.dbl = l*r; break; ! 700: case O_DIV: val.dbl = l/r; break; ! 701: case O_PLUS: val.dbl = l+r; break; ! 702: case O_MINUS: val.dbl = l-r; break; ! 703: } ! 704: signal(SIGFPE, (SIG_TYP)SIG_DFL); ! 705: return fpe; ! 706: } ! 707: ! 708: char *Expr::evalbinary(Frame *frame) ! 709: { ! 710: char *error; ! 711: long size; ! 712: ! 713: trace( "%d.evalbinary(%d)", this, frame ); OK("evalbinary"); ! 714: IF_LIVE( edisc!=E_BINARY ) return "<binary expr>"; ! 715: switch( op ){ ! 716: case O_CALL: return evalcall(frame); ! 717: case O_ENV: return evalenv(frame); ! 718: } ! 719: if( error = sub1->eval(frame) ) return error; ! 720: type.pcc = LONG; ! 721: type.over = sub1->type.over; ! 722: if( op==O_DOT || op==O_ARROW ) return evaldotarrow(frame); ! 723: if( (sub1->type.isintegral() && op==O_LOGAND && !sub1->val.lng) ! 724: || (sub1->type.isintegral() && op==O_LOGOR && sub1->val.lng) ){ ! 725: val = sub1->val.lng != 0; ! 726: return 0; ! 727: } ! 728: if( error = sub2->eval(frame) ) return error; ! 729: type.over |= sub2->type.over; ! 730: switch( op ){ ! 731: case O_RANGE: ! 732: return evalrange(); ! 733: case O_COMMA: ! 734: type = sub2->type; ! 735: val = sub2->val; ! 736: return 0; ! 737: case O_ASSIGN: ! 738: return evalassign(frame); ! 739: case O_MULT: ! 740: case O_DIV: ! 741: if( sub1->type.isreal() || sub2->type.isreal() ) ! 742: return evalflop(); ! 743: case O_MOD: ! 744: if( sub1->type.isintegral() && sub2->type.isintegral() ){ ! 745: long l = sub1->val.lng, r = sub2->val.lng; ! 746: if( op==O_MULT ){ ! 747: val.lng = l * r; ! 748: return 0; ! 749: } ! 750: if( r == 0 ) return "zero divide"; ! 751: if( op == O_MOD ) val.lng = l % r; ! 752: if( op == O_DIV ) val.lng = l / r; ! 753: return 0; ! 754: } ! 755: return invalidoperands(); ! 756: case O_LOGAND: ! 757: case O_LOGOR: ! 758: case O_BITAND: ! 759: case O_BITOR: ! 760: case O_BITXOR: ! 761: case O_LSHIFT: ! 762: case O_RSHIFT: ! 763: if( sub1->type.isscalar() && sub2->type.isscalar() ){ ! 764: long l = sub1->val.lng, r = sub2->val.lng; ! 765: switch( op ){ ! 766: case O_LOGAND: val.lng = l && r; return 0; ! 767: case O_LOGOR: val.lng = l || r; return 0; ! 768: case O_BITAND: val.lng = l & r; return 0; ! 769: case O_BITOR: val.lng = l | r; return 0; ! 770: case O_BITXOR: val.lng = l ^ r; return 0; ! 771: case O_LSHIFT: val.lng = l << r; return 0; ! 772: case O_RSHIFT: val.lng = l >> r; return 0; ! 773: } ! 774: return "internal error: && || & | ^ >> <<"; ! 775: } ! 776: return invalidoperands(); ! 777: case O_EQ: ! 778: case O_NE: ! 779: case O_LT: ! 780: case O_GT: ! 781: case O_LE: ! 782: case O_GE: ! 783: type.pcc = LONG; ! 784: if( sub1->type.isreal() || sub2->type.isreal() ){ ! 785: if( !sub1->type.isreal() || sub1->floaterror() ! 786: || !sub2->type.isreal() || sub2->floaterror() ) ! 787: return invalidoperands(); ! 788: double l = sub1->val.dbl; double r = sub2->val.dbl; /*C++*/ ! 789: switch( op ){ ! 790: case O_EQ: val.lng = l == r; return 0; ! 791: case O_NE: val.lng = l != r; return 0; ! 792: case O_LT: val.lng = l < r; return 0; ! 793: case O_GT: val.lng = l > r; return 0; ! 794: case O_LE: val.lng = l <= r; return 0; ! 795: case O_GE: val.lng = l >= r; return 0; ! 796: } ! 797: return "internal floating relation error"; ! 798: } ! 799: if( sub1->type.isscalar() && sub2->type.isscalar() ){ ! 800: long l = sub1->val.lng, r = sub2->val.lng; ! 801: switch( op ){ ! 802: case O_EQ: val.lng = l == r; return 0; ! 803: case O_NE: val.lng = l != r; return 0; ! 804: case O_LT: val.lng = l < r; return 0; ! 805: case O_GT: val.lng = l > r; return 0; ! 806: case O_LE: val.lng = l <= r; return 0; ! 807: case O_GE: val.lng = l >= r; return 0; ! 808: } ! 809: return "internal fixed point relation error"; ! 810: } ! 811: return invalidoperands(); ! 812: case O_PLUS: ! 813: case O_MINUS: ! 814: if( sub1->type.isreal() || sub2->type.isreal() ) ! 815: return evalflop(); ! 816: if( sub1->type.isary() ){ ! 817: sub1->val.lng = sub1->addr; ! 818: sub1->type = sub1->type.decref()->incref(); ! 819: } ! 820: if( sub2->type.isary() ){ ! 821: sub2->val.lng = sub2->addr; ! 822: sub2->type = sub2->type.decref()->incref(); ! 823: } ! 824: if( sub1->type.isptr() && sub2->type.isintegral() ){ ! 825: size = sub1->type.decref()->size_of(); ! 826: if( !size ) return "pointer arithmetic error"; ! 827: if( op == O_MINUS ) size = -size; ! 828: val.lng = sub1->val.lng + size*sub2->val.lng; ! 829: type = sub1->type; ! 830: return 0; ! 831: } ! 832: if( sub1->type.isintegral() && sub2->type.isintegral() ){ ! 833: if( op==O_PLUS ) val.lng = sub1->val.lng+sub2->val.lng; ! 834: if( op==O_MINUS) val.lng = sub1->val.lng-sub2->val.lng; ! 835: return 0; ! 836: } ! 837: if( op == O_PLUS && sub2->type.isptr() && sub1->type.isintegral() ){ ! 838: size = sub2->type.decref()->size_of(); ! 839: if( !size ) return "pointer arithmetic error"; ! 840: val.lng = sub2->val.lng + size*sub1->val.lng; ! 841: type = sub2->type; ! 842: return 0; ! 843: } ! 844: if( op == O_MINUS && sub1->type.isptr() && sub2->type.isptr() ){ ! 845: size = sub1->type.decref()->size_of(); ! 846: if( !size || size!=sub2->type.decref()->size_of() ) ! 847: return "pointer-pointer size error"; ! 848: val.lng = (sub1->val.lng - sub2->val.lng)/size; ! 849: type.over |= sub2->type.over; ! 850: return 0; ! 851: } ! 852: return invalidoperands(); ! 853: case O_INDEX: ! 854: trace( "%s %s", sub1->type.text(), sub2->type.text() ); ! 855: if( sub1->type.isaryorptr() && sub2->type.isintegral() ) ! 856: return evalindex(frame,sub1,sub2->val.lng); ! 857: if( sub2->type.isaryorptr() && sub1->type.isintegral() ) ! 858: return evalindex(frame,sub2,sub1->val.lng); ! 859: return invalidoperands(); ! 860: default: ! 861: return "binary operator not implemented"; ! 862: } ! 863: } ! 864: ! 865: char *Expr::evalcast() ! 866: { ! 867: trace( "%d.evalcast()", this, ); OK("<cast>"); ! 868: IF_LIVE( !type.isscalar() || !sub1->type.isscalar() ) return "cast error"; ! 869: if( type.isptr() ){ ! 870: if( sub1->type.isreal() ) return "can't cast float to ptr"; ! 871: val.lng = sub1->val.lng; ! 872: return 0; ! 873: } ! 874: if( type.isreal() ){ ! 875: if( sub1->floaterror() ) return sub1->floaterror(); ! 876: val.dbl = sub1->val.dbl; ! 877: if( !sub1->type.isreal() ) val.dbl = sub1->val.lng; ! 878: return 0; ! 879: } ! 880: val.lng = sub1->val.lng; ! 881: switch( sub1->type.pcc ){ ! 882: case CHAR: val.lng = sub1->val.chr; break; ! 883: case SHORT: val.lng = sub1->val.sht; break; ! 884: } ! 885: addr = sub1->addr; ! 886: if( sub1->type.isreal() ){ ! 887: if( sub1->floaterror() ) return sub1->floaterror(); ! 888: val.lng = (long) sub1->val.dbl; ! 889: } ! 890: return 0; ! 891: } ! 892: ! 893: char *Expr::evalunary(Frame *frame) ! 894: { ! 895: char *error; ! 896: ! 897: trace( "%d.evalunary(%d)", this, frame ); OK("<unary expr>"); ! 898: IF_LIVE( edisc!=E_UNARY ) return "<unary expr>"; ! 899: if( error = sub1->eval(frame) ) return error; ! 900: switch( op ){ ! 901: case O_SPECIAL: ! 902: type = sub1->type; ! 903: addr = sub1->addr; ! 904: val = sub1->val; ! 905: if( type.isptr() ){ ! 906: type = *type.decref(); ! 907: addr = val.lng; ! 908: } ! 909: if( !type.pcc == STRTY || !type.utype() || !addr ) ! 910: return invalidoperands(); ! 911: error = frame->special( type.utype()->text(), addr ); ! 912: { // cfront bug ! 913: DType nulltype; ! 914: type = nulltype; ! 915: } // cfront bug ! 916: type.pcc = VOID; ! 917: addr = 0; ! 918: return error; ! 919: case O_1SCOMP: ! 920: case O_LOGNOT: ! 921: if( !sub1->type.isscalar() || sub1->type.isreal() ) ! 922: return invalidoperands(); ! 923: type.pcc = LONG; ! 924: if( op == O_1SCOMP ) val.lng = ~sub1->val.lng; ! 925: if( op == O_LOGNOT ) val.lng = !sub1->val.lng; ! 926: return 0; ! 927: case O_FABS: ! 928: { // cfront bug ! 929: double fabs(double); ! 930: if( !sub1->type.isreal() || sub1->floaterror() ) ! 931: return invalidoperands(); ! 932: type.pcc = DOUBLE; ! 933: val.dbl = fabs(sub1->val.dbl); /* cannot fail? */ ! 934: return 0; ! 935: } // cfront bug ! 936: case O_MINUS: ! 937: if( sub1->type.isintegral() ){ ! 938: type.pcc = LONG; ! 939: val.lng = -sub1->val.lng; ! 940: return 0; ! 941: } ! 942: if( sub1->type.isreal() && !sub1->floaterror() ){ ! 943: type.pcc = DOUBLE; ! 944: val.dbl = -sub1->val.dbl; ! 945: return 0; ! 946: } ! 947: return invalidoperands(); ! 948: case O_CAST: ! 949: return evalcast(); ! 950: case O_SIZEOF: ! 951: addr = 0; ! 952: if( !(val.lng = sub1->type.size_of())) return "sizeof error"; ! 953: type.pcc = UNSIGNED; ! 954: return 0; ! 955: case O_TYPEOF: ! 956: return sub1->type.text(); ! 957: case O_DEREF: ! 958: if( !sub1->type.isptr() ) return "unary * applied to non-pointer"; ! 959: addr = sub1->val.lng; ! 960: type = *sub1->type.decref(); ! 961: return getval(frame); ! 962: case O_REF: ! 963: if( !sub1->addr ) return "unary & applied to non-lvalue"; ! 964: addr = 0; ! 965: int o = type.over; ! 966: type = sub1->type.incref(); ! 967: type.over = o; ! 968: val.lng = sub1->addr; ! 969: return 0; ! 970: default: ! 971: return "unary operator not implemented"; ! 972: } ! 973: } ! 974: ! 975: Index Expr::castcarte() ! 976: { ! 977: static Index *ix; ! 978: static short bt[] = { DOUBLE, FLOAT, LONG, SHORT, CHAR, 0 }; ! 979: Menu m; ! 980: DType *base, *ptr; ! 981: ! 982: trace( "%d.castcarte()", this ); OK(ZIndex); ! 983: if (!ix) ! 984: ix = new Index(0,0); ! 985: if( !ix->null() ) return *ix; ! 986: Action a = (Action)&Phrase::applycast; ! 987: int t; ! 988: for( t = 0; bt[t]; ++t ){ ! 989: base = new DType(); ! 990: base->pcc = bt[t]; ! 991: ptr = new DType; ! 992: *ptr = base->incref(); ! 993: m.first( sf( "%s\240", ptr->text() ), a, (long) ptr ); ! 994: m.first( sf( " %s\240", base->text()), a, (long) base ); ! 995: } ! 996: Action i = (Action)&Phrase::increfcast; ! 997: Action e = (Action)&Phrase::enumcast; ! 998: Action s = (Action)&Phrase::strcast; ! 999: m.last( " * ? ", i, 1 ); ! 1000: m.last( " enum ? ", e, 0 ); ! 1001: m.last( " *struct ? ", s, 1 ); ! 1002: return *ix = m.index("cast $"); ! 1003: } ! 1004: ! 1005: Index Expr::carte(Frame *f) ! 1006: { ! 1007: Menu m; ! 1008: ! 1009: trace( "%d.carte()", this ); OK(ZIndex); ! 1010: m.last( "eval $", (Action)&Phrase::evaluate ); ! 1011: if( evalerr || op==O_TYPEOF ) ! 1012: return m.index(); ! 1013: switch( op ){ ! 1014: case O_QCAST: ! 1015: return castcarte(); ! 1016: case O_QSTRUCT: ! 1017: return f ? f->symtab()->utypecarte(STRTY) : ZIndex; ! 1018: case O_QENUM: ! 1019: return f ? f->symtab()->utypecarte(ENUMTY) : ZIndex; ! 1020: case O_QINDEX: ! 1021: return NumericRange( -2, 20 ); ! 1022: } ! 1023: if( !spy ) ! 1024: m.first( "spy on $", (Action) &Phrase::setspy, 1 ); ! 1025: else ! 1026: m.first( "unspy $", (Action) &Phrase::setspy, 0 ); ! 1027: if( addr ) m.last( "& $", (Action)&Phrase::applyunary, (long)O_REF ); ! 1028: if( val.lng ) ! 1029: m.last( "mem .=$ ", (Action)&Phrase::memory ); ! 1030: if( type.isscalar() ) m.last(castcarte()); ! 1031: m.last(type.carte()); ! 1032: return m.index(); ! 1033: } ! 1034: ! 1035: void Expr::setspy(long s) ! 1036: { ! 1037: trace( "%d.setspy(%d)", this, s ); VOK; ! 1038: if( !s && spy ){ ! 1039: delete spy; ! 1040: spy = 0; ! 1041: } else if( s ) ! 1042: spy = new Spy; ! 1043: } ! 1044: ! 1045: char *Expr::evalassign(Frame *frame) ! 1046: { ! 1047: char *error; ! 1048: ! 1049: trace( "%d.evalassign(%d)", this, frame ); OK("evalassign"); ! 1050: if( !sub1->addr ) return "lhs of = does not yield an lvalue"; ! 1051: if( sub2->type.isary() && sub2->addr ){ ! 1052: sub2->type.pcc = PTR; ! 1053: sub2->val.lng = sub2->addr; ! 1054: } ! 1055: if( sub1->type.isscalar() && sub2->type.isscalar() ){ ! 1056: DType type1 = sub1->type, type2 = sub2->type; ! 1057: long addr1 = sub1->addr, size1 = type1.size_of(); ! 1058: Cslfd *val2 = &sub2->val; ! 1059: if( type1.isreal() || type1.isreal() ){ ! 1060: if( !type1.isreal() || !type2.isreal() ) ! 1061: return invalidoperands("mixed mode"); ! 1062: error = frame->pokedbl(addr1, val2->dbl, type1.size_of()); ! 1063: } else ! 1064: error = frame->poke(addr1, val2->lng, type1.size_of()); ! 1065: if( error ) ! 1066: return sf( "%s: 0x%X", error, sub1->addr ); ! 1067: if( error = sub1->eval(frame) ) ! 1068: return error; ! 1069: type = sub1->type; ! 1070: val = sub1->val; ! 1071: addr = 0; ! 1072: return 0; ! 1073: } ! 1074: if( sub1->type.isstrun() && sub2->type.isstrun() ){ ! 1075: UType *u1 = sub1->type.utype(), *u2 = sub2->type.utype(); ! 1076: if( !u1 ! 1077: || !u2 ! 1078: || u1->type.pcc != u2->type.pcc ! 1079: || strcmp(u1->type.text(), u2->type.text()) ) ! 1080: return "incompatible struct/union ="; ! 1081: if( !sub2->addr ) ! 1082: return "rhs of struct/union = does not yield an lvalue"; ! 1083: error = frame->blockmove(sub2->addr,sub1->addr,u1->type.size_of()); ! 1084: type = sub1->type; ! 1085: val = 0; ! 1086: addr = sub1->addr; ! 1087: return error; ! 1088: } ! 1089: return "invalid asssignment"; ! 1090: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.