![[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 [CSRG BSD Unix] / 42BSD / ingres / source / monitor|
Return to expr.c CVS log | Up to [CSRG BSD Unix] / 42BSD / ingres / source / monitor |
1.1 root 1: # include <ingres.h>
2: # include <sccs.h>
3:
4: SCCSID(@(#)expr.c 7.1 2/5/81)
5:
6:
7:
8: /*
9: ** EXPR -- evaluate expression
10: **
11: ** This module evaluates an expression in somewhat standard
12: ** infix notation. Several restrictions apply. There are
13: ** no variables, since this can be simulated with the macro
14: ** processor. No numeric overflow is checked. There may be
15: ** no spaces, tabs, or newlines in the expression.
16: **
17: ** The text of the expression is read from 'macgetch', so
18: ** that must be initialized before calling this routine.
19: **
20: ** Operators accepted are + - * / < > >= <= = != % ( )
21: ** & |.
22: ** Operands may be signed integers.
23: ** Standard precedence applies.
24: **
25: ** An expression can be viewed as a sequence of operands,
26: ** and operators. If the terminator is considered to be
27: ** an operator, then the sequence must be composed
28: ** of n matched pairs of operators and operands. NOT and
29: ** Negation are considered to be part of the operand and
30: ** are treated as such. Thus to evaluate an expression,
31: ** n pairs are read until the terminator is found as the
32: ** last operator.
33: **
34: ** Parameters:
35: ** none
36: **
37: ** Returns:
38: ** value of the expression. Undetermined value
39: ** on error.
40: **
41: ** Side Effects:
42: ** Macro processing can occur.
43: **
44: ** Trace Flags:
45: ** none
46: */
47:
48:
49:
50: # undef STACKSIZE
51: # define STACKSIZE 50
52: # define RIGHTP 21
53: # define END 22
54: # define SEPERATOR 0
55: # define OR 1
56: # define AND 2
57: # define EQUALS 3
58: # define NEQ 4
59: # define LESS 5
60: # define LEQ 6
61: # define GREATER 7
62: # define GEQ 8
63: # define ADD 9
64: # define SUBTRACT 10
65: # define MULTIPLY 11
66: # define DIVIDE 12
67: # define MOD 13
68:
69:
70: int ExprPrec[] = /* Precedence table */
71: {
72: 0, /* filler */
73: 1, /* 1 -- OR */
74: 2, /* 2 -- AND */
75: 3, /* 3 -- EQUALS */
76: 3, /* 4 -- NEQ */
77: 4, /* 5 -- LESS */
78: 4, /* 6 -- LEQ */
79: 4, /* 7 -- GREATER */
80: 4, /* 8 -- GEQ */
81: 5, /* 9 -- ADD */
82: 5, /* 10 -- SUBTRACT */
83: 6, /* 11 -- MULTIPLY */
84: 6, /* 12 -- DIVIDE */
85: 6 /* 13 -- MOD */
86: };
87:
88:
89: int ExprNstack[STACKSIZE];
90: int *ExprNptr;
91: int ExprOstack[STACKSIZE];
92: int *ExprOptr;
93: int ExprError;
94: char ExprPeek;
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106: expr()
107: {
108: ExprNptr = ExprNstack;
109: ExprOptr = ExprOstack;
110: ExprError = FALSE;
111: ExprPeek = -1;
112: return(valof(END));
113: }
114: /*
115: ** VALOF -- compute value of expression
116: **
117: ** This is the real expression processor. It handles sequencing
118: ** and precedence.
119: **
120: ** Parameters:
121: ** terminator -- the symbol which should terminate
122: ** the expression.
123: **
124: ** Returns:
125: ** The value of the expression.
126: **
127: ** Side Effects:
128: ** Gobbles input.
129: **
130: ** Requires:
131: ** exprfind -- to read operands.
132: ** opfind -- to read operators.
133: ** exp_op -- to perform operations.
134: **
135: ** Called By:
136: ** expr
137: **
138: ** Diagnostics:
139: ** Extra Parenthesis found: assumed typo
140: ** An unmatched right parenthesis was read.
141: ** It was thrown away.
142: ** Insufficient parenthesis found: assumed zero.
143: ** An unmatched left parenthesis was left
144: ** in the operator stack at the end of the
145: ** expression. The value zero was taken
146: ** for the expression.
147: **
148: ** Syserrs:
149: ** none
150: */
151:
152: valof(terminator)
153: int terminator;
154: {
155: register int number;
156: register int operator;
157:
158: pushop(SEPERATOR); /* initialize the stack */
159:
160: for(;;)
161: {
162: number = exprfind();
163: if (ExprError)
164: return(0);
165: operator = opfind();
166: if (ExprError)
167: return(0);
168:
169: if (operator == RIGHTP || operator == END)
170: break;
171:
172: /* Do all previous operations with a higher precedence */
173: while (ExprPrec[operator] <= ExprPrec[ExprOptr[-1]])
174: number = exp_op(popop(), popnum(), number);
175: pushop(operator);
176: pushnum(number);
177: }
178: if (operator != terminator) /* ExprError in operators */
179: if (operator == RIGHTP)
180: printf("Extra parenthesis found: assumed typo.\n");
181: else
182: {
183: ExprError = TRUE;
184: printf("Insufficient parenthesis found: Assumed zero.\n");
185: return(0);
186: }
187: /* Empty stack for this call of valof */
188: while ((operator = popop()) != SEPERATOR)
189: number = exp_op(operator, popnum(), number);
190:
191: return(number);
192: }
193: /*
194: ** EXPRFIND -- find and chomp operand
195: **
196: ** This routine reads the next operand. It generally just
197: ** reads numbers, except it also knows about unary operators
198: ** ! and - (where it calls itself recursively), and paren-
199: ** theses (where it calls valof recursively).
200: **
201: ** Parameters:
202: ** none
203: **
204: ** Returns:
205: ** value of operand.
206: **
207: ** Side Effects:
208: ** Gobbles input.
209: **
210: ** Requires:
211: ** numberget -- to read numbers.
212: ** exprgch.
213: **
214: ** Called By:
215: ** valof
216: ** exprfind (recursively)
217: **
218: ** Trace Flags:
219: ** none
220: **
221: ** Diagnostics:
222: ** Expression expected: end of expression found.
223: ** Nothing was found. Zero is returned.
224: ** Expression expected: %c found; assumed zero.
225: ** A syntax error -- nothing was found
226: ** which was acceptable.
227: */
228:
229:
230:
231: exprfind()
232: {
233: register int result;
234: register int c;
235:
236: c = exprgch();
237:
238: switch(c)
239: {
240:
241: case '0':
242: case '1':
243: case '2':
244: case '3':
245: case '4':
246: case '5':
247: case '6':
248: case '7':
249: case '8':
250: case '9':
251: return(numberget(c));
252:
253: case '!':
254: result = exprfind();
255: return(ExprError ? 0 : (result <= 0));
256:
257: case '-':
258: result = exprfind();
259: return(ExprError ? 0 : -result);
260:
261: case '(':
262: return(valof(RIGHTP));
263:
264: case ' ':
265: case '\n':
266: case '/t':
267: case '\0':
268: printf("Expression expected: end of expression found.\n");
269: ExprError = TRUE;
270: return(0);
271:
272: default:
273: printf("Expression expected; '%c' found: Assumed zero.\n", c);
274: ExprError = TRUE;
275: return(0);
276: }
277: }
278: /*
279: ** OPFIND -- find and translate operator
280: **
281: ** This reads the next operator from the input stream and
282: ** returns the internal code for it.
283: **
284: ** Parameters:
285: ** none
286: **
287: ** Returns:
288: ** The code for the next operator.
289: ** Zero on error.
290: **
291: ** Side Effects:
292: ** Gobbles input.
293: **
294: ** Requires:
295: ** exprgch.
296: **
297: ** Called By:
298: ** valof
299: **
300: ** Trace Flags:
301: ** none
302: **
303: ** Diagnostics:
304: ** Operator expected: '%c' found.
305: ** Gibberish in input.
306: */
307:
308: opfind()
309: {
310: register int c;
311:
312: c = exprgch();
313:
314: switch(c)
315: {
316:
317: case '/':
318: return(DIVIDE);
319:
320: case '=':
321: return(EQUALS);
322:
323: case '&':
324: return(AND);
325:
326: case '|':
327: return(OR);
328:
329: case '+':
330: return(ADD);
331:
332: case '-':
333: return(SUBTRACT);
334:
335: case '*':
336: return(MULTIPLY);
337:
338: case '<':
339: c = exprgch();
340: if (c == '=')
341: {
342: return(LEQ);
343: }
344: ExprPeek = c;
345: return(LESS);
346:
347: case '>':
348: c = exprgch();
349: if (c == '=')
350: {
351: return(GEQ);
352: }
353: ExprPeek = c;
354: return(GREATER);
355:
356: case '%':
357: return(MOD);
358:
359: case '!':
360: c = exprgch();
361: if (c == '=')
362: {
363: return(NEQ);
364: }
365: else
366: {
367: printf("Operator expected: '!%c' found.\n", c);
368: ExprError = TRUE;
369: return(0);
370: }
371:
372: case ')':
373: return(RIGHTP);
374:
375: case ' ':
376: case '\t':
377: case '\n':
378: case '\0':
379: return(END);
380:
381: default:
382: printf("Operator expected: '%c' found.\n", c);
383: ExprError = TRUE;
384: return(0);
385:
386: }
387: }
388: /*
389: ** EXP_OP -- perform operation
390: **
391: ** Performs an operation between two values.
392: **
393: ** Parameters:
394: ** op -- the operation to perform.
395: ** lv -- the left operand.
396: ** rv -- the right operand.
397: **
398: ** Returns:
399: ** The value of the operation.
400: **
401: ** Side Effects:
402: ** none
403: **
404: ** Requires:
405: ** none
406: **
407: ** Called By:
408: ** valof.
409: **
410: ** Trace Flags:
411: ** none
412: **
413: ** Diagnostics:
414: ** none
415: */
416:
417: exp_op(op, lv, rv)
418: int op;
419: int lv;
420: int rv;
421: {
422: switch(op)
423: {
424:
425: case OR:
426: return((lv > 0) || (rv > 0));
427:
428: case AND:
429: return((lv > 0) && (rv > 0));
430:
431: case EQUALS:
432: return(lv == rv);
433:
434: case NEQ:
435: return(lv != rv);
436:
437: case LESS:
438: return(lv < rv);
439:
440: case LEQ:
441: return(lv <= rv);
442:
443: case GREATER:
444: return(lv > rv);
445:
446: case GEQ:
447: return(lv >= rv);
448:
449: case ADD:
450: return(lv + rv);
451:
452: case SUBTRACT:
453: return(lv - rv);
454:
455: case MULTIPLY:
456: return(lv * rv);
457:
458: case DIVIDE:
459: if (rv == 0)
460: {
461: printf("Divide by zero: zero assumed.\n");
462: return(0);
463: }
464: else
465: return(lv / rv);
466:
467: case MOD:
468: return(lv % rv);
469:
470: default:
471: syserr("exp_op: bad op %d", op);
472:
473: }
474: }
475: /*
476: ** NUMBERGET -- read and convert a number
477: **
478: ** Reads and converts a signed integer.
479: **
480: ** Parameters:
481: ** none
482: **
483: ** Returns:
484: ** The next number in the input stream.
485: **
486: ** Side Effects:
487: ** Gobbles input.
488: **
489: ** Requires:
490: ** exprgch.
491: **
492: ** Called By:
493: ** exprfind.
494: */
495:
496: numberget(cx)
497: char cx;
498: {
499: register int result;
500: register int c;
501:
502: c = cx;
503:
504: result = 0;
505: do
506: {
507: result = result * 10 + c - '0';
508: c = exprgch();
509: } while (c >= '0' && c <= '9');
510: ExprPeek = c;
511: return(result);
512: }
513: /*
514: ** EXPRGCH -- expression character get
515: **
516: ** Gets the next character from the expression input. Takes
517: ** a character out of ExprPeek first. Also maps spaces, tabs,
518: ** and newlines into zero bytes.
519: **
520: ** Parameters:
521: ** none
522: **
523: ** Returns:
524: ** Next character.
525: **
526: ** Side Effects:
527: ** Gobbles input.
528: ** Clears ExprPeek if set.
529: **
530: ** Requires:
531: ** ExprPeek -- the peek character.
532: ** macgetch -- to get the next character if ExprPeek
533: ** is not set.
534: */
535:
536: exprgch()
537: {
538: register int c;
539:
540: c = ExprPeek;
541: if (c < 0)
542: c = macgetch();
543: ExprPeek = -1;
544: if (c == ' ' || c == '\n' || c == '\t')
545: c = 0;
546: return (c);
547: }
548: /*
549: ** Stack operations.
550: */
551:
552:
553: /* Popop returns the top of the operator stack and decrements this stack. */
554: popop()
555: {
556: if (ExprOptr <= ExprOstack)
557: syserr("popop: underflow");
558: return(*--ExprOptr);
559: }
560:
561:
562:
563: /* Pushop increments the stack pointer and pushes op on the stack. */
564: pushop(op)
565: int op;
566: {
567: *ExprOptr++ = op;
568: }
569:
570:
571:
572: /* Popnum returns the top of the number stack and decrements the stack pointer. */
573: popnum()
574: {
575: if (ExprNptr <= ExprNstack)
576: syserr("popnum: underflow");
577: return(*--ExprNptr);
578: }
579:
580:
581:
582:
583: /* Pushnum increments the stack pointer and pushes num onto the stack */
584: pushnum(num)
585: int num;
586: {
587: *ExprNptr++ = num;
588: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.