![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to rval.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / pxp|
Return to rval.c CVS log | Up to [CSRG BSD Unix] / 43BSD / ucb / pascal / pxp |
1.1 root 1: /*
2: * Copyright (c) 1980 Regents of the University of California.
3: * All rights reserved. The Berkeley software License Agreement
4: * specifies the terms and conditions for redistribution.
5: */
6:
7: #ifndef lint
8: static char sccsid[] = "@(#)rval.c 5.1 (Berkeley) 6/5/85";
9: #endif not lint
10:
11: /*
12: * pxp - Pascal execution profiler
13: *
14: * Bill Joy UCB
15: * Version 1.2 January 1979
16: */
17:
18: #include "0.h"
19: #include "tree.h"
20:
21: extern char *opnames[];
22:
23: #define alph(c) ((c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z'))
24: /*
25: * Rvalue reformats an expression.
26: * Par is a flag indicating that the expression
27: * should be parenthesized if it is non-atomic.
28: */
29: rvalue(r, par)
30: register int *r;
31: int par;
32: {
33: register int *al;
34: register char *opname;
35:
36: if (r == NIL) {
37: ppid("{expr}");
38: return;
39: }
40: if (r[0] <= T_IN)
41: opname = opnames[r[0]];
42: switch (r[0]) {
43: case T_BINT:
44: case T_INT:
45: case T_FINT:
46: ppnumb(r[2]);
47: if (r[0] == T_BINT)
48: ppsep("b");
49: return;
50: case T_NIL:
51: ppkw("nil");
52: return;
53: case T_FCALL:
54: funccod(r);
55: return;
56: case T_VAR:
57: lvalue(r);
58: return;
59: case T_CSET:
60: cset(r);
61: return;
62: case T_STRNG:
63: ppstr(r[2]);
64: return;
65: }
66: if (par)
67: ppbra("(");
68: switch (r[0]) {
69: default:
70: panic("rval");
71: case T_PLUS:
72: case T_MINUS:
73: /*
74: * if child is relational (bogus) or adding operator,
75: * parenthesize child.
76: * this has the unaesthetic property that
77: * --i prints as -(-i), but is needed to catch
78: * -(a+b) which must print as -(a+b), not as -a+b.
79: * otherwise child has higher precedence
80: * and need not be parenthesized.
81: */
82: ppop(r[0] == T_PLUS ? "+" : "-");
83: al = r[2];
84: rvalue(r[2], prec(al) <= prec(r) || full);
85: break;
86: case T_NOT:
87: /*
88: * if child is of lesser precedence
89: * (i.e. not another not operator)
90: * parenthesize it.
91: * nested not operators need not be parenthesized
92: * because it's a prefix operator.
93: */
94: ppkw(opname);
95: ppspac();
96: al = r[2];
97: rvalue(r[2], prec(al) < prec(r) || full);
98: break;
99: case T_EQ:
100: case T_NE:
101: case T_GE:
102: case T_LE:
103: case T_GT:
104: case T_LT:
105: /*
106: * make the aesthetic choice to
107: * fully parenthesize relational expressions,
108: * in spite of left to right associativity.
109: * note: there are no operators with lower precedence.
110: */
111: al = r[2];
112: rvalue(al, prec(al) <= prec(r) || full);
113: goto rest;
114: case T_AND:
115: case T_OR:
116: case T_MULT:
117: case T_ADD:
118: case T_SUB:
119: case T_DIVD:
120: case T_MOD:
121: case T_DIV:
122: case T_IN:
123: /*
124: * need not parenthesize left child
125: * if it has equal precedence,
126: * due to left to right associativity.
127: * right child needs to be parenthesized
128: * if it has equal (or lesser) precedence.
129: */
130: al = r[2];
131: rvalue(al, prec(al) < prec(r) || full);
132: rest:
133: ppspac();
134: if (alph(opname[0]))
135: ppkw(opname);
136: else
137: ppop(opname);
138: ppspac();
139: al = r[3];
140: rvalue(al, prec(al) <= prec(r) || full);
141: break;
142: }
143: if (par)
144: ppket(")");
145: }
146:
147: /*
148: * Prec returns the precedence of an operator,
149: * with larger numbers indicating stronger binding.
150: * This is used to determine when parenthesization
151: * is needed on subexpressions.
152: */
153: prec(r)
154: register int *r;
155: {
156:
157: if (r == NIL)
158: return;
159: switch (r[0]) {
160: case T_NOT:
161: return (3);
162: case T_MULT:
163: case T_DIVD:
164: case T_DIV:
165: case T_MOD:
166: case T_AND:
167: return (2);
168: case T_ADD:
169: case T_SUB:
170: case T_OR:
171: case T_PLUS:
172: case T_MINUS:
173: return (1);
174: default:
175: return (0);
176: }
177: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.