![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to interp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 42BSD / ingres / source / ovqp|
Return to interp.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / ovqp |
1.1 ! root 1: # include <ingres.h> ! 2: # include <aux.h> ! 3: # include <symbol.h> ! 4: # include <tree.h> ! 5: # include <access.h> ! 6: # include "../decomp/globs.h" ! 7: # include <sccs.h> ! 8: ! 9: SCCSID(@(#)interp.c 7.3 3/6/81) ! 10: ! 11: ! 12: ! 13: /* ! 14: ** ! 15: ** INTERPRET ! 16: ** ! 17: ** Processes the retrieved tuple from the De.ov_source relation ! 18: ** according to the symbols in the list. Recognition ! 19: ** of characteristic delimiters and separators initiates ! 20: ** action appropriate to a target list or qualification list ! 21: ** as the case may be. ! 22: ** ! 23: ** Between delimiters, the symbol list is expected to be in ! 24: ** Polish postfix form. A qualification list is further ! 25: ** expected to be in conjunctive normal form, with Boolean ! 26: ** operators infixed. ! 27: ** ! 28: */ ! 29: ! 30: ! 31: double pow(); ! 32: double sqrt(); ! 33: double log(); ! 34: double exp(); ! 35: double sin(); ! 36: double cos(); ! 37: double atan(); ! 38: ! 39: # define SPUSH(v) (++((struct stacksym *) v)) ! 40: # define SPOP(v) (((struct stacksym *) v)--) ! 41: ! 42: SYMBOL * ! 43: interpret(list) ! 44: SYMBOL **list; /* ptr to list of sym pointers */ ! 45: { ! 46: register SYMBOL *tos; ! 47: SYMBOL *op1,*op2; /*operands popped off stack*/ ! 48: register ANYTYPE *val1,*val2; /*ptrs to values of operands*/ ! 49: int opval, optype, l1; ! 50: char *s1; ! 51: int byflag; ! 52: long hitid; ! 53: extern char *Usercode; ! 54: extern ov_err(); ! 55: int cb_mark; ! 56: extern char *ov_ovqpbuf; ! 57: extern char *locv(); ! 58: ! 59: # ifdef xOTR1 ! 60: if (tTf(72, 0)) ! 61: printf("INTERP: list=%x\n",list); ! 62: # endif ! 63: ! 64: # ifdef xOTM ! 65: if (tTf(90, 2)) ! 66: timtrace(11, 0); ! 67: # endif ! 68: ! 69: byflag = (list == De.ov_bylist); /* set byflag if aggregate function */ ! 70: tos = (SYMBOL *)(De.ov_stack-1); ! 71: /* reset the concat and ascii operator buffer */ ! 72: seterr(De.ov_ovqpbuf, CBUFULL, ov_err); ! 73: cb_mark = markbuf(De.ov_ovqpbuf); ! 74: ! 75: loop: ! 76: # ifdef xOTR1 ! 77: if (tTf(72, 1) && tos >= (SYMBOL *) De.ov_stack) ! 78: { ! 79: printf("\ttops of stack="); ! 80: prstack(tos); /* print top of stack element */ ! 81: } ! 82: # endif ! 83: /* check for stack overflow */ ! 84: l1 = getsymbol(SPUSH(tos), &list); ! 85: ! 86: if (l1) ! 87: { ! 88: # ifdef xOTM ! 89: if (tTf(90, 2)) ! 90: timtrace(12, 0); ! 91: # endif ! 92: ! 93: freebuf(De.ov_ovqpbuf, cb_mark); ! 94: return (tos); ! 95: } ! 96: optype = tos->type; ! 97: opval = tos->value.sym_data.i2type; ! 98: SPOP(tos); /* assume that stack will be popped */ ! 99: ! 100: switch(optype) ! 101: { ! 102: case INT: ! 103: case FLOAT: ! 104: case CHAR: ! 105: SPUSH(tos); /* just leave symbol on stack */ ! 106: goto loop; ! 107: ! 108: case COP: ! 109: SPUSH(tos); /* new symbol goes on stack */ ! 110: tos->type = CHAR; ! 111: switch (opval) ! 112: { ! 113: ! 114: case opDBA: ! 115: tos->value.sym_data.cptype = Admin.adhdr.adowner; ! 116: tos->len = 2; ! 117: goto loop; ! 118: ! 119: case opUSERCODE: ! 120: tos->value.sym_data.cptype = Usercode; ! 121: tos->len = 2; ! 122: goto loop; ! 123: } ! 124: ! 125: case AND: /* if top value false return immediately */ ! 126: if (!tos->value.sym_data.i2type) ! 127: { ! 128: # ifdef xOTM ! 129: if (tTf(90, 2)) ! 130: timtrace(12, 0); ! 131: # endif ! 132: freebuf(De.ov_ovqpbuf, cb_mark); ! 133: return(tos); ! 134: } ! 135: else ! 136: SPOP(tos); ! 137: freebuf(De.ov_ovqpbuf, cb_mark); ! 138: goto loop; ! 139: ! 140: case OR: /* if top value is true then skip to ! 141: ** end of disjunction. */ ! 142: if (tos->value.sym_data.i2type) ! 143: { ! 144: SPUSH(tos); ! 145: do ! 146: { ! 147: getsymbol(tos, &list); ! 148: } while (tos->type != AND); ! 149: optype = AND; ! 150: SPOP(tos); ! 151: } ! 152: SPOP(tos); ! 153: goto loop; ! 154: ! 155: case RESDOM: ! 156: freebuf(De.ov_ovqpbuf, cb_mark); /* init the concat and ascii buffer */ ! 157: if (De.ov_result) ! 158: { ! 159: if (opval) /* if gt zero then opval represents a real domain */ ! 160: { ! 161: if (byflag) ! 162: opval++; /* skip over count field for ag functs */ ! 163: rcvt(tos, De.ov_result->relfrmt[opval], De.ov_result->relfrml[opval]); ! 164: tout(tos, De.ov_outtup+De.ov_result->reloff[opval], De.ov_result->relfrml[opval]); ! 165: } ! 166: else /* opval refers to the tid and this is an update */ ! 167: { ! 168: De.ov_uptid = tos->value.sym_data.i4type; /* copy tid */ ! 169: if (De.de_qmode == mdREPL || (De.ov_diffrel && De.de_qmode == mdDEL && De.ov_result->reldum.relindxd > 0 )) ! 170: { ! 171: /* De.ov_origtup must be left with the orig ! 172: ** unaltered tuple, and De.ov_outtup must ! 173: ** be initialized with the orig tuple. ! 174: ** ! 175: ** De.ov_outtup only matters with REPL. ! 176: ** Scan() sets up De.ov_origtup so when ! 177: ** De.ov_source == De.ov_result, origtup is already ! 178: ** correct. ! 179: */ ! 180: ! 181: if (De.ov_diffrel) ! 182: { ! 183: if (l1 = get(De.ov_result, &De.ov_uptid, &hitid, De.ov_origtup, CURTUP)) ! 184: syserr("interp:get on resdom %s, %d", locv(De.ov_uptid), l1); ! 185: bmove(De.ov_origtup, De.ov_outtup, De.ov_result->reldum.relwid); ! 186: } ! 187: else ! 188: { ! 189: bmove(De.ov_intup, De.ov_outtup, De.ov_result->reldum.relwid); ! 190: } ! 191: } ! 192: } ! 193: } ! 194: else ! 195: { ! 196: if (Equel) ! 197: equelatt(tos); /* send attribute to equel */ ! 198: else ! 199: { ! 200: if (tos->type == CHAR) ! 201: s1 = tos->value.sym_data.cptype; ! 202: else ! 203: s1 = tos->value.sym_data.c0type; ! 204: printatt(tos->type, tos->len & 0377, s1); /* print attribute */ ! 205: } ! 206: } ! 207: SPOP(tos); ! 208: goto loop; ! 209: ! 210: ! 211: case BOP: ! 212: op2 = (SYMBOL *)SPOP(tos); ! 213: op1 = (SYMBOL *)tos; ! 214: typecheck(op1, op2, opval); ! 215: val1 = &op1->value.sym_data; ! 216: val2 = &op2->value.sym_data; ! 217: ! 218: switch (tos->type) ! 219: { ! 220: case INT: ! 221: switch (tos->len) ! 222: { ! 223: case 1: ! 224: case 2: ! 225: switch (opval) ! 226: { ! 227: case opADD: ! 228: val1->i2type += val2->i2type; ! 229: goto loop; ! 230: ! 231: case opSUB: ! 232: val1->i2type -= val2->i2type; ! 233: goto loop; ! 234: ! 235: case opMUL: ! 236: val1->i2type *= val2->i2type; ! 237: goto loop; ! 238: ! 239: case opDIV: ! 240: val1->i2type /= val2->i2type; ! 241: goto loop; ! 242: ! 243: case opMOD: ! 244: val1->i2type %= val2->i2type; ! 245: goto loop; ! 246: ! 247: case opPOW: ! 248: itof(op1); ! 249: itof(op2); ! 250: val1->f8type = pow(val1->f8type, val2->f8type); ! 251: goto loop; ! 252: ! 253: /* relational operator */ ! 254: default: ! 255: l1 = val1->i2type - val2->i2type; ! 256: val1->i2type = relop_interp(opval, l1); ! 257: goto loop; ! 258: } ! 259: ! 260: case 4: ! 261: switch(opval) ! 262: { ! 263: case opADD: ! 264: val1->i4type += val2->i4type; ! 265: goto loop; ! 266: ! 267: case opSUB: ! 268: val1->i4type -= val2->i4type; ! 269: goto loop; ! 270: ! 271: case opMUL: ! 272: val1->i4type *= val2->i4type; ! 273: goto loop; ! 274: ! 275: case opDIV: ! 276: val1->i4type /= val2->i4type; ! 277: goto loop; ! 278: ! 279: case opMOD: ! 280: val1->i4type %= val2->i4type; ! 281: goto loop; ! 282: ! 283: case opPOW: ! 284: itof(op1); ! 285: itof(op2); ! 286: val1->f8type = pow(val1->f8type, val2->f8type); ! 287: goto loop; ! 288: ! 289: /* relational operator */ ! 290: default: ! 291: tos->len = 2; ! 292: if (val1->i4type > val2->i4type) ! 293: l1 = 1; ! 294: else ! 295: if (val1->i4type == val2->i4type) ! 296: l1 = 0; ! 297: else ! 298: l1 = -1; ! 299: ! 300: val1->i2type = relop_interp(opval, l1); ! 301: goto loop; ! 302: ! 303: } ! 304: } ! 305: ! 306: case FLOAT: ! 307: switch (opval) ! 308: { ! 309: case opADD: ! 310: val1->f8type += val2->f8type; ! 311: goto loop; ! 312: ! 313: case opSUB: ! 314: val1->f8type -= val2->f8type; ! 315: goto loop; ! 316: ! 317: case opMUL: ! 318: val1->f8type *= val2->f8type; ! 319: goto loop; ! 320: ! 321: case opDIV: ! 322: val1->f8type /= val2->f8type; ! 323: goto loop; ! 324: ! 325: case opPOW: ! 326: val1->f8type = pow(val1->f8type, val2->f8type); ! 327: goto loop; ! 328: ! 329: default: ! 330: tos->type = INT; ! 331: tos->len = 2; ! 332: if (val1->f8type > val2->f8type) ! 333: l1 = 1; ! 334: else ! 335: if (val1->f8type == val2->f8type) ! 336: l1 = 0; ! 337: else ! 338: l1 = -1; ! 339: val1->i2type = relop_interp(opval, l1); ! 340: goto loop; ! 341: } ! 342: ! 343: case CHAR: ! 344: if (opval == opCONCAT) ! 345: { ! 346: concatsym(op1, op2); /* concatenate the two symbols */ ! 347: goto loop; ! 348: } ! 349: l1 = lexcomp(val1->cptype, op1->len & 0377, val2->cptype, op2->len & 0377); ! 350: tos->type = INT; ! 351: tos->len = 2; ! 352: val1->i2type = relop_interp(opval, l1); ! 353: goto loop; ! 354: } /* end of BOP */ ! 355: ! 356: case UOP: ! 357: val1 = &tos->value.sym_data; ! 358: switch (opval) ! 359: { ! 360: case opMINUS: ! 361: case opABS: ! 362: if (tos->type == CHAR) ! 363: ov_err(BADUOPC); ! 364: l1 = opval == opMINUS; ! 365: switch (tos->type) ! 366: { ! 367: case INT: ! 368: switch (tos->len) ! 369: { ! 370: case 1: ! 371: case 2: ! 372: if (l1 || val1->i2type < 0) ! 373: val1->i2type = -val1->i2type; ! 374: goto loop; ! 375: ! 376: case 4: ! 377: if (l1 || val1->i4type < 0) ! 378: val1->i4type = -val1->i4type; ! 379: goto loop; ! 380: } ! 381: ! 382: case FLOAT: ! 383: if (l1 || val1->f8type < 0.0) ! 384: val1->f8type = -val1->f8type; ! 385: goto loop; ! 386: } ! 387: ! 388: case opNOT: ! 389: val1->i2type = !val1->i2type; ! 390: case opPLUS: ! 391: if (tos->type == CHAR) ! 392: ov_err(BADUOPC); ! 393: goto loop; ! 394: ! 395: case opASCII: ! 396: ascii(tos); ! 397: goto loop; ! 398: ! 399: case opINT1: ! 400: typecoerce(tos, INT, 1); ! 401: goto loop; ! 402: ! 403: case opINT2: ! 404: typecoerce(tos, INT, 2); ! 405: goto loop; ! 406: ! 407: case opINT4: ! 408: typecoerce(tos, INT, 4); ! 409: goto loop; ! 410: ! 411: case opFLOAT4: ! 412: typecoerce(tos, FLOAT, 4); ! 413: goto loop; ! 414: ! 415: case opFLOAT8: ! 416: typecoerce(tos, FLOAT, 8); ! 417: goto loop; ! 418: ! 419: default: ! 420: if (tos->type == CHAR) ! 421: ov_err(BADUOPC); ! 422: if (tos->type == INT) ! 423: itof(tos); ! 424: switch (opval) ! 425: { ! 426: case opATAN: ! 427: val1->f8type = atan(val1->f8type); ! 428: goto loop; ! 429: ! 430: case opLOG: ! 431: val1->f8type = log(val1->f8type); ! 432: goto loop; ! 433: ! 434: case opSIN: ! 435: val1->f8type = sin(val1->f8type); ! 436: goto loop; ! 437: ! 438: case opCOS: ! 439: val1->f8type = cos(val1->f8type); ! 440: goto loop; ! 441: ! 442: case opSQRT: ! 443: val1->f8type = sqrt(val1->f8type); ! 444: goto loop; ! 445: ! 446: case opEXP: ! 447: val1->f8type = exp(val1->f8type); ! 448: goto loop; ! 449: ! 450: default: ! 451: syserr("interp:bad uop %d",opval); ! 452: } ! 453: } ! 454: ! 455: ! 456: case AOP: ! 457: aop_interp(opval, tos); ! 458: SPOP(tos); /* pop this symbol */ ! 459: goto loop; ! 460: ! 461: } ! 462: syserr("interp: fell out"); ! 463: /*NOTREACHED*/ ! 464: } ! 465: /* ! 466: ** relop_interp interprets the relational operators ! 467: ** (ie. EQ, NE etc.) and returns true or false ! 468: ** by evaluating l1. ! 469: ** ! 470: ** l1 should be greater than, equal or less than zero. ! 471: */ ! 472: ! 473: relop_interp(opval, l1) ! 474: int opval; ! 475: int l1; ! 476: { ! 477: register int i; ! 478: ! 479: i = l1; ! 480: ! 481: switch (opval) ! 482: { ! 483: ! 484: case opEQ: ! 485: return (i == 0); ! 486: ! 487: case opNE: ! 488: return (i != 0); ! 489: ! 490: case opLT: ! 491: return (i < 0); ! 492: ! 493: case opLE: ! 494: return (i <= 0); ! 495: ! 496: case opGT: ! 497: return (i > 0); ! 498: ! 499: case opGE: ! 500: return (i >= 0); ! 501: ! 502: default: ! 503: syserr("relop:bad relop or bop %d", opval); ! 504: } ! 505: /*NOTREACHED*/ ! 506: } ! 507: /* ! 508: ** Aggregate values are stored in De.ov_outtup. De.ov_tend points ! 509: ** to the spot for the next aggregate. Aop_interp() ! 510: ** computes the value for the aggregate and leaves ! 511: ** the result in the position pointed to by De.ov_tend. ! 512: */ ! 513: ! 514: aop_interp(opval, tos) ! 515: int opval; ! 516: register SYMBOL *tos; ! 517: { ! 518: register int i; ! 519: int l1; ! 520: ANYTYPE numb; /* used for type conversion */ ! 521: ! 522: bmove(De.ov_tend, (char *) &numb, 8); /* note: this assumes that there are always 8 bytes which can be moved. ! 523: ** if it moves beyond De.ov_tend, it's ok */ ! 524: switch (opval) ! 525: { ! 526: ! 527: case opSUMU: ! 528: case opSUM: ! 529: if (*De.ov_counter <= 1) ! 530: goto puta; ! 531: switch (tos->type) ! 532: { ! 533: case INT: ! 534: switch(tos->len) ! 535: { ! 536: case 1: ! 537: tos->value.sym_data.i2type += numb.i1type; ! 538: goto puta; ! 539: ! 540: case 2: ! 541: tos->value.sym_data.i2type += numb.i2type; ! 542: goto puta; ! 543: ! 544: case 4: ! 545: tos->value.sym_data.i4type += numb.i4type; ! 546: goto puta; ! 547: } ! 548: ! 549: case FLOAT: ! 550: if (tos->len == 4) ! 551: numb.f8type = numb.f4type; ! 552: tos->value.sym_data.f8type += numb.f8type; ! 553: goto puta; ! 554: ! 555: default: ! 556: ov_err(BADSUMC); /* cant sum char fields */ ! 557: } ! 558: ! 559: case opCOUNTU: ! 560: case opCOUNT: ! 561: tos->type = CNTTYPE; ! 562: tos->len = CNTLEN; ! 563: tos->value.sym_data.i4type = *De.ov_counter; ! 564: goto puta; ! 565: ! 566: case opANY: ! 567: tos->type = OANYTYPE; ! 568: tos->len = OANYLEN; ! 569: if (*De.ov_counter) ! 570: { ! 571: tos->value.sym_data.i2type = 1; ! 572: if (!De.ov_bylist && (De.ov_agcount == 1)) ! 573: De.ov_targvc = 0; /* if simple agg. stop scan */ ! 574: } ! 575: else ! 576: tos->value.sym_data.i2type = 0; ! 577: goto puta; ! 578: ! 579: case opMIN: ! 580: case opMAX: ! 581: if (*De.ov_counter<=1) ! 582: goto puta; ! 583: switch (tos->type) ! 584: { ! 585: case INT: ! 586: switch (tos->len) ! 587: { ! 588: case 1: ! 589: i = (tos->value.sym_data.i1type < numb.i1type); ! 590: break; ! 591: ! 592: case 2: ! 593: i = (tos->value.sym_data.i2type < numb.i2type); ! 594: break; ! 595: ! 596: case 4: ! 597: i = (tos->value.sym_data.i4type < numb.i4type); ! 598: break; ! 599: } ! 600: break; ! 601: ! 602: case FLOAT: ! 603: if (tos->len == 4) ! 604: numb.f8type = numb.f4type; ! 605: i = (tos->value.sym_data.f8type < numb.f8type); ! 606: break; ! 607: ! 608: case CHAR: ! 609: l1 = tos->len & 0377; ! 610: i = (lexcomp(tos->value.sym_data.cptype, l1, De.ov_tend, l1) < 0); ! 611: break; ! 612: ! 613: default: ! 614: syserr("interp:bad op type for opMIN/MAX %d", tos->type); ! 615: } ! 616: ! 617: /* check result of comparison */ ! 618: if (opval == opMAX) ! 619: i = !i; /* complement test for opMAX */ ! 620: if (i) ! 621: goto puta; /* condition true. new value */ ! 622: ! 623: /* condition false. Keep old value */ ! 624: goto done; ! 625: ! 626: ! 627: case opAVGU: ! 628: case opAVG: ! 629: if (tos->type == INT) ! 630: itof(tos); ! 631: else ! 632: if (tos->type == CHAR) ! 633: ov_err(BADAVG); ! 634: if (*De.ov_counter > 1) ! 635: { ! 636: tos->value.sym_data.f8type = numb.f8type + (tos->value.sym_data.f8type - numb.f8type) / *De.ov_counter; ! 637: } ! 638: tos->len = 8; ! 639: goto puta; ! 640: ! 641: default: ! 642: syserr("interp:bad agg op %d", tos->type); ! 643: } ! 644: ! 645: puta: ! 646: tout(tos, De.ov_tend, tos->len); ! 647: done: ! 648: De.ov_tend += tos->len & 0377; ! 649: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.