![[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 [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / cdb|
Return to expr.c CVS log | Up to [Power 6/32 Unix Tahoe 4.2BSD] / cci / usr / src / bin / cdb |
1.1 ! root 1: static char sccsid[] = "@(#)expr.c 2.12"; ! 2: ! 3: #include "cdb.h" ! 4: #include "macdefs.h" ! 5: ! 6: extern long atol(); ! 7: extern double atof(); ! 8: extern int vrgOffset[]; /* defined in access.c */ ! 9: ! 10: /* the following define the stack mechanism used by the expression parser */ ! 11: ! 12: export int viopMac; /* operator stack pointer */ ! 13: export int vivarMac; /* variable stack pointer */ ! 14: ! 15: #define istkMax 15 ! 16: TYR vrgTy[cTyMax*istkMax]; /* variable stack */ ! 17: ADRT vrgAdr[cTyMax*istkMax]; /* addresses of the variables in vrgTy */ ! 18: TKE vrgTk[istkMax]; /* operator stack */ ! 19: ! 20: #define TOPOP (vrgTk[viopMac-1]) ! 21: #define TOPVAR (vrgTy[vivarMac-1]) ! 22: #define EmptyStack (vivarMac==0) ! 23: #define precParen 99 ! 24: ! 25: /* parser state */ ! 26: #define psFail 0 /* parser tripped */ ! 27: #define psOp 1 /* expression parser last saw an OPERATOR */ ! 28: #define psVar 2 /* expression parser last saw an VARIABLE */ ! 29: typedef int PSE, *pPSE; /* parser state */ ! 30: ! 31: ADRT vadrSb, vadrSbMax; /* where we can stick strings in child */ ! 32: ! 33: /* P U S H O P */ ! 34: ! 35: local void PushOp(tk) ! 36: TKE tk; ! 37: { ! 38: if (viopMac >= istkMax) ! 39: UError("Expression stack overflow"); ! 40: vrgTk[viopMac++] = tk; ! 41: } /* PushOp */ ! 42: ! 43: ! 44: /* P O P O P */ ! 45: ! 46: local TKE PopOp() ! 47: { ! 48: if (viopMac <= 0) ! 49: UError("Operator stack underflow"); ! 50: return(vrgTk[--viopMac]); ! 51: } /* PopOp */ ! 52: ! 53: ! 54: /* P U S H V A R */ ! 55: ! 56: local void PushVar(adrLong, ty) ! 57: long adrLong; ! 58: pTYR ty; ! 59: { ! 60: if (vivarMac >= istkMax) ! 61: UError("Expression stack overflow"); ! 62: CopyTy(vrgTy+vivarMac, ty); ! 63: vrgAdr[vivarMac] = adrLong; ! 64: vivarMac += 2; ! 65: } /* PushVar */ ! 66: ! 67: ! 68: /* F P O P V A R */ ! 69: ! 70: local FLAGT FPopVar(pret, ty) ! 71: long *pret; ! 72: pTYR ty; ! 73: { ! 74: if (vivarMac <= 0) ! 75: return(false); ! 76: vivarMac -= 2; /* point to first one */ ! 77: CopyTy(ty, vrgTy+vivarMac); ! 78: *pret = vrgAdr[vivarMac]; ! 79: return(true); ! 80: } /* FPopVar */ ! 81: ! 82: ! 83: /* A D R F S T O R E */ ! 84: ! 85: export ADRT AdrFStore(sb, cb) ! 86: char *sb; ! 87: int cb; ! 88: { ! 89: ADRT adr; ! 90: TYR ty[cTyMax]; ! 91: ! 92: /* this routine stores data in the CHILD's address space. ! 93: * this is mostly useful for passing strings as arguements to ! 94: * procedure calls from the command line. ! 95: */ ! 96: if (FOdd(cb)) ! 97: cb++; /* force to word boundary */ ! 98: /* will it fit? */ ! 99: if ((vadrSb == 0) OR (vadrSb+cb >= vadrSbMax)) { ! 100: /* no, we will go back and use the buffer over again */ ! 101: vadrSb = AdrFGlobal("__buffer", ty); ! 102: vadrSbMax = AdrFGlobal("_bufMax", ty); ! 103: if (vadrSb+cb >= vadrSbMax) ! 104: UError("I can't put something that big in the child. See 'end.c'"); ! 105: } ! 106: adr = vadrSb; ! 107: vadrSb += cb; /* advance to next free byte */ ! 108: PutBlock(adr, spaceData, sb, cb); ! 109: return(adr); ! 110: } /* AdrFStore */ ! 111: ! 112: ! 113: /* P R E C F T K */ ! 114: ! 115: export int PrecFTk(tk) ! 116: TKE tk; ! 117: { ! 118: /* determine precedence */ ! 119: /* these values are meaningful only in their relationship to one another */ ! 120: switch (tk) { ! 121: default: ! 122: return(0); ! 123: case tkBOE: ! 124: case tkLP: ! 125: return(precParen); ! 126: case tkInside: ! 127: case tkSizeof: ! 128: case tkLSB: ! 129: case tkPtr: ! 130: case tkDot: ! 131: return(96); ! 132: case tkRef: ! 133: case tkUMinus: ! 134: case tkBang: ! 135: case tkTilda: ! 136: case tkDeref: ! 137: return(95); /* unary operator */ ! 138: case tkDiv: ! 139: case tkMul: ! 140: return(80); ! 141: case tkPlus: ! 142: case tkMinus: ! 143: return(70); ! 144: case tkLShift: ! 145: case tkRShift: ! 146: return(60); ! 147: case tkLT: ! 148: case tkLE: ! 149: case tkGT: ! 150: case tkGE: ! 151: return(50); ! 152: case tkEqual: ! 153: case tkNotEqual: ! 154: return(40); ! 155: case tkBitAnd: ! 156: return(32); ! 157: case tkXOR: ! 158: return(31); ! 159: case tkBitOr: ! 160: return(30); ! 161: case tkLAND: ! 162: return(21); ! 163: case tkLOR: ! 164: return(20); ! 165: case tkAssPlus: ! 166: case tkAssMinus: ! 167: case tkAssMult: ! 168: case tkAssDiv: ! 169: case tkAssXOR: ! 170: case tkAssBAND: ! 171: case tkAssBOR: ! 172: case tkAssLeft: ! 173: case tkAssRight: ! 174: case tkAssMod: ! 175: case tkAssign: ! 176: return(3); ! 177: case tkComma: ! 178: case tkEOE: ! 179: case tkRP: ! 180: case tkIndex: ! 181: case tkRSB: ! 182: return(1); ! 183: } /* switch */ ! 184: } /* PrecFTk */ ! 185: ! 186: ! 187: /* V A L F A D R */ ! 188: ! 189: export long ValFAdr(adrLong, ty) ! 190: long adrLong; ! 191: pTYR ty; ! 192: { ! 193: int cb, bt; ! 194: ADRT adrSrc, adrDest; ! 195: STUFFU stuff; ! 196: ! 197: if (ty->td.fConstant) ! 198: return(adrLong); /* it was a constant - ergo, it has no address */ ! 199: ! 200: stuff.lng = 0; ! 201: adrSrc = adrLong; ! 202: cb = CbFTy(ty); ! 203: if (cb > 4) ! 204: cb = 4; /* this routine is not designed for more than a long */ ! 205: ! 206: if (ty->td.st == stReg) { ! 207: #ifndef REGULUS ! 208: if (cb == CBCHAR) { ! 209: stuff.chars.chLoLo = GetReg(adrSrc); ! 210: } ! 211: else if (cb == CBSHORT) { ! 212: stuff.shorts.shortLo = GetReg(adrSrc); ! 213: } ! 214: else { ! 215: #if (CBINT == CBSHORT) ! 216: stuff.shorts.shortHi = GetReg(adrSrc); ! 217: stuff.shorts.shortLo = GetReg(adrSrc+1); ! 218: #else ! 219: stuff.lng = GetReg(adrSrc); ! 220: #endif ! 221: } /* if */ ! 222: #else ! 223: if (trace(ptReadUser, vpid, cb, ! 224: &stuff, v_ar0+vrgOffset[adrSrc]) < 0) ! 225: UError("Bad Access"); ! 226: #endif ! 227: goto extendSign; ! 228: } /* if */ ! 229: ! 230: /* figure address we want this read into */ ! 231: adrDest = (cb == 1) ? (ADRT) &(stuff.chars.chLoLo) : ! 232: (cb == 2) ? (ADRT) &(stuff.shorts.shortLo) : ! 233: (ADRT) &(stuff.lng); ! 234: ! 235: if (ty->td.st == stSpc) { ! 236: /* a `special' variable (lives in debuggers universe) */ ! 237: MoveBytes(adrDest, adrSrc, cb); ! 238: goto extendSign; ! 239: } /* if */ ! 240: ! 241: /* unfortunately, there are some special addresses which look like adrNil! */ ! 242: if (adrSrc == adrNil) ! 243: return(0); ! 244: ! 245: if (cb > 0) { ! 246: GetBlock(adrSrc, spaceData, adrDest, cb); ! 247: return(stuff.lng); ! 248: } ! 249: else { ! 250: /* it must be a bit field spec */ ! 251: /* This is dependent on the order the compiler allocates bits */ ! 252: #ifdef BSD41 ! 253: cb = (ty->valTy + ty->td.width + (SZCHAR-1)) / SZCHAR; ! 254: GetBlock(adrSrc, spaceData, &stuff.lng, cb); ! 255: stuff.lng = Extract(stuff.lng, ty->valTy, ty->td.width); ! 256: return(stuff.lng); ! 257: #else ! 258: Panic("Don't know how to handle bit fields for this machine"); ! 259: #endif ! 260: } /* if */ ! 261: ! 262: extendSign: ! 263: /* following forces sign extension */ ! 264: bt = ty->td.bt; ! 265: if (TqFTy(ty, 1) == tqNil) { /* then it is a base type, not a pointer */ ! 266: if (bt == btChar) ! 267: stuff.lng = stuff.chars.chLoLo; ! 268: else if (bt == btShort) ! 269: stuff.lng = stuff.shorts.shortLo; ! 270: #if (CBINT == CBSHORT) ! 271: else if (bt == btInt) ! 272: stuff.lng = stuff.shorts.shortLo; ! 273: #endif ! 274: } ! 275: return(stuff.lng); ! 276: } /* ValFAdr */ ! 277: ! 278: ! 279: /* P U T V A L */ ! 280: ! 281: export void PutVal(adrLong, ty, val) ! 282: long adrLong; ! 283: pTYR ty; ! 284: long val; ! 285: { ! 286: int cb; ! 287: ADRT adrDest, adrSrc; ! 288: STUFFU stuff; ! 289: ! 290: if (ty->td.fConstant) ! 291: return; /* it was a constant - ergo, it lives no where */ ! 292: ! 293: stuff.lng = val; ! 294: adrDest = adrLong; ! 295: cb = CbFTy(ty); ! 296: if (cb > 4) ! 297: cb = 4; /* this routine is not designed for more than a long */ ! 298: ! 299: /* figure address we want this read from */ ! 300: adrSrc = (cb == 1) ? (ADRT) &(stuff.chars.chLoLo) : ! 301: (cb == 2) ? (ADRT) &(stuff.shorts.shortLo) : ! 302: (ADRT) &(stuff.lng); ! 303: ! 304: if (ty->td.st == stReg) { ! 305: #ifndef REGULUS ! 306: if (cb == CBCHAR) { ! 307: PutReg(adrDest, stuff.chars.chLoLo); ! 308: } ! 309: else if (cb == CBSHORT) { ! 310: PutReg(adrDest, stuff.shorts.shortLo); ! 311: } ! 312: else { ! 313: #if (CBIBT == CBSHORT) ! 314: PutReg(adrDest, stuff.shorts.shortHi); ! 315: PutReg(adrDest+1, stuff.shorts.shortLo); ! 316: #else ! 317: PutReg(adrDest, stuff.lng); ! 318: #endif ! 319: } /* if */ ! 320: #else ! 321: if (trace(ptWriteUser, vpid, cb, ! 322: &stuff, v_ar0+vrgOffset[adrDest]) < 0) ! 323: UError("Bad Access"); ! 324: #endif ! 325: return; ! 326: } /* if */ ! 327: ! 328: if (ty->td.st == stSpc) { ! 329: /* a `local' variable */ ! 330: MoveBytes(adrDest, adrSrc, cb); ! 331: return; ! 332: } /* if */ ! 333: ! 334: if (cb > 0) { ! 335: PutBlock(adrDest, spaceData, adrSrc, cb); ! 336: } ! 337: else { ! 338: /* it must be a bit field */ ! 339: #ifdef BSD41 ! 340: cb = (ty->valTy + ty->td.width + (SZCHAR-1)) / SZCHAR; ! 341: GetBlock(adrDest, spaceData, &stuff.lng, cb); ! 342: SetBits(stuff.lng, ty->td.width, ty->valTy, val); ! 343: PutBlock(adrDest, spaceData, &stuff.lng, cb); ! 344: #else ! 345: Panic("Don't know how to handle bit fields for this machine"); ! 346: #endif ! 347: } /* if */ ! 348: } /* PutVal */ ! 349: ! 350: ! 351: /* P S F D O O P */ ! 352: ! 353: local PSE PsFDoOp() ! 354: { ! 355: /* this is the rotuine that actually does the TOP operator */ ! 356: int cb1, cb2, tq, ipd; ! 357: ushort *rgDim; ! 358: ADRT adr, adrShort; ! 359: FLAGT fDidIt, fDoIntOp; ! 360: TKE tk; ! 361: TYR aty1[cTyMax], aty2[cTyMax], atyMax[cTyMax]; ! 362: pTYR ty, ty1, ty2, tyMax; ! 363: long adr1, adr2, val1, val2; ! 364: STUFFU stuff; ! 365: #define cbAssMax 200 ! 366: char buf[cbAssMax]; ! 367: ! 368: ty1 = aty1; ! 369: ty2 = aty2; ! 370: tyMax = atyMax; ! 371: ! 372: if (viopMac < 0) ! 373: return(psFail); ! 374: ! 375: if (TOPOP == tkLP ! 376: OR TOPOP == tkBOE) ! 377: return(psFail); /* they should be waiting for one of these */ ! 378: tk = PopOp(); ! 379: ! 380: if (!FPopVar(&adr2, ty2)) /* every op needs at least one */ ! 381: return(psFail); ! 382: val2 = ValFAdr(adr2, ty2); ! 383: ! 384: fDidIt = true; ! 385: switch (tk) { ! 386: /* unary operators */ ! 387: default: ! 388: fDidIt = false; ! 389: break; ! 390: case tkUMinus: ! 391: ty2->td.fConstant = true; ! 392: ty2->td.st = stValue; ! 393: PushVar(-val2, ty2); ! 394: break; ! 395: case tkBang: ! 396: PushVar(lengthen(val2==0), vtyCnInt); ! 397: break; ! 398: case tkTilda: ! 399: ty2->td.fConstant = true; ! 400: ty2->td.st = stValue; ! 401: PushVar(~val2, ty2); ! 402: break; ! 403: case tkRef: ! 404: if (ty2->td.fConstant) ! 405: UError("You can't take the address of a constant"); ! 406: if (ty2->td.st == stReg) ! 407: UError("You can't take the address of a register"); ! 408: if (!FAdjTd(ty2, tqPtr)) /* add a pointer level */ ! 409: UError("Type information overflow"); ! 410: ty2->td.fConstant = true; ! 411: ty2->td.st = stValue; ! 412: PushVar(adr2, ty2); ! 413: break; ! 414: case tkDeref: ! 415: tq = TqFTy(ty2, 1); ! 416: if ((tq == tqPtr) OR (tq == tqArray)) ! 417: FAdjTd(ty2, tqNil); /* remove tq */ ! 418: ty2->td.st = stValue; ! 419: if (ty2->td.fConstant) { ! 420: ty2->td.fConstant = false; ! 421: PushVar(adr2, ty2); ! 422: } ! 423: else if (tq == tqArray) { ! 424: PushVar(adr2, ty2); /* array is pointer to itself */ ! 425: } ! 426: else { ! 427: PushVar(val2, ty2); ! 428: } /* if */ ! 429: break; ! 430: case tkInside: ! 431: adrShort = adr2; ! 432: ipd = IpdFAdr(adrShort); ! 433: val2 = (vpc >= vrgPd[ipd].adrStart) ! 434: AND (vpc < vrgPd[ipd+1].adrStart); ! 435: PushVar(val2, vtyCnInt); ! 436: break; ! 437: case tkSizeof: ! 438: val2 = CbFTy(ty2); ! 439: PushVar(val2, vtyCnInt); ! 440: break; ! 441: } /* switch */ ! 442: if (fDidIt) /* we must have done one of them - go back */ ! 443: return(psVar); ! 444: ! 445: /* not unary, so we pop another and try the binaries */ ! 446: if (!FPopVar(&adr1, ty1)) ! 447: return(psFail); ! 448: val1 = ValFAdr(adr1, ty1); ! 449: ! 450: fDidIt = true; ! 451: switch (tk) { ! 452: default: ! 453: fDidIt = false; ! 454: break; ! 455: case tkDot: ! 456: val1 = adr1; /* direct address, then do ptr */ ! 457: case tkPtr: ! 458: val1 = AdrFField(val1, ty1, ty2); ! 459: /* ty1 is struct, ty2 is field */ ! 460: PushVar(val1, ty2); ! 461: break; ! 462: case tkIndex: /* foo[x] */ ! 463: tq = TqFTy(ty1, 1); ! 464: if (tq == tqArray) ! 465: val1 = adr1; /* array value IS the address */ ! 466: FAdjTd(ty1, tqNil);/* remove ptr or array level */ ! 467: adr1 = val1 + (val2 * CbFTy(ty1)); ! 468: PushVar(adr1, ty1); ! 469: break; ! 470: ! 471: } /* switch */ ! 472: if (fDidIt) ! 473: return(psVar); ! 474: ! 475: /* MaxFTyTy may try to do too much. It first determines if the types ! 476: * are such that integer operators may be applied to them (and returns ! 477: * a true/false on this) If so, it copies into tyMax the ty of the ! 478: * larger of the two operands. ! 479: */ ! 480: fDoIntOp = MaxFTyTy(tyMax, ty1, ty2); ! 481: if ( (!fDoIntOp) ! 482: AND (tk != tkPtr) ! 483: AND (tk != tkDot) ! 484: AND (tk != tkAssign) ) { ! 485: /* they are trying something stupid, like adding structures together */ ! 486: UError("Cannot allow that combination of operand(s) and operator"); ! 487: } /* if */ ! 488: ! 489: tyMax->td.fConstant = true; /* any op that DOESN'T want this turns it off */ ! 490: tyMax->td.st = stValue; ! 491: /* binary operators */ ! 492: fDidIt = true; ! 493: switch (tk) { ! 494: default: ! 495: fDidIt = false; ! 496: break; ! 497: case tkDiv: ! 498: val1 = val1 / val2; ! 499: break; ! 500: case tkMul: ! 501: val1 = val1 * val2; ! 502: break; ! 503: case tkPlus: ! 504: val1 = val1 + val2; ! 505: break; ! 506: case tkMinus: ! 507: val1 = val1 - val2; ! 508: break; ! 509: case tkBitAnd: ! 510: val1 = val1 & val2; ! 511: break; ! 512: case tkXOR: ! 513: val1 = val1 ^ val2; ! 514: break; ! 515: case tkBitOr: ! 516: val1 = val1 | val2; ! 517: break; ! 518: } /* switch */ ! 519: if (fDidIt) { ! 520: PushVar(val1, tyMax); ! 521: return(psVar); ! 522: } /* if */ ! 523: ! 524: fDidIt = true; ! 525: ty = vtyCnInt; ! 526: switch (tk) { ! 527: default: ! 528: fDidIt = false; ! 529: break; ! 530: case tkLT: ! 531: val1 = val1 < val2; ! 532: break; ! 533: case tkLE: ! 534: val1 = val1 <= val2; ! 535: break; ! 536: case tkGT: ! 537: val1 = val1 > val2; ! 538: break; ! 539: case tkGE: ! 540: val1 = val1 >= val2; ! 541: break; ! 542: case tkEqual: ! 543: val1 = val1 == val2; ! 544: break; ! 545: case tkNotEqual: ! 546: val1 = val1 != val2; ! 547: break; ! 548: case tkLAND: ! 549: val1 = val1 && val2; ! 550: break; ! 551: case tkLOR: ! 552: val1 = val1 || val2; ! 553: break; ! 554: case tkLShift: ! 555: if (ty1->td.bt == btShort) { ! 556: /* we do this to crop it to 16 bits */ ! 557: stuff.lng = val1; ! 558: val1 = stuff.shorts.shortLo << val2; ! 559: } ! 560: else { ! 561: val1 = val1 << val2; ! 562: ty = vtyCnLong; ! 563: } /* if */ ! 564: break; ! 565: case tkRShift: ! 566: if (ty1->td.bt == btShort) { ! 567: /* we do this to crop it to 16 bits */ ! 568: stuff.lng = val1; ! 569: val1 = stuff.shorts.shortLo >> val2; ! 570: } ! 571: else { ! 572: val1 = val1 >> val2; ! 573: ty = vtyCnLong; ! 574: } /* if */ ! 575: break; ! 576: } /* switch */ ! 577: if (fDidIt) { ! 578: PushVar(val1, ty); ! 579: return(psVar); ! 580: } /* if */ ! 581: ! 582: if (tk != tkAssign) ! 583: UError("Unknown operator"); ! 584: ! 585: cb1 = CbFTy(ty1); ! 586: if (cb1 <= CBLONG) { ! 587: PutVal(adr1, ty1, val2); ! 588: } ! 589: else { ! 590: cb2 = CbFTy(ty2); ! 591: if (cb1 >= cbAssMax) ! 592: Panic("Too many bytes (> %d) moved in assignment", cbAssMax); ! 593: /* we transfer cb1 bytes, just to be safe */ ! 594: adrShort = adr2; ! 595: GetBlock(adrShort, spaceData, (ADRT)buf, cb1); ! 596: adrShort = adr1; ! 597: PutBlock(adrShort, spaceData, (ADRT)buf, cb1); ! 598: if (cb1 != cb2) { ! 599: printf("WARNING: X=Y: X is %d bytes and Y is %d bytes\n", ! 600: cb1, cb2); ! 601: printf(" Moving %d bytes\n", cb1); ! 602: } /* if */ ! 603: } /* if */ ! 604: PushVar(adr1, ty1); /* leave dest on stack, too */ ! 605: return(psVar); ! 606: } /* PsFDoOp */ ! 607: ! 608: ! 609: /* P S F O P E R A T O R */ ! 610: ! 611: local PSE PsFOperator(tk, ps) ! 612: TKE tk; ! 613: PSE ps; ! 614: { ! 615: /* this routine implements the precedence rules */ ! 616: int prec; ! 617: TKE tkStop, tkNew; ! 618: long adr; ! 619: TYR rgTy[cTyMax]; ! 620: ! 621: prec = PrecFTk(tk); ! 622: if (prec == 0) ! 623: Panic("Bad token in PsFOperator - [%d]", tk); ! 624: ! 625: if (ps == psOp) { ! 626: /* this had better be a unary operator */ ! 627: switch (tk) { ! 628: case tkSizeof: ! 629: case tkInside: ! 630: case tkBang: ! 631: case tkTilda: ! 632: case tkBOE: ! 633: case tkLP: ! 634: PushOp(tk); ! 635: break; ! 636: /* these next ones map to something else */ ! 637: case tkAmper: ! 638: PushOp(tkRef); ! 639: break; ! 640: case tkStar: ! 641: PushOp(tkDeref); ! 642: break; ! 643: case tkMinus: ! 644: PushOp(tkUMinus); ! 645: break; ! 646: case tkPlus: /* ignore it */ ! 647: break; ! 648: default: ! 649: UError("Two operators in a row??"); ! 650: } /* switch */ ! 651: return(psOp); ! 652: } /* if */ ! 653: ! 654: tkStop = tkNil; ! 655: switch (tk) { /* set our stop token for [], (), and (x,y,z) */ ! 656: case tkEOE: ! 657: tkStop = tkBOE; ! 658: break; ! 659: case tkRSB: ! 660: tkStop = tkLSB; ! 661: break; ! 662: case tkComma: ! 663: case tkRP: ! 664: tkStop = tkLP; ! 665: break; ! 666: } /* switch */ ! 667: ! 668: /* first process all higher precedence operators */ ! 669: while (prec <= PrecFTk(TOPOP)) { ! 670: if (TOPOP == tkStop) { ! 671: PopOp(); /* eat top op */ ! 672: return(psVar); /* by definition, "(x+y)" is a var */ ! 673: } ! 674: else if (PrecFTk(TOPOP) == precParen) { ! 675: break; /* we pretend it is higher precedence than the paren */ ! 676: } /* if */ ! 677: if (PsFDoOp() == psFail) { ! 678: switch (tk) { ! 679: case tkRSB: ! 680: UError("Missing '['"); ! 681: case tkRP: ! 682: UError("Missing '('"); ! 683: case tkComma: ! 684: UError("Bad procedure call"); ! 685: default: ! 686: UError("Badly formed expression"); ! 687: } /* switch */ ! 688: } /* if */ ! 689: } /* while */ ! 690: ! 691: tkNew = tkNil; ! 692: switch (tk) { ! 693: case tkAssPlus: ! 694: tkNew = tkPlus; ! 695: break; ! 696: case tkAssMinus: ! 697: tkNew = tkMinus; ! 698: break; ! 699: case tkAssMult: ! 700: tkNew = tkMul; ! 701: break; ! 702: case tkAssDiv: ! 703: tkNew = tkDiv; ! 704: break; ! 705: case tkAssXOR: ! 706: tkNew = tkXOR; ! 707: break; ! 708: case tkAssBAND: ! 709: tkNew = tkBitAnd; ! 710: break; ! 711: case tkAssBOR: ! 712: tkNew = tkBitOr; ! 713: break; ! 714: case tkAssLeft: ! 715: tkNew = tkLShift; ! 716: break; ! 717: case tkAssRight: ! 718: tkNew = tkRShift; ! 719: break; ! 720: case tkAssMod: ! 721: tkNew = tkModulo; ! 722: break; ! 723: } /* switch */ ! 724: if (tkNew != tkNil) { ! 725: /* this is an 'assign with function' op e.g. *= or += */ ! 726: /* replicate the top of the variable stack */ ! 727: if (!FPopVar(&adr, rgTy)) ! 728: UError("Bad Syntax"); ! 729: PushVar(adr, rgTy); ! 730: PushVar(adr, rgTy); ! 731: PushOp(tkAssign); ! 732: tk = tkNew; ! 733: } /* if */ ! 734: ! 735: PushOp(tk); ! 736: if (tk == tkLSB) ! 737: PushOp(tkIndex); /* we push the tkLSB and then the tkIndex */ ! 738: return(psOp); ! 739: } /* PsFOperator */ ! 740: ! 741: ! 742: /* T K F O P E R A N D */ ! 743: ! 744: export TKE TkFOperand() ! 745: { ! 746: int iln, ifd, ipd, cnt; ! 747: short valShort; ! 748: char sbFloat[30]; ! 749: long val; ! 750: TKE tk; ! 751: ADRT adr, fp, ap; ! 752: TYR ty[cTyMax]; ! 753: STUFFU stuff; ! 754: ! 755: /* look at the current token and figure out what the hell it is */ ! 756: /* successful cases fall out bottom and return tkAdr */ ! 757: switch (vtk) { ! 758: default: ! 759: return(tkNil); /* nothing of interest */ ! 760: case tkDot: ! 761: PushVar(vdot, vtyDot); ! 762: break; ! 763: case tkColon: /* they want us to search ONLY global space */ ! 764: tk = TkNext(); ! 765: if (tk != tkStr) ! 766: UError("Misformed global name"); ! 767: if ((adr = AdrFGlobal(vsbTok, ty)) == adrNil) ! 768: UError("Unknown global - %s", vsbTok); ! 769: PushVar(lengthen(adr), ty); ! 770: break; ! 771: case tkCharConstant: ! 772: CopyTy(ty, vtyCnChar); ! 773: val = vsbTok[0]; ! 774: PushVar(val, ty); ! 775: break; ! 776: case tkStrConstant: ! 777: adr = AdrFStore(vsbTok, vcbTok+1); ! 778: CopyTy(ty, vtyCnChar); /* it is a constant */ ! 779: FAdjTd(ty, tqPtr); /* this makes it a 'char *' */ ! 780: PushVar(lengthen(adr), ty); ! 781: break; ! 782: case tkNumber: ! 783: if (vsbTok[0] == '0') { ! 784: if (vsbTok[1] == 'x') ! 785: sscanf((vsbTok+2), "%X", &val); ! 786: else sscanf(vsbTok, "%O", &val); ! 787: } ! 788: else { ! 789: tk = TkPeek(); ! 790: if (tk == tkDot) { ! 791: /* looks like a float constant */ ! 792: strcpy(sbFloat, vsbTok); ! 793: TkNext(); /* eat the dot */ ! 794: strcat(sbFloat, "."); ! 795: /* we allow them to say "10." instead of "10.0" */ ! 796: if (tkNumber == TkPeek()) { ! 797: TkNext(); /* actually get the number */ ! 798: strcat(sbFloat, vsbTok); /* get fractional part */ ! 799: } /* if */ ! 800: stuff.fl = atof(sbFloat); ! 801: PushVar(stuff.lng, vtyCnFloat); /* sorta kludgey */ ! 802: return(tkNumber); ! 803: } ! 804: else { ! 805: val = atol(vsbTok); ! 806: } /* if */ ! 807: } /* if */ ! 808: ! 809: TkPeek(); ! 810: /* did they specify long? */ ! 811: if ((vcbPeek == 1) ! 812: AND (vsbTokPeek[0] == 'L' OR vsbTokPeek[0] == 'l')) { ! 813: TkNext(); /* actually eat the L or l */ ! 814: PushVar(val, vtyCnLong); ! 815: } ! 816: else { ! 817: valShort = val & 0x0000ffff; ! 818: PushVar(val, (val==valShort) ? vtyCnInt : vtyCnLong); ! 819: } ! 820: return(tkNumber); ! 821: /* NOTREACHED */ ! 822: break; ! 823: case tkStr: ! 824: if ((TOPOP == tkDot) OR (TOPOP == tkPtr)) { ! 825: /* we don't do anything until we PROCESS the field. ! 826: * so we jam the name in a record. ! 827: */ ! 828: ty[0] = *vtyZeros; ! 829: ty[1] = *vtyZeros; ! 830: #ifdef BSD41 ! 831: ty[0].sbVar = SbSafe(vsbTok); ! 832: #else ! 833: strncpy(ty[0].sbVar, vsbTok, cbVarMax); ! 834: #endif ! 835: ty[0].td.fConstant = true; ! 836: ty[0].td.st = stStruct; ! 837: PushVar(0L, ty); ! 838: return(psVar); ! 839: } /* if */ ! 840: ! 841: /* is it a register or Special variable? */ ! 842: if (vsbTok[0] == '$') { ! 843: if (FAdrFSpecial(vsbTok, ty, &adr)) { ! 844: PushVar(lengthen(adr), ty); ! 845: break; ! 846: } /* if */ ! 847: UError("Unknown special variable `%s'", vsbTok); ! 848: } /* if */ ! 849: ! 850: /* is it a local? */ ! 851: if ((vipd != ipdNil) ! 852: AND ((adr=AdrFLocal(vipd, -1, vsbTok, ty)) != adrNil)) { ! 853: PushVar(lengthen(adr), ty); ! 854: break; ! 855: } /* if */ ! 856: ! 857: /* is it a global? */ ! 858: if ((adr = AdrFGlobal(vsbTok, ty)) != adrNil) { ! 859: PushVar(lengthen(adr), ty); ! 860: break; ! 861: } /* if */ ! 862: ! 863: /* is it a procedure name? */ ! 864: if ((ipd = IpdFName(vsbTok)) != ipdNil) { ! 865: /* it is a procedure name! is there anymore to the name? */ ! 866: tk = TkPeek(); ! 867: if (tk == tkDot) { ! 868: /* so far we know `procname.' */ ! 869: TkNext(); /* eat dot */ ! 870: /* we want full name of a local */ ! 871: FpApFIpd(&fp, &ap, ipd, -1); ! 872: if (fp == 0) ! 873: UError("procedure %s not active",vrgPd[ipd].sbProc); ! 874: tk = TkNext(); ! 875: cnt = -1; /* default - take first instance */ ! 876: if (tk == tkNumber) { ! 877: /* we have `proc.3' (or something like that). ! 878: * they want a SPECIFIC instance of this proc ! 879: * at backtrace location #. ! 880: * This is useful for recursive procedures... ! 881: */ ! 882: cnt = atoi(vsbTok); ! 883: if (TkNext() != tkDot) ! 884: UError("Need a `.' after the number"); ! 885: ; ! 886: tk = TkNext(); ! 887: } /* if */ ! 888: if (tk != tkStr) { ! 889: /* procname.???? */ ! 890: UError("Syntax error - bad local name '%s'",vsbTok); ! 891: } /* if */ ! 892: if ((adr = AdrFLocal(ipd,cnt,vsbTok,ty)) ! 893: != adrNil) { ! 894: PushVar(lengthen(adr), ty); ! 895: return(tkAdr); ! 896: } ! 897: else { ! 898: UError("No such local - %s.%s", ! 899: vrgPd[ipd].sbProc, vsbTok); ! 900: } /* if */ ! 901: } ! 902: else if (tk == tkLP) { ! 903: /* we have `procname(' - must be a procedure call */ ! 904: TkNext(); /* eat ( */ ! 905: val = DoProc(ipd, ty, adrNil); ! 906: PushVar(val, ty); ! 907: break; ! 908: } ! 909: else if (tk == tkHash) { ! 910: TkNext(); /* eat the # */ ! 911: tk = TkNext(); ! 912: if (tk != tkNumber) ! 913: UError("'#' should be followed by a decimal line number."); ! 914: iln = atoi(vsbTok); ! 915: ifd = IfdFIpd(ipd); ! 916: adr = AdrFIfdLn(ifd, iln); /* get adr of this line */ ! 917: PushVar(lengthen(adr), vtyCnInt); ! 918: } ! 919: else { ! 920: /* proc name followed by ???, give proc adr and type */ ! 921: TyFLocal(ty, vrgPd[ipd].sbProc, vrgPd[ipd].isym); ! 922: PushVar(lengthen(vrgPd[ipd].adrStart), ty); ! 923: } /* if */ ! 924: } ! 925: else if ((adr=AdrFLabel(vsbTok)) != adrNil) { ! 926: /* it is a label */ ! 927: TkPeek(); ! 928: if (vtkPeek == tkLP) { ! 929: /* we have `label(' - must be a procedure call */ ! 930: TkNext(); /* eat ( */ ! 931: val = DoProc(ipdNil, ty, adr); ! 932: PushVar(val, ty); ! 933: } ! 934: else { ! 935: PushVar(lengthen(adr), vtyCnInt); ! 936: } ! 937: } ! 938: else { ! 939: /* don't what it is, it is NOT something we can handle! */ ! 940: return(tkNil); ! 941: } /* if */ ! 942: break; ! 943: } /* switch */ ! 944: return(tkAdr); ! 945: } /* TkFOperand */ ! 946: ! 947: ! 948: /* T K F E X P R */ ! 949: ! 950: export TKE TkFExpr(pret, ty) ! 951: long *pret; ! 952: pTYR ty; ! 953: { ! 954: int cbTemp; ! 955: PSE ps; ! 956: TKE tk, tkRet, tkTemp; ! 957: char *sbCmdTemp, sbTokTemp[50]; ! 958: ! 959: if (vtk == tkNil) { ! 960: *pret = 0; ! 961: return(tkNil); ! 962: } /* if */ ! 963: ! 964: /* save the token state in case we think it is garbage */ ! 965: cbTemp = vcbTok; ! 966: sbCmdTemp = vsbCmd; ! 967: tk = tkTemp = vtk; ! 968: ps = psOp; ! 969: strcpy(sbTokTemp, vsbTok); ! 970: ! 971: PushOp(tkBOE); /* push a {ning-of-expression onto the stack */ ! 972: ! 973: /* we do a little dance here to see if we have a pure number */ ! 974: tkRet = TkFOperand(); ! 975: if (tkRet != tkNil) { ! 976: ps = psVar; ! 977: tk = TkNext(); ! 978: if ((tkRet == tkNumber) AND (PrecFTk(tk)==0)) { ! 979: tk = PopOp(); /* eat the BOE */ ! 980: FPopVar(pret, ty); ! 981: return(tkNumber); ! 982: } /* if */ ! 983: } ! 984: else if (PrecFTk(tk) == 0) { ! 985: /* it is neither an operator nor an operand */ ! 986: goto bombout; ! 987: } /* if */ ! 988: ! 989: if (tk == tkComma) { ! 990: PushOp(tkLP); /* makes procedure call code easier */ ! 991: tk = TkNext(); ! 992: } /* if */ ! 993: ! 994: while (tk != tkNil) { ! 995: if ( (PrecFTk(tk) != 0) ! 996: AND ((tk != tkDot) OR (ps == psVar)) ) { ! 997: /* it is an operator */ ! 998: ps = PsFOperator(tk, ps); ! 999: if (ps == psFail) ! 1000: goto bombout; ! 1001: if (tk == tkComma) ! 1002: break; ! 1003: } ! 1004: else { ! 1005: /* it's not an operator, is it an OPERAND?? */ ! 1006: tk = TkFOperand(); ! 1007: if (tk == tkNil) { ! 1008: ps = psFail; ! 1009: break; /* not operand - fall out of loop and see what happens */ ! 1010: } /* if */ ! 1011: ps = psVar; /* yup, it was an operand - and it's on the stack */ ! 1012: } /* if */ ! 1013: tk = TkNext(); ! 1014: } /* while */ ! 1015: ! 1016: /* one way or the other, someone thinks we might be done, try it and see */ ! 1017: if (psFail != PsFOperator(tkEOE, ps)) { ! 1018: FPopVar(pret, ty); /* put final stuff in return variables */ ! 1019: return(tkAdr); ! 1020: } /* if */ ! 1021: ! 1022: bombout: ! 1023: /* something ain't right - reset the universe */ ! 1024: vcbTok = cbTemp; ! 1025: vsbCmd = sbCmdTemp; ! 1026: vtk = tkTemp; ! 1027: strcpy(vsbTok, sbTokTemp); ! 1028: vivarMac = 0; /* stack pointer cleanup */ ! 1029: viopMac = 0; ! 1030: return(tkNil); ! 1031: } /* TkFExpr */ ! 1032: ! 1033: ! 1034: /* G E T E X P R */ ! 1035: ! 1036: export long GetExpr(pty, tk) ! 1037: pTYR *pty; ! 1038: TKE tk; ! 1039: { ! 1040: long adrLong, i; ! 1041: static TYR ty[cTyMax]; ! 1042: /* ty is used for callers to GetExp who don't want to be bothered ! 1043: * with allocating an ty. ! 1044: * NOTE(!): if they want this info for more than a statement or two, ! 1045: * they MUST copy it someplace else!!! ! 1046: */ ! 1047: ! 1048: if (tk == tkNil) ! 1049: TkNext(); ! 1050: if (TkFExpr(&adrLong, ty) != tkNil) { ! 1051: i = ValFAdr(adrLong, ty); ! 1052: *pty = ty; ! 1053: } ! 1054: else { ! 1055: *pty = tyNil; ! 1056: } /* if */ ! 1057: return(i); ! 1058: } /* GetExpr */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.