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